MapBasedTest::testPersist() - Code Metrics - Inspection of "Outbox workflow based on doctrine events" - dsantang/domain-events-doctrine - Measure and Improve Code Quality continuously with Scrutinizer

Passed
Pull Request — master (#7)

by Fábio Tadeu da
created 2019-04-09 13:51 UTC
MapBasedTest::testPersist() A

↳ Parent: MapBasedTest
Complexity

Conditions	1
Paths	1
Size

Total Lines	23
Code Lines	15
Duplication

Lines	0
Ratio	0 %
Importance

Changes
Metric	Value
eloc	15
dl	0
loc	23
rs	9.7666
c	0
b	0
f	0
cc	1
nc	1
nop	0
<?php

declare(strict_types=1);

namespace Dsantang\DomainEventsDoctrine\Tests\Unit\Outbox;

use Doctrine\Common\EventArgs;
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\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 InvalidArgumentException;
use PHPUnit\Framework\TestCase;
use stdClass;
use function array_pop;
use function array_values;

final class MapBasedTest extends TestCase
{
    /** @var converter[] */
    private $conversionMap;

    /** @var StubMapBased */
    private $mapBasedEventsHandler;

    /**
     * @before
     */
    public function setUpDependencies() : void
    {
        $this->conversionMap =
            [

                '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(),
            ];
    }

    public function testDealWithInvalidConversionMap() : void
    {
        $this->expectException(InvalidArgumentException::class);

        $this->conversionMap = [

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

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

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

        $eventArgs = $this->getEventArgs();

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

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

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

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

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

        $this->assertEquals(array_values($eventsResult), array_values($eventsExpected));
    }

    public function testConvert() : void
    {
        $this->mapBasedEventsHandler = new StubMapBased(new OutboxSubClass(), $this->conversionMap);

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

        $returnedOutboxEvents = $this->mapBasedEventsHandler->convert(...$domainEvents);

        $expectedOutboxEvents = [
            (new ThirdOutboxConverter())->convert(new ThirdDomainEvent()),
            (new FirstOutboxConverter())->convert(new FirstDomainEvent()),
            (new SecondOutboxConverter())->convert(new SecondDomainEvent()),
        ];

        self::assertEquals($expectedOutboxEvents, $returnedOutboxEvents);
    }

    public function testConvertWithANonOutboxEntryDomainEvent() : void
    {
        array_pop($this->conversionMap);
        $this->mapBasedEventsHandler = new StubMapBased(new OutboxSubClass(), $this->conversionMap);

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

        $returnedOutboxEvents = $this->mapBasedEventsHandler->convert(...$domainEvents);

        $expectedOutboxEvents = [
            (new FirstOutboxConverter())->convert(new FirstDomainEvent()),
            (new SecondOutboxConverter())->convert(new SecondDomainEvent()),
        ];

        self::assertEquals($expectedOutboxEvents, $returnedOutboxEvents);
    }

    public function testPersist() : void
    {
        $eventArgs      = $this->getEventArgs();
        $outboxSubClass = new OutboxSubClass();

        $this->mapBasedEventsHandler = new StubMapBased($outboxSubClass, $this->conversionMap);
        $this->mapBasedEventsHandler->getDomainEvents($eventArgs);

        $outboxEvents = [
            new ThirdOutboxEntry(new ThirdDomainEvent()),
            new FirstOutboxEntry(new FirstDomainEvent()),
            new SecondOutboxEntry(new SecondDomainEvent()),
        ];

        $eventArgs->getEntityManager()->getUnitOfWork()->expects(self::once())
                    getEntityManager()->getUnitOfWork()->expects(self::once())
            ->method('computeChangeSets');

        $eventArgs->getEntityManager()->expects(self::exactly(3))
            ->method('persist');

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

    private function getEventArgs() : EventArgs
    {
        $entity1 = $this->getEntityClass();
        $entity2 = $this->getEntityClass();
        $entity3 = $this->getEntityClass();

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

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

        $unitOfWork = $this->createMock(UnitOfWork::class);
        $unitOfWork->expects(self::once())->method('getScheduledEntityInsertions')->willReturn([]);
        $unitOfWork->expects(self::once())->method('getScheduledEntityUpdates')->willReturn([$entity3]);
        $unitOfWork->expects(self::once())->method('getScheduledEntityDeletions')->willReturn([$entity2, $entity1]);

        $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;

    }

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

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

dsantang / domain-events-doctrine

GitHub Access Token became invalid

Pull Request — master (#7)

MapBasedTest::testPersist() A

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like
