Create a timestamp class to normalise the differing values that could come back from the db

Author: redthor

src/AntiMattr/MongoDB/Migrations/Configuration/Configuration.php

@@ -304,6 +304,7 @@ public function getMigratedVersions()
      * @return string
      *
      * @throws AntiMattr\MongoDB\Migrations\Exception\UnknownVersionException Throws exception if migration version does not exist
+     * @throws DomainException If more than one version exists
      */
     public function getMigratedTimestamp($version)
     {
@@ -325,7 +326,10 @@ public function getMigratedTimestamp($version)
 
         $returnVersion = $cursor->getNext();
 
-        return (string) $returnVersion['t'];
+        // Convert to normalised timestamp
+        $ts = new Timestamp($returnVersion['t']);
+
+        return (string) $ts;
     }
 
     /**

src/AntiMattr/MongoDB/Migrations/Configuration/Timestamp.php

@@ -0,0 +1,104 @@
+<?php
+
+/*
+ * This file is part of the AntiMattr MongoDB Migrations Library, a library by Matthew Fitzgerald.
+ *
+ * (c) 2014 Matthew Fitzgerald
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+namespace AntiMattr\MongoDB\Migrations\Configuration;
+
+/**
+ * This class is to normalise the potential values from the 't' version
+ * attribute
+ *
+ * @author Douglas Reith <douglas@reith.com.au>
+ */
+class Timestamp
+{
+    private $t;
+
+    /**
+     * __construct
+     *
+     * @param mixed $t
+     */
+    public function __construct($t)
+    {
+        $this->t = $t;
+    }
+
+    /**
+     * __invoke
+     *
+     * @param mixed $t
+     * @return int
+     */
+    public function __invoke($t): int
+    {
+        return (new static($t))->getTimestamp();
+    }
+
+    /**
+     * getTimestamp
+     *
+     * Normalise based on the different options for backward/forward
+     * compatibility
+     *
+     * @return int Time in seconds since 1970
+     */
+    public function getTimestamp(): int
+    {
+        $supportedClasses = implode(
+            ', ',
+            [
+                '\MongoTimestamp',
+                '\MongoDate',
+                '\MongoDB\BSON\Timestamp',
+                '\MongoDB\BSON\UTCDateTime',
+                '\DateTimeInterface',
+            ]
+        );
+
+        if (!$this->t || !is_object($this->t)) {
+            throw new \DomainException(
+                'The timestamp to normalise must be one of ' . $supportedClasses . ' but it is not an object'
+            );
+        }
+
+        switch(get_class($this->t)) {
+            case 'MongoTimestamp':
+                return (int) $this->t->__toString();
+
+            case 'MongoDate':
+                return $this->t->sec;
+
+            case 'MongoDB\BSON\Timestamp':
+                return $this->t->getTimestamp();
+
+            case 'MongoDB\BSON\UTCDateTime':
+                return (int) $this->t->toDateTime()->format('U');
+        }
+
+        if ($this->t instanceof \DateTimeInterface) {
+            return $this->t->getTimestamp();
+        }
+
+        throw new \DomainException(
+            'The normalised timestamp must be one of ' . $supportedClasses
+        );
+    }
+
+    /**
+     * __toString
+     *
+     * @return string
+     */
+    public function __toString(): string
+    {
+        return (string) $this->getTimestamp();
+    }
+}

tests/AntiMattr/Tests/MongoDB/Migrations/Configuration/ConfigurationTest.php

@@ -306,6 +306,41 @@ public function testDuplicateThrowsException()
         $this->configuration->getMigratedTimestamp('1');
     }
 
+    public function testGetMigratedTimestamp()
+    {
+        $this->prepareValidConfiguration();
+
+        $collection = $this->buildMock('Doctrine\MongoDB\Collection');
+        $database = $this->buildMock('Doctrine\MongoDB\Database');
+
+        $this->connection->expects($this->once())
+            ->method('selectDatabase')
+            ->with('test_antimattr_migrations')
+            ->willReturn($database);
+
+        $database->expects($this->once())
+            ->method('selectCollection')
+            ->with('antimattr_migration_versions_test')
+            ->willReturn($collection);
+
+        $cursor = $this->buildMock('Doctrine\MongoDB\Cursor');
+
+        $collection->expects($this->once())
+            ->method('find')
+            ->willReturn($cursor);
+
+        $cursor->expects($this->exactly(2))
+            ->method('count')
+            ->willReturn(1);
+
+        $cursor->expects($this->once())
+            ->method('getNext')
+            ->willReturn(['t' => new \DateTime()]);
+
+        $this->assertTrue(is_numeric($this->configuration->getMigratedTimestamp('1')));
+    }
+
+
     private function prepareValidConfiguration()
     {
         $directory = dirname(__DIR__) . '/Resources/Migrations/';

tests/AntiMattr/Tests/MongoDB/Migrations/Configuration/TimestampTest.php

@@ -0,0 +1,80 @@
+<?php
+
+namespace AntiMattr\Tests\MongoDB\Migrations\Configuration;
+
+use AntiMattr\TestCase\AntiMattrTestCase;
+use AntiMattr\MongoDB\Migrations\Configuration\Timestamp;
+
+class TimestampTest extends AntiMattrTestCase
+{
+    /**
+     * testTimestamp
+     *
+     * @dataProvider provideTimestamps
+     */
+    public function testTimestamp($ts, $expected)
+    {
+        self::assertEquals($expected, (new Timestamp($ts))->getTimestamp());
+    }
+
+    public function provideTimestamps(): array
+    {
+        $rightNow = new \DateTimeImmutable();
+        $secondsSince1970 = (int) $rightNow->format('U');
+        $millisecondsSince1970 = $secondsSince1970 * 1000;
+
+        $timestamps = [
+            [$rightNow, $secondsSince1970]
+        ];
+
+        if (class_exists('\MongoDB\BSON\Timestamp')) {
+            $timestamps[] = [
+                new \MongoDB\BSON\Timestamp(0, $secondsSince1970),
+                $secondsSince1970
+            ];
+        }
+
+        if (class_exists('\MongoDB\BSON\UTCDateTime')) {
+            $timestamps[] = [
+                new \MongoDB\BSON\UTCDateTime($millisecondsSince1970),
+                $secondsSince1970
+            ];
+        }
+
+        if (class_exists('\MongoDate')) {
+            $timestamps[] = [
+                new \MongoDate($secondsSince1970),
+                $secondsSince1970
+            ];
+        }
+
+        if (class_exists('\MongoTimestamp')) {
+            $timestamps[] = [
+                new \MongoTimestamp($secondsSince1970),
+                $secondsSince1970
+            ];
+        }
+
+        return $timestamps;
+    }
+
+    /**
+     * testWillThrowAnExceptionForUnknownClass
+     *
+     * @expectedException \DomainException
+     */
+    public function testWillThrowAnExceptionForUnknownClass()
+    {
+        (new Timestamp(new \stdClass()))->getTimestamp();
+    }
+
+    /**
+     * testWillThrowAnExceptionForNull
+     *
+     * @expectedException \DomainException
+     */
+    public function testWillThrowAnExceptionForNull()
+    {
+        (new Timestamp(null))->getTimestamp();
+    }
+}