LazyListenerTest::testLazyListenerWillCreateAndDispatchEvent() - Code Metrics - Inspection of "Feature/2.0.0" - alex-patterson-webdev/event-dispatcher - Measure and Improve Code Quality continuously with Scrutinizer

Passed

Pull Request — master (#18)

by Alex

created 2022-03-18 19:35 UTC

testLazyListenerWillCreateAndDispatchEvent() A

↳ Parent: LazyListenerTest

Complexity

Conditions	1
Paths	1

Size

Total Lines	10
Code Lines	3

Duplication

Lines	0
Ratio	0 %

Importance

Changes

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

<?php

declare(strict_types=1);

namespace ArpTest\EventDispatcher\Listener;

use Arp\EventDispatcher\Listener\Exception\EventListenerException;
use Arp\EventDispatcher\Listener\LazyListener;
use PHPUnit\Framework\ExpectationFailedException;
use PHPUnit\Framework\TestCase;

/**
 * @covers  \Arp\EventDispatcher\Listener\LazyListener
 *
 * @author  Alex Patterson <[email protected]>
 * @package ArpTest\EventDispatcher\Listener
 */
final class LazyListenerTest extends TestCase
{
    /**
     * testIsCallable
     */
    public function testIsCallable(): void
    {
        $listener = new LazyListener(
            static function () {
            }
        );

        $this->assertIsCallable($listener);
    }

    /**
     * Assert a EventListenerException is thrown from __construct if the provided $factory is invalid
     *
     * @param mixed $factory
     *
     * @dataProvider getConstructWillThrowEventListenerExceptionIfTheConfiguredFactoryIsNotCallableData
     */
    public function testConstructWillThrowEventListenerExceptionIfTheConfiguredFactoryIsNotCallable($factory): void
    {
        $this->expectException(EventListenerException::class);
        $this->expectExceptionMessage(
            sprintf(
                'The event listener factory must be of type \'callable\' or \'object\'; \'%s\' provided in \'%s\'',
                is_object($factory) ? get_class($factory) : gettype($factory),
                LazyListener::class
            )
        );

        new LazyListener($factory);
    }

    /**
     * @return array<mixed>
     */
    public function getConstructWillThrowEventListenerExceptionIfTheConfiguredFactoryIsNotCallableData(): array
    {
        return [
            ['hello'],
            [true],
            [123],
        ];
    }

    /**
     * Assert that non-callable factory methods will raise a EventListenerException in __invoke()
     *
     * @throws EventListenerException
     */
    public function testInvokeWillThrowEventListenerExceptionIfTheFactoryMethodIsNotCallable(): void
    {
        $event = new \stdClass();
        $factory = new \stdClass();

        $lazyListener = new LazyListener($factory);

        $this->expectException(EventListenerException::class);
        $this->expectExceptionMessage(
            sprintf(
                'The method \'%s\' is not callable for lazy load factory \'%s\'',
                '__invoke',
                'array'
            )
        );

        $lazyListener($event);
    }

    /**
     * Assert that a non-callable listener method will raise a EventListenerException in __invoke()
     *
     * @throws EventListenerException
     */
    public function testInvokeWillThrowEventListenerExceptionIfTheListenerMethodIsNotCallable(): void
    {
        $event = new \stdClass();
        $listener = new \stdClass();
        $factory = static fn () => $listener;

        $lazyListener = new LazyListener($factory);

        $this->expectException(EventListenerException::class);
        $this->expectExceptionMessage(
            sprintf(
                'The method \'%s\' is not callable for lazy load event listener \'%s\'',
                '__invoke',
                'array'
            )
        );

        $lazyListener($event);
    }

    /**
     * @param mixed       $expected
     * @param mixed       $factory
     * @param string|null $factoryMethod
     * @param string|null $listenerMethod
     *
     * @throws EventListenerException
     * @throws ExpectationFailedException
     *
     * @dataProvider getLazyListenerWillCreateAndDispatchEventData
     */
    public function testLazyListenerWillCreateAndDispatchEvent(
        $expected,
        $factory,
        ?string $factoryMethod = null,
        ?string $listenerMethod = null
    ): void {
        $event = new \stdClass();
        $lazyListener = new LazyListener($factory, $factoryMethod, $listenerMethod);

        $this->assertSame($expected, $lazyListener($event));
    }

    /**
     * @return array<mixed>
     */
    public function getLazyListenerWillCreateAndDispatchEventData(): array
    {
        $factory1 = new class () {
            public function create(): callable
            {
                return static fn () => 'hello123';
            }
        };

        $listener1 = new class () {
            public function doSomething(object $event): string
            public function doSomething(/** @scrutinizer ignore-unused */ object $event): string
            {
                return 'test123';
            }
        };

        $factory2 = new class ($listener1) {
            private object $listener;

            public function __construct(object $listener)
            {
                $this->listener = $listener;
            }

            public function create(): object
            {
                return $this->listener;
            }
        };

        return [
            [
                'hello123',
                static fn () => static fn () => 'hello123',
            ],

            [
                'hello123',
                $factory1,
                'create'
            ],

            [
                'test123',
                $factory2,
                'create',
                'doSomething',
            ]
        ];
    }
}


alex-patterson-webdev / event-dispatcher

Pull Request — master (#18)

testLazyListenerWillCreateAndDispatchEvent() A

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like