Merge pull request #7 from hellofresh/issue/microseconds

italolelis · web-flow · commit db948f89a238 · 2016-07-18T21:08:49.000+02:00
Issue/microseconds
diff --git a/src/Domain/DomainMessage.php b/src/Domain/DomainMessage.php
@@ -28,21 +28,21 @@ final class DomainMessage
     private $version;
 
     /**
-     * @param string $id
+     * @param AggregateIdInterface|string $id
      * @param $version
      * @param mixed $payload
      * @param \DateTimeImmutable $recordedOn
      */
     public function __construct($id, $version, $payload, \DateTimeImmutable $recordedOn)
     {
-        $this->id = $id;
+        $this->id = (string) $id;
         $this->payload = $payload;
-        $this->recordedOn = $recordedOn;
+        $this->recordedOn = $recordedOn->setTimezone(new \DateTimeZone('UTC'));
         $this->version = $version;
     }
 
     /**
-     * @return AggregateIdInterface
+     * @return string
      */
     public function getId()
     {
@@ -58,15 +58,15 @@ public function getPayload()
     }
 
     /**
-     * {@inheritDoc}
+     * @inheritDoc
      */
     public function getRecordedOn()
     {
         return $this->recordedOn;
     }
 
     /**
-     * {@inheritDoc}
+     * @inheritDoc
      */
     public function getType()
     {
@@ -81,7 +81,9 @@ public function getType()
      */
     public static function recordNow($id, $version, DomainEventInterface $payload)
     {
-        return new DomainMessage($id, $version, $payload, new \DateTimeImmutable('now', new \DateTimeZone('UTC')));
+        $recordedOn = \DateTimeImmutable::createFromFormat('U.u', sprintf('%.6F', microtime(true)));
+
+        return new DomainMessage($id, $version, $payload, $recordedOn);
     }
 
     /**
diff --git a/src/EventStore/Adapter/RedisAdapter.php b/src/EventStore/Adapter/RedisAdapter.php
@@ -59,8 +59,8 @@ public function countEventsFor(StreamName $streamName, AggregateIdInterface $agg
         return count($this->redis->lrange($this->getNamespaceKey($streamName, $aggregateId), 0, -1));
     }
 
-    private function getNamespaceKey(StreamName $streamName, AggregateIdInterface $aggregateId)
+    private function getNamespaceKey(StreamName $streamName, $aggregateId)
     {
-        return "events:{$streamName}:{$aggregateId}";
+        return sprintf('events:%s:%s', $streamName, $aggregateId);
     }
 }
diff --git a/src/EventStore/Snapshot/Adapter/RedisSnapshotAdapter.php b/src/EventStore/Snapshot/Adapter/RedisSnapshotAdapter.php
@@ -43,7 +43,7 @@ public function byId(AggregateIdInterface $id)
             'json'
         );
 
-        if (null === $metadata) {
+        if (!is_array($metadata)) {
             return null;
         }
 
@@ -54,11 +54,14 @@ public function byId(AggregateIdInterface $id)
             'json'
         );
 
+        $createdAt = \DateTimeImmutable::createFromFormat('U.u', $metadata['created_at']);
+        $createdAt->setTimezone(new \DateTimeZone('UTC'));
+
         return new Snapshot(
             $aggregate->getAggregateRootId(),
             $aggregate,
             $metadata['version'],
-            new \DateTimeImmutable("@" . $metadata['created_at'])
+            $createdAt
         );
     }
 
@@ -69,7 +72,7 @@ public function save(Snapshot $snapshot)
     {
         $data = [
             'version' => $snapshot->getVersion(),
-            'created_at' => $snapshot->getCreatedAt()->getTimestamp(),
+            'created_at' => $snapshot->getCreatedAt()->format('U.u'),
             'snapshot' => [
                 'type' => $snapshot->getType(),
                 'payload' => $this->serializer->serialize($snapshot->getAggregate(), 'json')
@@ -89,14 +92,12 @@ public function save(Snapshot $snapshot)
      */
     public function has(AggregateIdInterface $id, $version)
     {
-        $data = $this->redis->hget(static::KEY_NAMESPACE, (string)$id);
-
-        if (!$data) {
+        if (!$this->redis->hexists(static::KEY_NAMESPACE, (string)$id)) {
             return false;
         }
 
         $snapshot = $this->serializer->deserialize(
-            $data,
+            $this->redis->hget(static::KEY_NAMESPACE, (string)$id),
             'array',
             'json'
         );
diff --git a/src/EventStore/Snapshot/Snapshot.php b/src/EventStore/Snapshot/Snapshot.php
@@ -43,7 +43,7 @@ public function __construct(
         $this->aggregateId = $aggregateId;
         $this->aggregate = $aggregate;
         $this->version = $version;
-        $this->createdAt = $createdAt;
+        $this->createdAt = $createdAt->setTimezone(new \DateTimeZone('UTC'));
     }
 
     /**
@@ -55,7 +55,9 @@ public function __construct(
      */
     public static function take(AggregateIdInterface $aggregateId, AggregateRootInterface $aggregate, $version)
     {
-        return new static($aggregateId, $aggregate, $version, new \DateTimeImmutable());
+        $dateTime = \DateTimeImmutable::createFromFormat('U.u', sprintf('%.6F', microtime(true)));
+
+        return new static($aggregateId, $aggregate, $version, $dateTime);
     }
 
     /**
diff --git a/tests/Domain/DomainMessageTest.php b/tests/Domain/DomainMessageTest.php
@@ -24,11 +24,13 @@ public function itShouldCreateAUuidFromConstructor(
         \DateTimeImmutable $date
     ) {
         $message = new DomainMessage($aggregateId, $version, $payload, $date);
+
         $this->assertInstanceOf(DomainMessage::class, $message);
-        $this->assertEquals($aggregateId, $message->getId());
-        $this->assertEquals($version, $message->getVersion());
-        $this->assertEquals($payload, $message->getPayload());
+        $this->assertSame((string) $aggregateId, $message->getId());
+        $this->assertSame($version, $message->getVersion());
+        $this->assertSame($payload, $message->getPayload());
         $this->assertEquals($date, $message->getRecordedOn());
+        $this->assertEquals(new \DateTimeZone('UTC'), $message->getRecordedOn()->getTimezone());
     }
 
     /**
@@ -46,15 +48,25 @@ public function itShouldCreateAUuidFromNamedConstructor(
         \DateTimeImmutable $date
     ) {
         $message = DomainMessage::recordNow($aggregateId, $version, $payload);
+
         $this->assertInstanceOf(DomainMessage::class, $message);
+
+        $this->assertNotEmpty((int)$message->getRecordedOn()->format('u'), 'Expected microseconds to be set');
+        $this->assertEquals(new \DateTimeZone('UTC'), $message->getRecordedOn()->getTimezone());
     }
 
     public function messageProvider()
     {
         return [
             [AggregateId::generate(), 1, new SomethingHappened(), new \DateTimeImmutable()],
             [AggregateId::generate(), 100, new SomethingHappened(), new \DateTimeImmutable()],
-            [AggregateId::generate(), 9999999, new SomethingHappened(), new \DateTimeImmutable()]
+            [AggregateId::generate(), 9999999, new SomethingHappened(), new \DateTimeImmutable()],
+            [
+                AggregateId::generate(),
+                9999999,
+                new SomethingHappened(),
+                \DateTimeImmutable::createFromFormat('U.u', sprintf('%.6F', microtime(true)))
+            ]
         ];
     }
 }
diff --git a/tests/EventStore/EventStoreTest.php b/tests/EventStore/EventStoreTest.php
@@ -3,6 +3,7 @@
 namespace HelloFresh\Tests\Engine\EventStore;
 
 use HelloFresh\Engine\Domain\AggregateId;
+use HelloFresh\Engine\Domain\AggregateIdInterface;
 use HelloFresh\Engine\Domain\DomainMessage;
 use HelloFresh\Engine\Domain\EventStream;
 use HelloFresh\Engine\Domain\StreamName;
@@ -79,7 +80,7 @@ public function idDataProvider()
     {
         return [
             'Simple String' => [
-                'Yolntbyaac', //You only live nine times because you are a cat
+                'Yolntbyaac', // You only live nine times because you are a cat
             ],
             'Identitiy' => [
                 AggregateId::generate(),
diff --git a/tests/EventStore/Snapshot/Adapter/RedisSnapshotAdapterTest.php b/tests/EventStore/Snapshot/Adapter/RedisSnapshotAdapterTest.php
@@ -0,0 +1,192 @@
+<?php
+
+namespace HelloFresh\Tests\Engine\EventStore\Snapshot\Adapter;
+
+use HelloFresh\Engine\Domain\AggregateId;
+use HelloFresh\Engine\EventStore\Snapshot\Adapter\RedisSnapshotAdapter;
+use HelloFresh\Engine\EventStore\Snapshot\Snapshot;
+use HelloFresh\Engine\Serializer\SerializerInterface;
+use HelloFresh\Tests\Engine\Mock\AggregateRoot;
+use HelloFresh\Tests\Engine\Mock\PredisClient;
+use PHPUnit\Framework\TestCase;
+use Predis\ClientInterface;
+
+class RedisSnapshotAdapterTest extends TestCase
+{
+    /**
+     * @var ClientInterface|\Prophecy\Prophecy\ObjectProphecy
+     */
+    private $client;
+    /**
+     * @var SerializerInterface|\Prophecy\Prophecy\ObjectProphecy
+     */
+    private $serializer;
+
+    protected function setUp()
+    {
+        $this->client = $this->prophesize(PredisClient::class);
+        $this->serializer = $this->prophesize(SerializerInterface::class);
+    }
+
+    /**
+     * @test
+     */
+    public function itCanSaveASnapshot()
+    {
+        $id = AggregateId::generate();
+        $aggregate = AggregateRoot::create($id, 'test');
+
+        $snapshot = Snapshot::take($id, $aggregate, '10');
+
+        $expectedSerializedAggregate = sprintf('["serialized": "%s"]', spl_object_hash($snapshot));
+        $expectedStorageArray = [
+            'version' => '10',
+            'created_at' => $snapshot->getCreatedAt()->format('U.u'),
+            'snapshot' => [
+                'type' => AggregateRoot::class,
+                'payload' => $expectedSerializedAggregate,
+            ]
+        ];
+        $expectedStoredData = '["version etc..."]';
+
+        $this->serializer->serialize($aggregate, 'json')
+            ->willReturn($expectedSerializedAggregate)
+            ->shouldBeCalledTimes(1);
+        $this->serializer->serialize($expectedStorageArray, 'json')
+            ->willReturn($expectedStoredData)
+            ->shouldBeCalledTimes(1);
+
+        $this->client->hset(RedisSnapshotAdapter::KEY_NAMESPACE, (string)$id, $expectedStoredData)
+            ->shouldBeCalledTimes(1);
+
+        $adapter = $this->createAdapter();
+        $adapter->save($snapshot);
+    }
+
+    /**
+     * @test
+     */
+    public function aSnapshotCanBeRetrievedById()
+    {
+        $id = AggregateId::generate();
+
+        $expectedAggregate = AggregateRoot::create($id, 'testing');
+
+        $snapshotMetadata = [
+            'version' => '15',
+            'created_at' => '1468847497.332610',
+            'snapshot' => [
+                'type' => AggregateRoot::class,
+                'payload' => 'aggregate_data',
+            ]
+        ];
+
+        $this->mockRedisHasAndGetData($id, $snapshotMetadata);
+
+        $this->serializer->deserialize('aggregate_data', AggregateRoot::class, 'json')
+            ->willReturn($expectedAggregate);
+
+        $adapter = $this->createAdapter();
+        $result = $adapter->byId($id);
+
+        $this->assertInstanceOf(Snapshot::class, $result);
+        $this->assertSame($id, $result->getAggregateId());
+        $this->assertSame($expectedAggregate, $result->getAggregate());
+        $this->assertSame('15', $result->getVersion());
+        $this->assertSame('1468847497.332610', $result->getCreatedAt()->format('U.u'));
+        $this->assertEquals(new \DateTimeZone('UTC'), $result->getCreatedAt()->getTimezone());
+    }
+
+    /**
+     * @test
+     */
+    public function aSnapshotCanNotBeRetrievedWhenTheIdIsUnknown()
+    {
+        $id = AggregateId::generate();
+
+        $this->client->hexists(RedisSnapshotAdapter::KEY_NAMESPACE, (string)$id)
+            ->willReturn(false)
+            ->shouldBeCalledTimes(1);
+
+        $adapter = $this->createAdapter();
+        $result = $adapter->byId($id);
+
+        $this->assertNull($result);
+    }
+
+    /**
+     * @test
+     */
+    public function itIndicatedIfASnapshotOfAggregateWithVersionExists()
+    {
+        $id = AggregateId::generate();
+        $expectedDeserializedRedisData = ['version' => 20];
+
+        $this->mockRedisHasAndGetData($id, $expectedDeserializedRedisData);
+
+        $adapter = $this->createAdapter();
+        $result = $adapter->has($id, 20);
+
+        $this->assertTrue($result);
+    }
+
+    /**
+     * @test
+     */
+    public function itIndicatedThatASnapshotOfAggregateIsUnknown()
+    {
+        $id = AggregateId::generate();
+
+        $this->client->hexists(RedisSnapshotAdapter::KEY_NAMESPACE, (string)$id)
+            ->willReturn(false)
+            ->shouldBeCalledTimes(1);
+
+        $adapter = $this->createAdapter();
+        $result = $adapter->has($id, 15);
+
+        $this->assertFalse($result);
+    }
+
+    /**
+     * @test
+     */
+    public function itIndicatedThatASnapshotOfAggregateIsUnknownWhenTheVersionIsIncorrect()
+    {
+        $id = AggregateId::generate();
+
+        $this->mockRedisHasAndGetData($id, 20);
+
+        $adapter = $this->createAdapter();
+        $result = $adapter->has($id, 15);
+
+        $this->assertFalse($result);
+    }
+
+
+    /**
+     * @return RedisSnapshotAdapter
+     */
+    protected function createAdapter()
+    {
+        $adapter = new RedisSnapshotAdapter($this->client->reveal(), $this->serializer->reveal());
+        return $adapter;
+    }
+
+    /**
+     * @param $id
+     * @param $expectedDeserializedRedisData
+     */
+    protected function mockRedisHasAndGetData($id, $expectedDeserializedRedisData)
+    {
+        $this->client->hexists(RedisSnapshotAdapter::KEY_NAMESPACE, (string)$id)
+            ->willReturn(true)
+            ->shouldBeCalledTimes(1);
+
+        $this->client->hget(RedisSnapshotAdapter::KEY_NAMESPACE, (string)$id)
+            ->willReturn('redis_data')
+            ->shouldBeCalledTimes(1);
+
+        $this->serializer->deserialize('redis_data', 'array', 'json')
+            ->willReturn($expectedDeserializedRedisData);
+    }
+}
diff --git a/tests/EventStore/Snapshot/SnapshotTest.php b/tests/EventStore/Snapshot/SnapshotTest.php
diff --git a/tests/Mock/PredisClient.php b/tests/Mock/PredisClient.php

Original file line number	Diff line number	Diff line change
`@@ -28,21 +28,21 @@ final class DomainMessage`
`28`	`28`	`private $version;`
`29`	`29`
`30`	`30`	`/**`
`31`		`- * @param string $id`
	`31`	`+ * @param AggregateIdInterface\|string $id`
`32`	`32`	`* @param $version`
`33`	`33`	`* @param mixed $payload`
`34`	`34`	`* @param \DateTimeImmutable $recordedOn`
`35`	`35`	`*/`
`36`	`36`	`public function __construct($id, $version, $payload, \DateTimeImmutable $recordedOn)`
`37`	`37`	`{`
`38`		`- $this->id = $id;`
	`38`	`+ $this->id = (string) $id;`
`39`	`39`	`$this->payload = $payload;`
`40`		`- $this->recordedOn = $recordedOn;`
	`40`	`+ $this->recordedOn = $recordedOn->setTimezone(new \DateTimeZone('UTC'));`
`41`	`41`	`$this->version = $version;`
`42`	`42`	`}`
`43`	`43`
`44`	`44`	`/**`
`45`		`- * @return AggregateIdInterface`
	`45`	`+ * @return string`
`46`	`46`	`*/`
`47`	`47`	`public function getId()`
`48`	`48`	`{`
`@@ -58,15 +58,15 @@ public function getPayload()`
`58`	`58`	`}`
`59`	`59`
`60`	`60`	`/**`
`61`		`- * {@inheritDoc}`
	`61`	`+ * @inheritDoc`
`62`	`62`	`*/`
`63`	`63`	`public function getRecordedOn()`
`64`	`64`	`{`
`65`	`65`	`return $this->recordedOn;`
`66`	`66`	`}`
`67`	`67`
`68`	`68`	`/**`
`69`		`- * {@inheritDoc}`
	`69`	`+ * @inheritDoc`
`70`	`70`	`*/`
`71`	`71`	`public function getType()`
`72`	`72`	`{`
`@@ -81,7 +81,9 @@ public function getType()`
`81`	`81`	`*/`
`82`	`82`	`public static function recordNow($id, $version, DomainEventInterface $payload)`
`83`	`83`	`{`
`84`		`- return new DomainMessage($id, $version, $payload, new \DateTimeImmutable('now', new \DateTimeZone('UTC')));`
	`84`	`+ $recordedOn = \DateTimeImmutable::createFromFormat('U.u', sprintf('%.6F', microtime(true)));`
	`85`	`+`
	`86`	`+ return new DomainMessage($id, $version, $payload, $recordedOn);`
`85`	`87`	`}`
`86`	`88`
`87`	`89`	`/**`
Original file line number	Diff line number	Diff line change
`@@ -59,8 +59,8 @@ public function countEventsFor(StreamName $streamName, AggregateIdInterface $agg`
`59`	`59`	`return count($this->redis->lrange($this->getNamespaceKey($streamName, $aggregateId), 0, -1));`
`60`	`60`	`}`
`61`	`61`
`62`		`- private function getNamespaceKey(StreamName $streamName, AggregateIdInterface $aggregateId)`
	`62`	`+ private function getNamespaceKey(StreamName $streamName, $aggregateId)`
`63`	`63`	`{`
`64`		`- return "events:{$streamName}:{$aggregateId}";`
	`64`	`+ return sprintf('events:%s:%s', $streamName, $aggregateId);`
`65`	`65`	`}`
`66`	`66`	`}`
Original file line number	Diff line number	Diff line change
`@@ -43,7 +43,7 @@ public function __construct(`
`43`	`43`	`$this->aggregateId = $aggregateId;`
`44`	`44`	`$this->aggregate = $aggregate;`
`45`	`45`	`$this->version = $version;`
`46`		`- $this->createdAt = $createdAt;`
	`46`	`+ $this->createdAt = $createdAt->setTimezone(new \DateTimeZone('UTC'));`
`47`	`47`	`}`
`48`	`48`
`49`	`49`	`/**`
`@@ -55,7 +55,9 @@ public function __construct(`
`55`	`55`	`*/`
`56`	`56`	`public static function take(AggregateIdInterface $aggregateId, AggregateRootInterface $aggregate, $version)`
`57`	`57`	`{`
`58`		`- return new static($aggregateId, $aggregate, $version, new \DateTimeImmutable());`
	`58`	`+ $dateTime = \DateTimeImmutable::createFromFormat('U.u', sprintf('%.6F', microtime(true)));`
	`59`	`+`
	`60`	`+ return new static($aggregateId, $aggregate, $version, $dateTime);`
`59`	`61`	`}`
`60`	`62`
`61`	`63`	`/**`