EventTest::tearDown() - Code Metrics - Inspection of "Event 单元测试" - top-think/framework - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Push — 6.0 ( 92d464...2656ee )

by yun

created 2019-09-16 03:48 UTC

EventTest::tearDown() A

↳ Parent: EventTest

Complexity

Conditions	1
Paths	1

Size

Total Lines	3
Code Lines	1

Duplication

Lines	0
Ratio	0 %

Importance

Changes	1
Bugs	0	Features	0

Metric	Value
cc	1
eloc	1
nc	1
nop	0
dl	0
loc	3
rs	10
c	1
b	0
f	0

<?php


namespace think\tests;

use Mockery as m;
use Mockery\MockInterface;
use PHPUnit\Framework\TestCase;
use think\App;
use think\Config;
use think\Container;
use think\Event;

class EventTest extends TestCase
{
    /** @var App|MockInterface */

    protected $app;

    /** @var Event|MockInterface */

    protected $event;

    /** @var Config|MockInterface */

    protected $config;

    protected function tearDown(): void

    {
        m::close();
    }

    protected function setUp()

    {
        $this->app = m::mock(App::class)->makePartial();

        Container::setInstance($this->app);
        $this->app->shouldReceive('make')->with(App::class)->andReturn($this->app);
        $this->config = m::mock(Config::class)->makePartial();
        $this->app->shouldReceive('get')->with('config')->andReturn($this->config);

        $this->event = new Event($this->app);
        $this->event = new Event(/** @scrutinizer ignore-type */ $this->app);
    }

    public function testBasic()

    {
        $this->event->bind(['foo' => 'baz']);

        $this->event->listen('foo', function ($bar) {

            $this->assertEquals('bar', $bar);
        });
someFunctionCall(
    $firstArgument,
    $secondArgument,
    $thirdArgument
); // Closing parenthesis on a new line.

        $this->assertTrue($this->event->hasListener('foo'));

        $this->event->trigger('baz', 'bar');

        $this->event->remove('foo');

        $this->assertFalse($this->event->hasListener('foo'));
    }

    public function testOnceEvent()

    {
        $this->event->listen('AppInit', function ($bar) {

            $this->assertEquals('bar', $bar);
            return 'foo';
        });
someFunctionCall(
    $firstArgument,
    $secondArgument,
    $thirdArgument
); // Closing parenthesis on a new line.

        $this->assertEquals('foo', $this->event->trigger('AppInit', 'bar', true));
        $this->assertEquals(['foo'], $this->event->trigger('AppInit', 'bar'));
    }

    public function testClassListener()

    {
        $listener = m::mock("overload:SomeListener", TestListener::class);

        $listener->shouldReceive('handle')->andReturnTrue();
        $listener->shouldReceive('handle')->/** @scrutinizer ignore-call */ andReturnTrue();

        $this->event->listen('some', "SomeListener");

        $this->assertTrue($this->event->until('some'));;
    }

    public function testSubscribe()

    {
        $listener = m::mock("overload:SomeListener", TestListener::class);

        $listener->shouldReceive('subscribe')->andReturnUsing(function (Event $event) use ($listener) {
        $listener->shouldReceive('subscribe')->/** @scrutinizer ignore-call */ andReturnUsing(function (Event $event) use ($listener) {

            $listener->shouldReceive('onBar')->once()->andReturnFalse();
            $listener->shouldReceive('onBar')->once()->/** @scrutinizer ignore-call */ andReturnFalse();

            $event->listenEvents(['SomeListener::onBar' => [[$listener, 'onBar']]]);
        });
someFunctionCall(
    $firstArgument,
    $secondArgument,
    $thirdArgument
); // Closing parenthesis on a new line.

        $this->event->subscribe('SomeListener');

        $this->assertTrue($this->event->hasListener('SomeListener::onBar'));

        $this->event->trigger('SomeListener::onBar');
    }

    public function testObserve()

    {
        $listener = m::mock("overload:SomeListener", TestListener::class);

        $listener->shouldReceive('onBar')->once();

        $this->event->observe('SomeListener', ['bar', 'foo']);

        $this->event->trigger('bar');
    }

    public function testAutoObserve()

    {
        $listener = m::mock("overload:SomeListener", TestListener::class);

        $listener->shouldReceive('onBar')->once();

        $this->app->shouldReceive('make')->with('SomeListener')->andReturn($listener);
                    shouldReceive('make')->with('SomeListener')->andReturn($listener);

        $this->event->observe('SomeListener');

        $this->event->trigger('bar');
    }

    public function testWithoutEvent()

    {
        $this->event->withEvent(false);

        $this->event->listen('SomeListener', TestListener::class);

        $this->assertFalse($this->event->hasListener('SomeListener'));
    }

}

class TestListener
{
    public function handle()

    {

    }

    public function onBar()

    {

    }

    public function onFoo()

    {

    }

    public function subscribe()

    {

    }
}


top-think / framework

Push — 6.0 ( 92d464...2656ee )

EventTest::tearDown() A

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like