Dsantang\DomainEventsDoctrine\Tests\Unit\Outbox\StubMapBasedTest

Complexity

Total Complexity

3

Size/Duplication

Total Lines	168
Duplicated Lines	0 %

Importance

Changes

0

11 Methods

Rating	Name	Duplication	Size	Complexity
A	setUpDependencies()	0	17	1
A	testGetDomainsEvents()	0	17	1
A	testPersist()	0	11	1
A	hp$2 ➔ trigger()	0	3	1
A	persistDataProvider()	0	12	1
A	hp$2 ➔ getEventArgs()	0	54	2
A	testOnFlushWithNoDomainEvents()	0	9	1
	getEventArgs()	0	54	?
A	hp$0 ➔ trigger()	0	3	1
A	testOnFlushWithDomainEvents()	0	9	1
A	hp$1 ➔ trigger()	0	3	1

<?php

declare(strict_types=1);

namespace Dsantang\DomainEventsDoctrine\Tests\Unit\Outbox;

use Doctrine\ORM\EntityManagerInterface;
use Doctrine\ORM\Event\OnFlushEventArgs;
use Doctrine\ORM\UnitOfWork;
use Dsantang\DomainEvents\Counter;
use Dsantang\DomainEvents\DomainEvent;
use Dsantang\DomainEvents\EventAware;
use Dsantang\DomainEvents\Registry\OrderedEventRegistry;
use Dsantang\DomainEventsDoctrine\Outbox\Converter;
use Dsantang\DomainEventsDoctrine\Tests\OutboxSubClass;
use Dsantang\DomainEventsDoctrine\Tests\Unit\Outbox\Stub\Converters\FirstOutboxConverter;
use Dsantang\DomainEventsDoctrine\Tests\Unit\Outbox\Stub\Converters\SecondOutboxConverter;
use Dsantang\DomainEventsDoctrine\Tests\Unit\Outbox\Stub\Converters\ThirdOutboxConverter;
use Dsantang\DomainEventsDoctrine\Tests\Unit\Outbox\Stub\DomainEvents\FirstDomainEvent;
use Dsantang\DomainEventsDoctrine\Tests\Unit\Outbox\Stub\DomainEvents\SecondDomainEvent;
use Dsantang\DomainEventsDoctrine\Tests\Unit\Outbox\Stub\DomainEvents\ThirdDomainEvent;
use Dsantang\DomainEventsDoctrine\Tests\Unit\Outbox\Stub\OutboxEntries\FirstOutboxEntry;
use Dsantang\DomainEventsDoctrine\Tests\Unit\Outbox\Stub\OutboxEntries\SecondOutboxEntry;
use Dsantang\DomainEventsDoctrine\Tests\Unit\Outbox\Stub\OutboxEntries\ThirdOutboxEntry;
use Dsantang\DomainEventsDoctrine\Tests\Unit\Outbox\Stub\StubMapBased;
use PHPUnit\Framework\MockObject\MockObject;
use PHPUnit\Framework\TestCase;
use function array_values;

final class StubMapBasedTest extends TestCase
{
    /** @var Converter[] */
    private $conversionMap;

    /** @var MockObject entityManager */
    private $entityManager;

    /** @var MockObject unitOfWork */
    private $unitOfWork;

    /**
     * @before
     */
    public function setUpDependencies() : void
    {
        $map = [
            'Dsantang\DomainEventsDoctrine\Tests\Unit\Outbox\Stub\DomainEvents\FirstDomainEvent'  =>
                new FirstOutboxConverter(),

            'Dsantang\DomainEventsDoctrine\Tests\Unit\Outbox\Stub\DomainEvents\SecondDomainEvent' =>
                new SecondOutboxConverter(),

            'Dsantang\DomainEventsDoctrine\Tests\Unit\Outbox\Stub\DomainEvents\ThirdDomainEvent'  =>
                new ThirdOutboxConverter(),
        ];

        $this->conversionMap = $map;

        $this->entityManager = $this->createMock(EntityManagerInterface::class);
        $this->unitOfWork    = $this->createMock(UnitOfWork::class);
    }

    public function testGetDomainsEvents() : void
    {
        Counter::reset();

        $eventArgs = $this->getEventArgs();

        self::assertEquals(3, Counter::getNext());

        $mapBasedEventsHandler = new StubMapBased(new OutboxSubClass(), $this->conversionMap);

        $eventsResult = $mapBasedEventsHandler->getDomainEvents($eventArgs);

        self::assertEquals(0, Counter::getNext());

        $eventsExpected = [new FirstDomainEvent(), new SecondDomainEvent(), new ThirdDomainEvent()];

        self::assertEquals(array_values($eventsResult), array_values($eventsExpected));
    }

    /**
     * @return mixed[] array
     */
    public function persistDataProvider() : array
    {
        return [
            [[], 0, 0],
            [[new FirstOutboxEntry(new FirstDomainEvent())], 1, 1],
            [
                [
                    new ThirdOutboxEntry(new ThirdDomainEvent()),
                    new FirstOutboxEntry(new FirstDomainEvent()),
                    new SecondOutboxEntry(new SecondDomainEvent()),
                ], 3,
                1,
            ],
        ];
    }

    /**
     * @param mixed[] $outboxEvents
     *
     * @dataProvider persistDataProvider
     */
    public function testPersist(array $outboxEvents, int $persistCalls, int $computeChangeSetsCalls) : void
    {
        $eventArgs = $this->getEventArgs();

        $mapBasedEventsHandler = new StubMapBased(new OutboxSubClass(), $this->conversionMap);

        $this->entityManager->expects(self::exactly($persistCalls))->method('persist');

        $this->unitOfWork->expects(self::exactly($computeChangeSetsCalls))->method('computeChangeSets');

        $mapBasedEventsHandler->persist($eventArgs->getEntityManager(), ...$outboxEvents);
    }

    public function testOnFlushWithDomainEvents() : void
    {
        $eventArgs = $this->getEventArgs();

        $mapBasedEventsHandler = new StubMapBased(new OutboxSubClass(), $this->conversionMap);

        $this->entityManager->expects(self::exactly(3))->method('persist');

        $mapBasedEventsHandler->onFlush($eventArgs);
    }

    public function testOnFlushWithNoDomainEvents() : void
    {
        $eventArgs = $this->getEventArgs(false);

        $mapBasedEventsHandler = new StubMapBased(new OutboxSubClass(), $this->conversionMap);

        $this->unitOfWork->expects(self::never())->method('computeChangeSets');

        $mapBasedEventsHandler->onFlush($eventArgs);
    }

    /**
     * @return OnFlushEventArgs|MockObject
     */
    private function getEventArgs(bool $withEvents = true) : OnFlushEventArgs
    {
        $insertions = $updates = $deletions = [];

        if ($withEvents) {
            $entity1 = new class() implements EventAware {
                use OrderedEventRegistry;

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

            $entity2 = new class() implements EventAware {
                use OrderedEventRegistry;

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

            $entity3 = new class() implements EventAware {
                use OrderedEventRegistry;

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

            $domainEvent1 = new FirstDomainEvent();
            $domainEvent2 = new SecondDomainEvent();
            $domainEvent3 = new ThirdDomainEvent();

            $entity1->trigger($domainEvent1);
            $entity2->trigger($domainEvent2);
            $entity3->trigger($domainEvent3);

            $updates   = [$entity3];
            $deletions = [$entity2, $entity1];
        }

        $this->unitOfWork->expects(self::any())->method('getScheduledEntityInsertions')->willReturn($insertions);
        $this->unitOfWork->expects(self::any())->method('getScheduledEntityUpdates')->willReturn($updates);
        $this->unitOfWork->expects(self::any())->method('getScheduledEntityDeletions')->willReturn($deletions);

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

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

        return $eventArgs;

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

    }
}