EventDispatcherTest.php

Go to the documentation of this file.

<?php
 
declare(strict_types=1);
 
/*
 * This file is part of the TYPO3 CMS project.
 *
 * It is free software; you can redistribute it and/or modify it under
 * the terms of the GNU General Public License, either version 2
 * of the License, or any later version.
 *
 * For the full copyright and license information, please read the
 * LICENSE.txt file that was distributed with this source code.
 *
 * The TYPO3 project - inspiring people to share!
 */
 
namespace ‪TYPO3\CMS\Core\Tests\Unit\EventDispatcher;
 
use Prophecy\PhpUnit\ProphecyTrait;
use Prophecy\Prophecy\ObjectProphecy;
use Psr\EventDispatcher\EventDispatcherInterface;
use Psr\EventDispatcher\ListenerProviderInterface;
use Psr\EventDispatcher\StoppableEventInterface;
use ‪TYPO3\CMS\Core\EventDispatcher\EventDispatcher;
use TYPO3\TestingFramework\Core\Unit\UnitTestCase;
 
class ‪EventDispatcherTest extends UnitTestCase
{
    use ProphecyTrait;
 
    protected ObjectProphecy ‪$listenerProviderProphecy;
 
    protected ‪EventDispatcher ‪$eventDispatcher;
 
    protected function ‪setUp(): void
    {
        parent::setUp();
        $this->listenerProviderProphecy = $this->prophesize(ListenerProviderInterface::class);
        $this->eventDispatcher = new ‪EventDispatcher(
            $this->listenerProviderProphecy->reveal()
        );
    }
 
    public function ‪implementsPsrInterface(): void
    {
        self::assertInstanceOf(EventDispatcherInterface::class, $this->eventDispatcher);
    }
 
    public function ‪dispatchesEvent(callable $callable): void
    {
        $event = new \stdClass();
        $event->invoked = 0;
 
        $this->listenerProviderProphecy->getListenersForEvent($event)->will(static function () use ($callable): iterable {
            yield $callable;
        });
 
        $ret = $this->eventDispatcher->dispatch($event);
        self::assertSame($event, $ret);
        self::assertEquals(1, $event->invoked);
    }
 
    public function ‪doesNotDispatchStoppedEvent(callable $callable): void
    {
        $event = new class () implements StoppableEventInterface {
            public $invoked = 0;
 
            public function isPropagationStopped(): bool
            {
                return true;
            }
        };
 
        $this->listenerProviderProphecy->getListenersForEvent($event)->will(static function () use ($callable): iterable {
            yield $callable;
        });
 
        $ret = $this->eventDispatcher->dispatch($event);
        self::assertSame($event, $ret);
        self::assertEquals(0, $event->invoked);
    }
 
    public function ‪dispatchesMultipleListeners(callable $callable): void
    {
        $event = new \stdClass();
        $event->invoked = 0;
 
        $this->listenerProviderProphecy->getListenersForEvent($event)->will(static function () use ($callable): iterable {
            yield $callable;
            yield $callable;
        });
 
        $ret = $this->eventDispatcher->dispatch($event);
        self::assertSame($event, $ret);
        self::assertEquals(2, $event->invoked);
    }
 
    public function ‪stopsOnStoppedEvent(callable $callable): void
    {
        $event = new class () implements StoppableEventInterface {
            public $invoked = 0;
            public $stopped = false;
 
            public function isPropagationStopped(): bool
            {
                return $this->stopped;
            }
        };
 
        $this->listenerProviderProphecy->getListenersForEvent($event)->will(static function () use ($callable): iterable {
            yield $callable;
            yield static function (object $event): void {
                $event->invoked += 1;
                $event->stopped = true;
            };
            yield $callable;
        });
 
        $ret = $this->eventDispatcher->dispatch($event);
        self::assertSame($event, $ret);
        self::assertEquals(2, $event->invoked);
    }
 
    public function ‪listenerExceptionIsPropagated(): void
    {
        $this->expectException(\BadMethodCallException::class);
        $this->expectExceptionCode(1563270337);
 
        $event = new \stdClass();
 
        $this->listenerProviderProphecy->getListenersForEvent($event)->will(static function (): iterable {
            yield static function (object $event): void {
                throw new \BadMethodCallException('some invalid state', 1563270337);
            };
        });
 
        $this->eventDispatcher->dispatch($event);
    }
 
    public function ‪callables(): array
    {
        return [
            [
                // Invokable
                new class () {
                    public function __invoke(object $event): void
                    {
                        $event->invoked += 1;
                    }
                },
            ],
            [
                // Class + method
                [
                    new class () {
                        public function onEvent(object $event): void
                        {
                            $event->invoked += 1;
                        }
                    },
                    'onEvent',
                ],
            ],
            [
                // Closure
                static function (object $event): void {
                    $event->invoked += 1;
                },
            ],
        ];
    }
}