EventSauce\EventSourcing\AggregateRootTestCase

Complexity

Total Complexity

21

Size/Duplication

Total Lines	189
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	6

Test Coverage

Coverage

98.33%

Importance

Changes

0

16 Methods

Rating	Name	Duplication	Size	Complexity
	aggregateRootClassName()	0	1	?
A	setUpEventStore()	0	12	1
A	assertScenario()	0	18	2
	aggregateRootId()	0	1	?
A	given()	0	7	1
A	on()	0	4	1
A	when()	0	14	3
A	then()	0	6	1
A	thenWeAreSorry()	0	6	1
A	thenNothingShouldHaveHappened()	0	6	1
A	assertLastCommitEqualsEvents()	0	4	1
B	assertExpectedException()	0	12	5
A	pointInTime()	0	4	1
A	clock()	0	4	1
A	messageDispatcher()	0	4	1
A	consumers()	0	4	1

<?php

namespace EventSauce\EventSourcing;

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

abstract class AggregateRootTestCase extends TestCase
{
    /**
     * @var InMemoryMessageRepository
     */
    private $messageRepository;

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

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

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

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

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

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

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

    /**
     * @before
     */
    protected function setUpEventStore()
    {
        $className = $this->aggregateRootClassName();
        $this->clock = new TestClock();
        $this->aggregateRootId = $this->aggregateRootId();
        $this->messageRepository = new InMemoryMessageRepository($this->messageDispatcher());
        $this->repository = new AggregateRootRepository($className, $this->messageRepository, new DelegatingMessageDecorator());
        $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;
        }
    }

    abstract protected function aggregateRootId(): AggregateRootId;

    abstract protected function aggregateRootClassName(): string;

    /**
     * @return $this
     */
    protected function given(Event ... $events)
    {
        $this->repository->persistEvents($this->aggregateRootId(), ... $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(Event ... $events)
    {
        $this->expectedEvents = $events;

        return $this;
    }

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

        return $this;
    }

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

        return $this;
    }

    protected function assertLastCommitEqualsEvents(Event ... $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 ( ! $expectedException instanceof Exception || ($caughtException instanceof Exception && (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(... $this->consumers());
    }

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