StubMapBasedTest::testOnFlushWithNoDomainEvents() - 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-10 12:31 UTC

StubMapBasedTest::testOnFlushWithNoDomainEvents() A

↳ Parent: StubMapBasedTest

Complexity

Conditions	1
Paths	1

Size

Total Lines	9
Code Lines	4

Duplication

Lines	0
Ratio	0 %

Importance

Changes

Metric	Value
eloc	4
dl	0
loc	9
rs	10
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\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;

    }
}


1			<?php
2
3			declare(strict_types=1);
4
5			namespace Dsantang\DomainEventsDoctrine\Tests\Unit\Outbox;
6
7			use Doctrine\ORM\EntityManagerInterface;
8			use Doctrine\ORM\Event\OnFlushEventArgs;
9			use Doctrine\ORM\UnitOfWork;
10			use Dsantang\DomainEvents\Counter;
11			use Dsantang\DomainEvents\DomainEvent;
12			use Dsantang\DomainEvents\EventAware;
13			use Dsantang\DomainEvents\Registry\OrderedEventRegistry;
14			use Dsantang\DomainEventsDoctrine\Outbox\Converter;
15			use Dsantang\DomainEventsDoctrine\Tests\OutboxSubClass;
16			use Dsantang\DomainEventsDoctrine\Tests\Unit\Outbox\Stub\Converters\FirstOutboxConverter;
17			use Dsantang\DomainEventsDoctrine\Tests\Unit\Outbox\Stub\Converters\SecondOutboxConverter;
18			use Dsantang\DomainEventsDoctrine\Tests\Unit\Outbox\Stub\Converters\ThirdOutboxConverter;
19			use Dsantang\DomainEventsDoctrine\Tests\Unit\Outbox\Stub\DomainEvents\FirstDomainEvent;
20			use Dsantang\DomainEventsDoctrine\Tests\Unit\Outbox\Stub\DomainEvents\SecondDomainEvent;
21			use Dsantang\DomainEventsDoctrine\Tests\Unit\Outbox\Stub\DomainEvents\ThirdDomainEvent;
22			use Dsantang\DomainEventsDoctrine\Tests\Unit\Outbox\Stub\OutboxEntries\FirstOutboxEntry;
23			use Dsantang\DomainEventsDoctrine\Tests\Unit\Outbox\Stub\OutboxEntries\SecondOutboxEntry;
24			use Dsantang\DomainEventsDoctrine\Tests\Unit\Outbox\Stub\OutboxEntries\ThirdOutboxEntry;
25			use Dsantang\DomainEventsDoctrine\Tests\Unit\Outbox\Stub\StubMapBased;
26			use PHPUnit\Framework\MockObject\MockObject;
27			use PHPUnit\Framework\TestCase;
28			use function array_values;
29
30			final class StubMapBasedTest extends TestCase
31			{
32			/** @var Converter[] */
33			private $conversionMap;
34
35			/** @var MockObject entityManager */
36			private $entityManager;
37
38			/** @var MockObject unitOfWork */
39			private $unitOfWork;
40
41			/**
42			* @before
43			*/
44			public function setUpDependencies() : void
45			{
46			$map = [
47			'Dsantang\DomainEventsDoctrine\Tests\Unit\Outbox\Stub\DomainEvents\FirstDomainEvent' =>
48			new FirstOutboxConverter(),
49
50			'Dsantang\DomainEventsDoctrine\Tests\Unit\Outbox\Stub\DomainEvents\SecondDomainEvent' =>
51			new SecondOutboxConverter(),
52
53			'Dsantang\DomainEventsDoctrine\Tests\Unit\Outbox\Stub\DomainEvents\ThirdDomainEvent' =>
54			new ThirdOutboxConverter(),
55			];
56
57			$this->conversionMap = $map;
58
59			$this->entityManager = $this->createMock(EntityManagerInterface::class);
60			$this->unitOfWork = $this->createMock(UnitOfWork::class);
61			}
62
63			public function testGetDomainsEvents() : void
64			{
65			Counter::reset();
66
67			$eventArgs = $this->getEventArgs();
68
69			self::assertEquals(3, Counter::getNext());
70
71			$mapBasedEventsHandler = new StubMapBased(new OutboxSubClass(), $this->conversionMap);
72
73			$eventsResult = $mapBasedEventsHandler->getDomainEvents($eventArgs);
74
75			self::assertEquals(0, Counter::getNext());
76
77			$eventsExpected = [new FirstDomainEvent(), new SecondDomainEvent(), new ThirdDomainEvent()];
78
79			self::assertEquals(array_values($eventsResult), array_values($eventsExpected));
80			}
81
82			/**
83			* @return mixed[] array
84			*/
85			public function persistDataProvider() : array
86			{
87			return [
88			[[], 0, 0],
89			[[new FirstOutboxEntry(new FirstDomainEvent())], 1, 1],
90			[
91			[
92			new ThirdOutboxEntry(new ThirdDomainEvent()),
93			new FirstOutboxEntry(new FirstDomainEvent()),
94			new SecondOutboxEntry(new SecondDomainEvent()),
95			], 3,
96			1,
97			],
98			];
99			}
100
101			/**
102			* @param mixed[] $outboxEvents
103			*
104			* @dataProvider persistDataProvider
105			*/
106			public function testPersist(array $outboxEvents, int $persistCalls, int $computeChangeSetsCalls) : void
107			{
108			$eventArgs = $this->getEventArgs();
109
110			$mapBasedEventsHandler = new StubMapBased(new OutboxSubClass(), $this->conversionMap);
111
112			$this->entityManager->expects(self::exactly($persistCalls))->method('persist');
113
114			$this->unitOfWork->expects(self::exactly($computeChangeSetsCalls))->method('computeChangeSets');
115
116			$mapBasedEventsHandler->persist($eventArgs->getEntityManager(), ...$outboxEvents);
117			}
118
119			public function testOnFlushWithDomainEvents() : void
120			{
121			$eventArgs = $this->getEventArgs();
122
123			$mapBasedEventsHandler = new StubMapBased(new OutboxSubClass(), $this->conversionMap);
124
125			$this->entityManager->expects(self::exactly(3))->method('persist');
126
127			$mapBasedEventsHandler->onFlush($eventArgs);
128			}
129
130			public function testOnFlushWithNoDomainEvents() : void
131			{
132			$eventArgs = $this->getEventArgs(false);
133
134			$mapBasedEventsHandler = new StubMapBased(new OutboxSubClass(), $this->conversionMap);
135
136			$this->unitOfWork->expects(self::never())->method('computeChangeSets');
137
138			$mapBasedEventsHandler->onFlush($eventArgs);
139			}
140
141			/**
142			* @return OnFlushEventArgs\|MockObject
143			*/
144			private function getEventArgs(bool $withEvents = true) : OnFlushEventArgs
145			{
146			$insertions = $updates = $deletions = [];
147
148			if ($withEvents) {
149			$entity1 = new class() implements EventAware {
150			use OrderedEventRegistry;
151
152			public function trigger(DomainEvent $event) : void
153			{
154			$this->triggeredA($event);
155			}
156			};
157
158			$entity2 = new class() implements EventAware {
159			use OrderedEventRegistry;
160
161			public function trigger(DomainEvent $event) : void
162			{
163			$this->triggeredA($event);
164			}
165			};
166
167			$entity3 = new class() implements EventAware {
168			use OrderedEventRegistry;
169
170			public function trigger(DomainEvent $event) : void
171			{
172			$this->triggeredA($event);
173			}
174			};
175
176			$domainEvent1 = new FirstDomainEvent();
177			$domainEvent2 = new SecondDomainEvent();
178			$domainEvent3 = new ThirdDomainEvent();
179
180			$entity1->trigger($domainEvent1);
181			$entity2->trigger($domainEvent2);
182			$entity3->trigger($domainEvent3);
183
184			$updates = [$entity3];
185			$deletions = [$entity2, $entity1];
186			}
187
188			$this->unitOfWork->expects(self::any())->method('getScheduledEntityInsertions')->willReturn($insertions);
189			$this->unitOfWork->expects(self::any())->method('getScheduledEntityUpdates')->willReturn($updates);
190			$this->unitOfWork->expects(self::any())->method('getScheduledEntityDeletions')->willReturn($deletions);
191
192			$this->entityManager->expects(self::any())->method('getUnitOfWork')->willReturn($this->unitOfWork);
193
194			$eventArgs = $this->createMock(OnFlushEventArgs::class);
195			$eventArgs->expects(self::any())->method('getEntityManager')->willReturn($this->entityManager);
196
197			return $eventArgs;
			0 ignored issues – show Bug Best Practice introduced 2019-04-10 09:31 UTC by Report Bug Copy Issue Report The expression `return $eventArgs` returns the type `PHPUnit\Framework\MockObject\MockObject` which is incompatible with the type-hinted return `Doctrine\ORM\Event\OnFlushEventArgs`. Loading history...
198			}
199			}
200

dsantang / domain-events-doctrine

GitHub Access Token became invalid

Pull Request — master (#7)

StubMapBasedTest::testOnFlushWithNoDomainEvents() A

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like