AggregateRootTestCase::setUpEventSauce() - Code Metrics - Inspection of "Release: 0.6.0" - EventSaucePHP/EventSauce - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Pull Request — master (#54)

by Frank

created 2019-08-01 21:13 UTC

AggregateRootTestCase::setUpEventSauce() A

↳ Parent: AggregateRootTestCase

Complexity

Conditions	1
Paths	1

Size

Total Lines	18
Code Lines	15

Duplication

Lines	0
Ratio	0 %

Code Coverage

Tests	16
CRAP Score	1

Importance

Changes

Metric	Value
cc	1
eloc	15
nc	1
nop	0
dl	0
loc	18
ccs	16
cts	16
cp	1
crap	1
rs	9.7666
c	0
b	0
f	0

<?php

declare(strict_types=1);

namespace EventSauce\EventSourcing;

use EventSauce\EventSourcing\TestUtilities\ConsumerThatSerializesMessages;
use EventSauce\EventSourcing\Time\Clock;
use EventSauce\EventSourcing\Time\TestClock;
use Exception;
use LogicException;
use PHPUnit\Framework\TestCase;
use function get_class;
use function method_exists;
use function sprintf;

/**
 * @method handle(...$arguments)
 */
abstract class AggregateRootTestCase extends TestCase
{
    /**
     * @var InMemoryMessageRepository
     */
    protected $messageRepository;

    /**
     * @var AggregateRootRepository
     */
    protected $repository;

    /**
     * @var Exception|null
     */
    private $caughtException;

    /**
     * @var object[]
     */
    private $expectedEvents = [];

    /**
     * @var Exception|null
     */
    private $theExpectedException;

    /**
     * @var TestClock
     */
    private $clock;

    /**
     * @var bool
     */
    private $assertedScenario = false;

    /**
     * @var AggregateRootId
     */
    protected $aggregateRootId;

    /**
     * @before
     */
    protected function setUpEventSauce()
    {
        $className = $this->aggregateRootClassName();
        $this->clock = new TestClock();
        $this->aggregateRootId = $this->newAggregateRootId();
        $this->messageRepository = new InMemoryMessageRepository();
        $dispatcher = $this->messageDispatcher();
        $decorator = $this->messageDecorator();
        $this->repository = $this->aggregateRootRepository(
            $className,
            $this->messageRepository,
            $dispatcher,
            $decorator
        );
        $this->expectedEvents = [];
        $this->assertedScenario = false;
        $this->theExpectedException = null;
        $this->caughtException = null;
    }

    /**
     * @after
     */
    protected function assertScenario()
    {
        // @codeCoverageIgnoreStart
        if ($this->assertedScenario) {
            return;
        }
        // @codeCoverageIgnoreEnd

        try {
            $this->assertExpectedException($this->theExpectedException, $this->caughtException);
            $this->assertLastCommitEqualsEvents(...$this->expectedEvents);
            $this->messageRepository->purgeLastCommit();
        } finally {
            $this->assertedScenario = true;
            $this->theExpectedException = null;
            $this->caughtException = null;
        }
    }

    protected function aggregateRootId(): AggregateRootId
    {
        return $this->aggregateRootId;
    }

    abstract protected function newAggregateRootId(): AggregateRootId;

    abstract protected function aggregateRootClassName(): string;

    /**
     * @return $this
     */
    protected function given(object ...$events)
    {
        $this->repository->persistEvents($this->aggregateRootId(), count($events), ...$events);
        $this->messageRepository->purgeLastCommit();

        return $this;
    }

    public function on(AggregateRootId $id)
    {
        return new EventStager($id, $this->messageRepository, $this->repository, $this);
    }

    /**
     * @return $this
     */
    protected function when(...$arguments)
    {
        try {
            if ( ! method_exists($this, 'handle')) {
                throw new LogicException(sprintf('Class %s is missing a ::handle method.', get_class($this)));
            }

            $this->handle(...$arguments);
        } catch (Exception $exception) {
            $this->caughtException = $exception;
        }

        return $this;
    }

    /**
     * @return $this
     */
    protected function then(object ...$events)
    {
        $this->expectedEvents = $events;

        return $this;
    }

    /**
     * @return $this
     */
    public function expectToFail(Exception $expectedException)
    {
        $this->theExpectedException = $expectedException;

        return $this;
    }

    /**
     * @return $this
     */
    protected function thenNothingShouldHaveHappened()
    {
        $this->expectedEvents = [];

        return $this;
    }

    protected function assertLastCommitEqualsEvents(object ...$events)
    {
        self::assertEquals($events, $this->messageRepository->lastCommit(), 'Events are not equal.');
    }

    private function assertExpectedException(Exception $expectedException = null, Exception $caughtException = null)
    {
        if ($expectedException == $caughtException) {
            return;
        }

        if (
            null !== $caughtException && (
            null === $expectedException ||
            get_class($expectedException) !== get_class($caughtException))
        ) {
            throw $caughtException;
        }

        self::assertEquals([$expectedException], [$caughtException], '>> Exceptions are not equal.');
    }

    protected function pointInTime(): PointInTime
    {
        return $this->clock->pointInTime();
    }

    protected function clock(): Clock
    {
        return $this->clock;
    }

    protected function messageDispatcher(): MessageDispatcher
    {
        return new SynchronousMessageDispatcher(
            new ConsumerThatSerializesMessages(),
            ...$this->consumers()
        );
    }

    /**
     * @return Consumer[]
     */
    protected function consumers(): array
    {
        return [];
    }

    private function messageDecorator(): MessageDecorator
    {
        return new MessageDecoratorChain(new DefaultHeadersDecorator());
    }

    protected function aggregateRootRepository(
        string $className,
        MessageRepository $repository,
        MessageDispatcher $dispatcher,
        MessageDecorator $decorator
    ): AggregateRootRepository {
        return new ConstructingAggregateRootRepository(
            $className,
            $repository,
            $dispatcher,
            $decorator
        );
    }
}


1		<?php
2
3		declare(strict_types=1);
4
5		namespace EventSauce\EventSourcing;
6
7		use EventSauce\EventSourcing\TestUtilities\ConsumerThatSerializesMessages;
8		use EventSauce\EventSourcing\Time\Clock;
9		use EventSauce\EventSourcing\Time\TestClock;
10		use Exception;
11		use LogicException;
12		use PHPUnit\Framework\TestCase;
13		use function get_class;
14		use function method_exists;
15		use function sprintf;
16
17		/**
18		* @method handle(...$arguments)
19		*/
20		abstract class AggregateRootTestCase extends TestCase
21		{
22		/**
23		* @var InMemoryMessageRepository
24		*/
25		protected $messageRepository;
26
27		/**
28		* @var AggregateRootRepository
29		*/
30		protected $repository;
31
32		/**
33		* @var Exception\|null
34		*/
35		private $caughtException;
36
37		/**
38		* @var object[]
39		*/
40		private $expectedEvents = [];
41
42		/**
43		* @var Exception\|null
44		*/
45		private $theExpectedException;
46
47		/**
48		* @var TestClock
49		*/
50		private $clock;
51
52		/**
53		* @var bool
54		*/
55		private $assertedScenario = false;
56
57		/**
58		* @var AggregateRootId
59		*/
60		protected $aggregateRootId;
61
62		/**
63		* @before
64		*/
65	10	protected function setUpEventSauce()
66		{
67	10	$className = $this->aggregateRootClassName();
68	10	$this->clock = new TestClock();
69	10	$this->aggregateRootId = $this->newAggregateRootId();
70	10	$this->messageRepository = new InMemoryMessageRepository();
71	10	$dispatcher = $this->messageDispatcher();
72	10	$decorator = $this->messageDecorator();
73	10	$this->repository = $this->aggregateRootRepository(
74	10	$className,
75	10	$this->messageRepository,
76	10	$dispatcher,
77	10	$decorator
78		);
79	10	$this->expectedEvents = [];
80	10	$this->assertedScenario = false;
81	10	$this->theExpectedException = null;
82	10	$this->caughtException = null;
83	10	}
84
85		/**
86		* @after
87		*/
88	10	protected function assertScenario()
89		{
90		// @codeCoverageIgnoreStart
91		if ($this->assertedScenario) {
92		return;
93		}
94		// @codeCoverageIgnoreEnd
95
96		try {
97	10	$this->assertExpectedException($this->theExpectedException, $this->caughtException);
98	7	$this->assertLastCommitEqualsEvents(...$this->expectedEvents);
99	7	$this->messageRepository->purgeLastCommit();
100	7	} finally {
101	10	$this->assertedScenario = true;
102	10	$this->theExpectedException = null;
103	10	$this->caughtException = null;
104		}
105	7	}
106
107	9	protected function aggregateRootId(): AggregateRootId
108		{
109	9	return $this->aggregateRootId;
110		}
111
112		abstract protected function newAggregateRootId(): AggregateRootId;
113
114		abstract protected function aggregateRootClassName(): string;
115
116		/**
117		* @return $this
118		*/
119	2	protected function given(object ...$events)
120		{
121	2	$this->repository->persistEvents($this->aggregateRootId(), count($events), ...$events);
122	2	$this->messageRepository->purgeLastCommit();
123
124	2	return $this;
125		}
126
127	1	public function on(AggregateRootId $id)
128		{
129	1	return new EventStager($id, $this->messageRepository, $this->repository, $this);
130		}
131
132		/**
133		* @return $this
134		*/
135	9	protected function when(...$arguments)
136		{
137		try {
138	9	if ( ! method_exists($this, 'handle')) {
139	1	throw new LogicException(sprintf('Class %s is missing a ::handle method.', get_class($this)));
140		}
141
142	8	$this->handle(...$arguments);
143	4	} catch (Exception $exception) {
144	4	$this->caughtException = $exception;
145		}
146
147	9	return $this;
148		}
149
150		/**
151		* @return $this
152		*/
153	4	protected function then(object ...$events)
154		{
155	4	$this->expectedEvents = $events;
156
157	4	return $this;
158		}
159
160		/**
161		* @return $this
162		*/
163	2	public function expectToFail(Exception $expectedException)
164		{
165	2	$this->theExpectedException = $expectedException;
166
167	2	return $this;
168		}
169
170		/**
171		* @return $this
172		*/
173	1	protected function thenNothingShouldHaveHappened()
174		{
175	1	$this->expectedEvents = [];
176
177	1	return $this;
178		}
179
180	7	protected function assertLastCommitEqualsEvents(object ...$events)
181		{
182	7	self::assertEquals($events, $this->messageRepository->lastCommit(), 'Events are not equal.');
183	7	}
184
185	10	private function assertExpectedException(Exception $expectedException = null, Exception $caughtException = null)
186		{
187	10	if ($expectedException == $caughtException) {
188	6	return;
189		}
190
191		if (
192	4	null !== $caughtException && (
193	4	null === $expectedException \|\|
194	2	get_class($expectedException) !== get_class($caughtException))
195	4	) {
196		throw $caughtException;
197	3	}
198
199		self::assertEquals([$expectedException], [$caughtException], '>> Exceptions are not equal.');
200	1	}
201	1
202		protected function pointInTime(): PointInTime
203	1	{
204		return $this->clock->pointInTime();
205	1	}
206
207		protected function clock(): Clock
208	8	{
209		return $this->clock;
210	8	}
211
212		protected function messageDispatcher(): MessageDispatcher
213	10	{
214		return new SynchronousMessageDispatcher(
215	10	new ConsumerThatSerializesMessages(),
216	10	...$this->consumers()
217	10	);
218		}
219
220		/**
221		* @return Consumer[]
222		*/
223		protected function consumers(): array
224	10	{
225		return [];
226	10	}
227
228		private function messageDecorator(): MessageDecorator
229	10	{
230		return new MessageDecoratorChain(new DefaultHeadersDecorator());
231	10	}
232
233		protected function aggregateRootRepository(
234	10	string $className,
235		MessageRepository $repository,
236		MessageDispatcher $dispatcher,
237		MessageDecorator $decorator
238		): AggregateRootRepository {
239		return new ConstructingAggregateRootRepository(
240	10	$className,
241	10	$repository,
242	10	$dispatcher,
243	10	$decorator
244	10	);
245		}
246		}
247

EventSaucePHP / EventSauce

Pull Request — master (#54)

AggregateRootTestCase::setUpEventSauce() A

Complexity

Size

Duplication

Code Coverage

Importance

Duplication Side-by-Side

Filter issues like