Dsantang\DomainEventsDoctrine\Tests\Integration\MapBasedEventsHandlerTest::getEntityClass()

Size

Total Lines	8
Code Lines	3

Duplication

Lines	0
Ratio	0 %

Importance

Changes

0

1 Method

Rating	Name	Duplication	Size	Complexity
A	MapBasedEventsHandlerTest.php$0 ➔ trigger()	0	3	1

<?php

declare(strict_types=1);

namespace Dsantang\DomainEventsDoctrine\Tests\Integration;

use Doctrine\Common\EventArgs;
use Doctrine\ORM\EntityManagerInterface;
use Doctrine\ORM\Event\OnFlushEventArgs;
use Doctrine\ORM\UnitOfWork;
use Dsantang\DomainEvents\DomainEvent;
use Dsantang\DomainEvents\EventAware;
use Dsantang\DomainEvents\Registry\OrderedEventRegistry;
use Dsantang\DomainEventsDoctrine\Outbox\EventsHandler;
use Dsantang\DomainEventsDoctrine\Outbox\MapBased;
use Dsantang\DomainEventsDoctrine\Tests\OutboxSubClass;
use Dsantang\DomainEventsDoctrine\Tests\Unit\Outbox\Stub\Converters\FirstOutboxConverter;
use Dsantang\DomainEventsDoctrine\Tests\Unit\Outbox\Stub\DomainEvents\FirstDomainEvent;
use PHPUnit\Framework\TestCase;

final class MapBasedEventsHandlerTest extends TestCase
{
    /** @var EventsHandler */
    private $mapBasedEventsHandler;

    /**
     * @before
     */
    public function setUpDependencies() : void
    {
        $this->mapBasedEventsHandler = new MapBased(
            new OutboxSubClass(),
            [
                'Dsantang\DomainEventsDoctrine\Tests\Unit\Outbox\Stub\DomainEvents\FirstDomainEvent'  =>
                    new FirstOutboxConverter(),
            ]
        );
    }

    public function testOutboxHappyPathWorkflowOnFlushEvent() : void
    {
        $entity      = $this->getEntityClass();
        $domainEvent = new FirstDomainEvent();
        $entity->trigger($domainEvent);

        $eventArgs = $this->getEventArgs($entity);

        $this->mapBasedEventsHandler->onFlush($eventArgs);
    }


    private function getEventArgs(EventAware $entity) : EventArgs
    {
        $unitOfWork = $this->createMock(UnitOfWork::class);
        $unitOfWork->expects(self::once())->method('getScheduledEntityInsertions')->willReturn([$entity]);
        $unitOfWork->expects(self::once())->method('getScheduledEntityUpdates')->willReturn([]);
        $unitOfWork->expects(self::once())->method('getScheduledEntityDeletions')->willReturn([]);

        $entityManager = $this->createMock(EntityManagerInterface::class);
        $entityManager->expects(self::any())->method('getUnitOfWork')->willReturn($unitOfWork);

        $eventArgs = $this->createMock(OnFlushEventArgs::class);
        $eventArgs->expects(self::any())->method('getEntityManager')->willReturn($entityManager);

        return $eventArgs;

The expression return $eventArgs returns the type PHPUnit\Framework\MockObject\MockObject which is incompatible with the type-hinted return Doctrine\Common\EventArgs.

    }

    private function getEntityClass() : EventAware
    {
        return new class() implements EventAware {
            use OrderedEventRegistry;

            public function trigger(DomainEvent $event) : void
            {
                $this->triggeredA($event);
            }
        };
    }
}