Base EventSourcing classes.

src/Domain/EventSourcing/EventSourcingAggregateRoot.php

@@ -0,0 +1,70 @@
+<?php
+
+namespace Ddd\Domain\EventSourcing;
+
+use Ddd\Domain\DomainEvent;
+use Ddd\Domain\DomainEventPublisher;
+
+/**
+ * Class EventSourcingAggregateRoot
+ */
+trait EventSourcingAggregateRoot
+{
+    /**
+     * @var DomainEvent[]
+     */
+    private $recordedEvents;
+
+    /**
+     * @param DomainEvent $event
+     */
+    protected function publishThat(DomainEvent $event)
+    {
+        $this->apply($event);
+        $this->record($event);
+        $this->notify($event);
+    }
+
+    /**
+     * @param DomainEvent $event
+     */
+    protected function notify(DomainEvent $event)
+    {
+        DomainEventPublisher::instance()->publish($event);
+    }
+
+    /**
+     * @param DomainEvent $event
+     */
+    protected function record(DomainEvent $event)
+    {
+        $this->recordedEvents[] = $event;
+    }
+
+    /**
+     * @param DomainEvent $event
+     */
+    protected function apply(DomainEvent $event)
+    {
+        $parts = explode('\\', get_class($event));
+        $apply = 'apply' . end($parts);
+
+        $this->$apply($event);
+    }
+
+    /**
+     * @return DomainEvent[]
+     */
+    public function recordedEvents()
+    {
+        return $this->recordedEvents;
+    }
+
+    /**
+     * @return void
+     */
+    public function clearRecordedEvents()
+    {
+        $this->recordedEvents = [];
+    }
+}

src/Domain/EventSourcing/EventSourcingStore.php

@@ -0,0 +1,25 @@
+<?php
+
+namespace Ddd\Domain\EventSourcing;
+
+use Ddd\Domain\DomainEvent;
+
+interface EventSourcingStore
+{
+    /**
+     * @param string $aggregateId
+     * @param int    $skipEvent
+     * @param int    $maxCount
+     * @return EventStream
+     */
+    public function loadEventStream($aggregateId, $skipEvent, $maxCount);
+
+
+    /**
+     * @param string        $aggregateId
+     * @param DomainEvent[] $events
+     * @param int           $expectedVersion
+     * @return void
+     */
+    public function appendToStream($aggregateId, array $events, $expectedVersion);
+}

src/Domain/EventSourcing/EventStream.php

@@ -0,0 +1,49 @@
+<?php
+
+namespace Ddd\Domain\EventSourcing;
+
+use Ddd\Domain\DomainEvent;
+use IteratorAggregate;
+use ArrayIterator;
+
+/**
+ * Class EventStream
+ */
+class EventStream implements IteratorAggregate
+{
+    /**
+     * @var int
+     */
+    private $version;
+
+    /**
+     * @var DomainEvent[]
+     */
+    private $events;
+
+    /**
+     * @param int           $version
+     * @param DomainEvent[] $events
+     */
+    public function __construct($version, array $events)
+    {
+        $this->version = $version;
+        $this->events  = $events;
+    }
+
+    /**
+     * @return int
+     */
+    public function version()
+    {
+        return $this->version;
+    }
+
+    /**
+     * @inheritdoc
+     */
+    public function getIterator()
+    {
+        return new ArrayIterator($this->events);
+    }
+}

tests/Domain/DomainEventPublisherTest.php

@@ -65,38 +65,3 @@ private function unsubscribe($id)
         DomainEventPublisher::instance()->unsubscribe($id);
     }
 }
-
-class SpySubscriber implements DomainEventSubscriber
-{
-    public $domainEvent;
-    public $isHandled = false;
-    private $eventName;
-
-    public function __construct($eventName)
-    {
-        $this->eventName = $eventName;
-    }
-
-    public function isSubscribedTo($aDomainEvent)
-    {
-        return $this->eventName === $aDomainEvent->name;
-    }
-
-    public function handle($aDomainEvent)
-    {
-        $this->domainEvent = $aDomainEvent;
-        $this->isHandled = true;
-    }
-}
-
-class FakeDomainEvent implements DomainEvent
-{
-    public $name;
-
-    public function __construct($name)
-    {
-        $this->name = $name;
-    }
-
-    public function occurredOn() {}
-}

tests/Domain/EventSourcing/EventSourcingAggregateRootTest.php

@@ -0,0 +1,100 @@
+<?php
+
+namespace Ddd\Domain\EventSourcing;
+
+use Ddd\Domain\DomainEventPublisher;
+use Ddd\Domain\FakeDomainEvent;
+use Ddd\Domain\SpySubscriber;
+
+class EventSourcingAggregateRootTest extends \PHPUnit_Framework_TestCase
+{
+    /**
+     * @var SpyEventSourcingAggregateRoot
+     */
+    private $aggregateRoot;
+
+    /**
+     * @var SpySubscriber
+     */
+    private $subscriber;
+
+    public function setUp()
+    {
+        $this->aggregateRoot = new SpyEventSourcingAggregateRoot();
+        $this->subscriber    = new SpySubscriber('fake-event');
+
+        DomainEventPublisher::instance()->subscribe($this->subscriber);
+    }
+
+    /**
+     * @test
+     */
+    public function itShouldPublishDomainEvent()
+    {
+        $this->aggregateRoot->someBusinessLogic();
+
+        $this->assertTrue($this->subscriber->isHandled);
+    }
+
+    /**
+     * @test
+     */
+    public function itShouldApplyDomainEvent()
+    {
+        $this->aggregateRoot->someBusinessLogic();
+
+        $this->assertTrue($this->aggregateRoot->isApplied());
+    }
+
+    /**
+     * @test
+     */
+    public function itShouldRecordDomainEvent()
+    {
+        $this->aggregateRoot->someBusinessLogic();
+
+        $this->assertEquals(
+            new FakeDomainEvent('fake-event'),
+            $this->aggregateRoot->recordedEvents()[0]
+        );
+    }
+
+    /**
+     * @test
+     */
+    public function itShouldClearRecordedDomainEvent()
+    {
+        $this->aggregateRoot->someBusinessLogic();
+        $this->aggregateRoot->clearRecordedEvents();
+
+        $this->assertEmpty($this->aggregateRoot->recordedEvents());
+    }
+}
+
+class SpyEventSourcingAggregateRoot
+{
+    use EventSourcingAggregateRoot;
+
+    /**
+     * @var bool
+     */
+    private $isApplied = false;
+
+    public function someBusinessLogic()
+    {
+        $this->publishThat(new FakeDomainEvent('fake-event'));
+    }
+
+    protected function applyFakeDomainEvent(FakeDomainEvent $domainEvent)
+    {
+        $this->isApplied = true;
+    }
+
+    /**
+     * @return boolean
+     */
+    public function isApplied()
+    {
+        return $this->isApplied;
+    }
+}

tests/Domain/FakeDomainEvent.php

@@ -0,0 +1,15 @@
+<?php
+
+namespace Ddd\Domain;
+
+class FakeDomainEvent implements DomainEvent
+{
+    public $name;
+
+    public function __construct($name)
+    {
+        $this->name = $name;
+    }
+
+    public function occurredOn() {}
+}

tests/Domain/SpySubscriber.php

@@ -0,0 +1,26 @@
+<?php
+
+namespace Ddd\Domain;
+
+class SpySubscriber implements DomainEventSubscriber
+{
+    public $domainEvent;
+    public $isHandled = false;
+    private $eventName;
+
+    public function __construct($eventName)
+    {
+        $this->eventName = $eventName;
+    }
+
+    public function isSubscribedTo($aDomainEvent)
+    {
+        return $this->eventName === $aDomainEvent->name;
+    }
+
+    public function handle($aDomainEvent)
+    {
+        $this->domainEvent = $aDomainEvent;
+        $this->isHandled = true;
+    }
+}