EventDispatcherTest::dpScenariosCausingSubscribingFailure() - Code Metrics - thephpleague/event - Measure and Improve Code Quality continuously with Scrutinizer

dpScenariosCausingSubscribingFailure() A
last analyzed 2020-09-29 17:46 UTC

↳ Parent: EventDispatcherTest

Complexity

Conditions	1
Paths	1

Size

Total Lines

Duplication

Lines	0
Ratio	0 %

Importance

Changes

Metric	Value
dl	0
loc	34
rs	9.376
c	0
b	0
f	0
cc	1
nc	1
nop	0

1 Method

Rating	Name	Duplication	Size	Complexity
A	EventDispatcherTest.php$1 ➔ subscribeListeners()	0	3	1

<?php

declare(strict_types=1);

namespace League\Event;

use PHPUnit\Framework\TestCase;
use Psr\EventDispatcher\ListenerProviderInterface;
use stdClass;

class EventDispatcherTest extends TestCase
{
    /**
     * @test
     */
    public function listening_to_a_plain_object_event(): void
    {
        $dispatcher = new EventDispatcher();
        $listenerSpy = new ListenerSpy();
        $event = new stdClass;

        $dispatcher->subscribeTo(stdClass::class, $listenerSpy);
        $dispatcher->dispatch($event);
function acceptsInteger($int) { }

$x = '123'; // string "123"

// Instead of
acceptsInteger($x);

// we recommend to use
acceptsInteger((integer) $x);

        $this->assertTrue($listenerSpy->wasCalledWith($event));
function acceptsInteger($int) { }

$x = '123'; // string "123"

// Instead of
acceptsInteger($x);

// we recommend to use
acceptsInteger((integer) $x);
    }

    /**
     * @test
     */
    public function dispatching_returns_the_event_object(): void
    {
        $event = new stdClass();
        $dispatcher = new  EventDispatcher();

        $returnedEvent = $dispatcher->dispatch($event);
function acceptsInteger($int) { }

$x = '123'; // string "123"

// Instead of
acceptsInteger($x);

// we recommend to use
acceptsInteger((integer) $x);

        $this->assertSame($event, $returnedEvent);
    }

    /**
     * @test
     */
    public function listening_to_a_named_event(): void
    {
        $dispatcher = new EventDispatcher();
        $listenerSpy = new ListenerSpy();
        $event = new StubNamedEvent('event.name');

        $dispatcher->subscribeTo('event.name', $listenerSpy);
        $dispatcher->dispatch($event);
function acceptsInteger($int) { }

$x = '123'; // string "123"

// Instead of
acceptsInteger($x);

// we recommend to use
acceptsInteger((integer) $x);

        $this->assertTrue($listenerSpy->wasCalledWith($event));
function acceptsInteger($int) { }

$x = '123'; // string "123"

// Instead of
acceptsInteger($x);

// we recommend to use
acceptsInteger((integer) $x);
    }

    /**
     * @test
     */
    public function listening_to_a_named_event_ignores_other_names(): void
    {
        $dispatcher = new EventDispatcher();
        $listenerSpy = new ListenerSpy();
        $dispatcher->subscribeTo('event.name', $listenerSpy);
        $dispatcher->dispatch(new StubNamedEvent('event.name'));
function acceptsInteger($int) { }

$x = '123'; // string "123"

// Instead of
acceptsInteger($x);

// we recommend to use
acceptsInteger((integer) $x);
        $dispatcher->dispatch(new StubNamedEvent('other.event.name'));
function acceptsInteger($int) { }

$x = '123'; // string "123"

// Instead of
acceptsInteger($x);

// we recommend to use
acceptsInteger((integer) $x);

        $this->assertEquals(1, $listenerSpy->numberOfTimeCalled());
    }

    /**
     * @test
     */
    public function it_uses_a_provided_listener_provider(): void

    {
        $listenerSpy = new ListenerSpy();
        $provider = new PrioritizedListenerRegistry();
        $provider->subscribeTo(stdClass::class, $listenerSpy);
        $dispatcher = new EventDispatcher($provider);
        $event = new stdClass();

        $dispatcher->dispatch($event);
function acceptsInteger($int) { }

$x = '123'; // string "123"

// Instead of
acceptsInteger($x);

// we recommend to use
acceptsInteger((integer) $x);

        $this->assertTrue($listenerSpy->wasCalledWith($event));
function acceptsInteger($int) { }

$x = '123'; // string "123"

// Instead of
acceptsInteger($x);

// we recommend to use
acceptsInteger((integer) $x);
    }

    /**
     * @test
     */
    public function it_only_keeps_notifying_handlers_when_the_event_propagation_is_not_stopped(): void

    {
        $dispatcher = new EventDispatcher();
        $listenerSpy = new ListenerSpy();
        $event = new StubStoppableEvent();

        $dispatcher->subscribeTo(
            StubStoppableEvent::class,
            function (StubStoppableEvent $event) {
                $event->stopPropagation();
            }
        );
        $dispatcher->subscribeTo(StubStoppableEvent::class, $listenerSpy);
        $dispatcher->dispatch($event);
function acceptsInteger($int) { }

$x = '123'; // string "123"

// Instead of
acceptsInteger($x);

// we recommend to use
acceptsInteger((integer) $x);

        $this->assertFalse($listenerSpy->wasCalledWith($event));
function acceptsInteger($int) { }

$x = '123'; // string "123"

// Instead of
acceptsInteger($x);

// we recommend to use
acceptsInteger((integer) $x);
    }

    /**
     * @test
     */
    public function it_calls_one_time_listeners_one_time(): void
    {
        $normalListener = new ListenerSpy();
        $oneTimeListener = new ListenerSpy();

        $dispatcher = new EventDispatcher();
        $dispatcher->subscribeTo(stdClass::class, $normalListener);
        $dispatcher->subscribeOnceTo(stdClass::class, $oneTimeListener);

        $dispatcher->dispatch(new stdClass());
function acceptsInteger($int) { }

$x = '123'; // string "123"

// Instead of
acceptsInteger($x);

// we recommend to use
acceptsInteger((integer) $x);
        $dispatcher->dispatch(new stdClass());
function acceptsInteger($int) { }

$x = '123'; // string "123"

// Instead of
acceptsInteger($x);

// we recommend to use
acceptsInteger((integer) $x);
        $dispatcher->dispatch(new stdClass());
function acceptsInteger($int) { }

$x = '123'; // string "123"

// Instead of
acceptsInteger($x);

// we recommend to use
acceptsInteger((integer) $x);

        $this->assertEquals(1, $oneTimeListener->numberOfTimeCalled());
        $this->assertEquals(3, $normalListener->numberOfTimeCalled());
    }

    /**
     * @test
     * @dataProvider dpScenariosCausingSubscribingFailure
     */
    public function subscribing_does_not_work_when_the_underlying_provider_does_not_allow_subscribing(
        callable $scenario
    ): void {
        $provider = new class() implements ListenerProviderInterface {
            public function getListenersForEvent(object $event): iterable
            {
                return [];
            }
        };
        $dispatcher = new EventDispatcher($provider);

        $this->expectExceptionObject(
            UnableToSubscribeListener::becauseTheListenerProviderDoesNotAcceptListeners($provider)
        );

        $scenario($dispatcher);
    }

    public function dpScenariosCausingSubscribingFailure(): iterable
    {
        yield "subscribing" => [
            function (EventDispatcher $dispatcher) {
                $dispatcher->subscribeTo(
                    'event',
                    function () {
                    }
                );
            },
        ];

        yield "subscribing once" => [
            function (EventDispatcher $dispatcher) {
                $dispatcher->subscribeOnceTo(
                    'event',
                    function () {
                    }
                );
            },
        ];

        yield "subscribing from subscriber" => [
            function (EventDispatcher $dispatcher) {
                $dispatcher->subscribeListenersFrom(
                    new class() implements ListenerSubscriber {
                        public function subscribeListeners(ListenerRegistry $acceptor): void
                        {
                        }
                    }
                );
            },
        ];
    }

    /**
     * @test
     */
    public function listeners_are_prioritized(): void
    {
        $dispatcher = new EventDispatcher();
        $event = new StubMutableEvent('Hi!');
        $append = static function (string $value) {
            return static function (StubMutableEvent $event) use ($value) {
                $event->append(' ' . $value);
            };
        };
        $appendHello = $append('Hello,');
        $appendWorld = $append('World!');
        $appendGoodBye = $append('Good bye!');
        $dispatcher->subscribeTo(StubMutableEvent::class, $appendWorld, 0);
        $dispatcher->subscribeTo(StubMutableEvent::class, $appendHello, 10);
        $dispatcher->subscribeTo(StubMutableEvent::class, $appendGoodBye, -10);

        $dispatcher->dispatch($event);
function acceptsInteger($int) { }

$x = '123'; // string "123"

// Instead of
acceptsInteger($x);

// we recommend to use
acceptsInteger((integer) $x);

        $this->assertEquals('Hi! Hello, World! Good bye!', $event->value());
    }

    /**
     * @test
     */
    public function events_from_an_event_generator_can_be_dispatched(): void
    {
        $dispatcher = new EventDispatcher();
        $listener = new ListenerSpy();
        $dispatcher->subscribeTo(stdClass::class, $listener);

        $eventGenerator = new class() implements EventGenerator {
            use EventGeneratorBehavior {
                recordEvent as public;
            }
        };
        $eventGenerator->recordEvent(new stdClass());
function acceptsInteger($int) { }

$x = '123'; // string "123"

// Instead of
acceptsInteger($x);

// we recommend to use
acceptsInteger((integer) $x);
        $eventGenerator->recordEvent(new stdClass());
function acceptsInteger($int) { }

$x = '123'; // string "123"

// Instead of
acceptsInteger($x);

// we recommend to use
acceptsInteger((integer) $x);
        $eventGenerator->recordEvent(new stdClass());
function acceptsInteger($int) { }

$x = '123'; // string "123"

// Instead of
acceptsInteger($x);

// we recommend to use
acceptsInteger((integer) $x);
        $dispatcher->dispatchGeneratedEvents($eventGenerator);

        $this->assertEquals(3, $listener->numberOfTimeCalled());
    }

    /**
     * @test
     */
    public function listeners_can_be_subscribed_through_a_subscriber(): void
    {
        $subscriber = new class() implements ListenerSubscriber {
            public function subscribeListeners(ListenerRegistry $acceptor): void
            {
                $acceptor->subscribeTo(
                    StubMutableEvent::class,
                    function (StubMutableEvent $event) {
                        $event->append(' mutated');
                    }
                );
            }
        };
        $dispatcher = new EventDispatcher();
        $dispatcher->subscribeListenersFrom($subscriber);
        $event = new StubMutableEvent('this is');
        $dispatcher->dispatch($event);
function acceptsInteger($int) { }

$x = '123'; // string "123"

// Instead of
acceptsInteger($x);

// we recommend to use
acceptsInteger((integer) $x);

        $this->assertEquals('this is mutated', $event->value());
    }
}


1			<?php
2
3			declare(strict_types=1);
4
5			namespace League\Event;
6
7			use PHPUnit\Framework\TestCase;
8			use Psr\EventDispatcher\ListenerProviderInterface;
9			use stdClass;
10
11			class EventDispatcherTest extends TestCase
12			{
13			/**
14			* @test
15			*/
16			public function listening_to_a_plain_object_event(): void
17			{
18			$dispatcher = new EventDispatcher();
19			$listenerSpy = new ListenerSpy();
20			$event = new stdClass;
21
22			$dispatcher->subscribeTo(stdClass::class, $listenerSpy);
23			$dispatcher->dispatch($event);
			0 ignored issues – show Documentation introduced 2020-09-26 13:18 UTC by Report Bug Copy Issue Report `$event` is of type `object<stdClass>`, but the function expects a `object<League\Event\object>`. It seems like the type of the argument is not accepted by the function/method which you are calling. In some cases, in particular if PHP’s automatic type-juggling kicks in this might be fine. In other cases, however this might be a bug. We suggest to add an explicit type cast like in the following example: function acceptsInteger($int) { } $x = '123'; // string "123" // Instead of acceptsInteger($x); // we recommend to use acceptsInteger((integer) $x); Loading history...
24
25			$this->assertTrue($listenerSpy->wasCalledWith($event));
			0 ignored issues – show Documentation introduced 2020-09-26 13:18 UTC by Report Bug Copy Issue Report `$event` is of type `object<stdClass>`, but the function expects a `object<League\Event\object>`. It seems like the type of the argument is not accepted by the function/method which you are calling. In some cases, in particular if PHP’s automatic type-juggling kicks in this might be fine. In other cases, however this might be a bug. We suggest to add an explicit type cast like in the following example: function acceptsInteger($int) { } $x = '123'; // string "123" // Instead of acceptsInteger($x); // we recommend to use acceptsInteger((integer) $x); Loading history...
26			}
27
28			/**
29			* @test
30			*/
31			public function dispatching_returns_the_event_object(): void
32			{
33			$event = new stdClass();
34			$dispatcher = new EventDispatcher();
35
36			$returnedEvent = $dispatcher->dispatch($event);
			0 ignored issues – show Documentation introduced 2020-09-27 19:22 UTC by Report Bug Copy Issue Report `$event` is of type `object<stdClass>`, but the function expects a `object<League\Event\object>`. It seems like the type of the argument is not accepted by the function/method which you are calling. In some cases, in particular if PHP’s automatic type-juggling kicks in this might be fine. In other cases, however this might be a bug. We suggest to add an explicit type cast like in the following example: function acceptsInteger($int) { } $x = '123'; // string "123" // Instead of acceptsInteger($x); // we recommend to use acceptsInteger((integer) $x); Loading history...
37

thephpleague / event

dpScenariosCausingSubscribingFailure() A last analyzed 2020-09-29 17:46 UTC

Complexity

Size

Duplication

Importance

1 Method

Duplication Side-by-Side

Filter issues like

dpScenariosCausingSubscribingFailure() A
last analyzed 2020-09-29 17:46 UTC