Yiisoft\EventDispatcher\Tests\Provider\ProviderTest

Complexity

Total Complexity

8

Size/Duplication

Total Lines	94
Duplicated Lines	0 %

Importance

Changes	2
Bugs	0	Features	0

7 Methods

Rating	Name	Duplication	Size	Complexity
A	testInvokable()	0	7	1
A	testAttachCallableObject()	0	7	1
A	testAttachCallableArray()	0	7	1
A	testAttachCallableFunction()	0	7	1
A	testAttachClosure()	0	9	1
A	testListenersForClassHierarchyAreReturned()	0	35	2
A	testListenerWithNoParameterThrowsException()	0	8	1

<?php

namespace Yiisoft\EventDispatcher\Tests\Provider;

use PHPUnit\Framework\TestCase;
use Yiisoft\EventDispatcher\Provider\Provider;
use Yiisoft\EventDispatcher\Tests\Event\ClassItself;
use Yiisoft\EventDispatcher\Tests\Event\Event;
use Yiisoft\EventDispatcher\Tests\Event\ParentClass;
use Yiisoft\EventDispatcher\Tests\Event\ParentInterface;
use Yiisoft\EventDispatcher\Tests\Event\ClassInterface;
use Yiisoft\EventDispatcher\Tests\Listener\Invokable;
use Yiisoft\EventDispatcher\Tests\Listener\NonStatic;
use Yiisoft\EventDispatcher\Tests\Listener\WithStaticMethod;

final class ProviderTest extends TestCase
{
    public function testAttachCallableArray(): void
    {
        $provider = new Provider();
        $provider->attach([WithStaticMethod::class, 'handle']);

        $listeners = $provider->getListenersForEvent(new Event());
        $this->assertCount(1, $listeners);
    }

    public function testAttachCallableFunction(): void
    {
        $provider = new Provider();
        $provider->attach('Yiisoft\EventDispatcher\Tests\Provider\handle');

        $listeners = $provider->getListenersForEvent(new Event());
        $this->assertCount(1, $listeners);
    }

    public function testAttachClosure(): void
    {
        $provider = new Provider();
        $provider->attach(function (Event $event) {

The parameter $event is not used and could be removed.

            // do nothing
        });

        $listeners = $provider->getListenersForEvent(new Event());
        $this->assertCount(1, $listeners);
    }

    public function testAttachCallableObject(): void
    {
        $provider = new Provider();
        $provider->attach([new NonStatic(), 'handle']);

        $listeners = $provider->getListenersForEvent(new Event());
        $this->assertCount(1, $listeners);
    }

    public function testInvokable(): void
    {
        $provider = new Provider();
        $provider->attach(new Invokable());

        $listeners = $provider->getListenersForEvent(new Event());
        $this->assertCount(1, $listeners);
    }

    public function testListenersForClassHierarchyAreReturned(): void
    {
        $provider = new Provider();

        $provider->attach(function (ParentInterface $parentInterface) {
            $parentInterface->register('parent interface');
        });
        $provider->attach(function (ParentClass $parentClass) {
            $parentClass->register('parent class');
        });
        $provider->attach(function (ClassInterface $classInterface) {
            $classInterface->register('class interface');
        });
        $provider->attach(function (ClassItself $classItself) {
            $classItself->register('class itself');
        });

        $event = new ClassItself();
        foreach ($provider->getListenersForEvent($event) as $listener) {
            $listener($event);
        }

        $classHierarchyHandlers = array_slice($event->registered(), 0, 2);
        $interfaceHandlers = array_slice($event->registered(), 2);

        $this->assertEquals(
            [
                'class itself',
                'parent class'
            ],
            $classHierarchyHandlers
        );

        $this->assertContains('class interface', $interfaceHandlers);
        $this->assertContains('parent interface', $interfaceHandlers);
    }

    public function testListenerWithNoParameterThrowsException(): void
    {
        $provider = new Provider();

        $this->expectException(\InvalidArgumentException::class);
        $this->expectExceptionMessage('Listeners must declare an object type they can accept.');

        $provider->attach(fn () => null);
    }
}

function handle(Event $event): void

The parameter $event is not used and could be removed.

{
    // do nothing
}