allow runtime dynamic type assertions

Author: midnight-wonderer

src/ObjectId.php

@@ -34,17 +34,19 @@ private static function generator(): Generator
 
     /**
      * Constructor.
+     * @throws Invalid
      */
-    public function __construct(?string $rawData = null)
+    public function __construct($rawData = null)
     {
-        if ($rawData !== null) {
-            if (strlen($rawData) !== 12) {
-                throw new Invalid("Raw data must be 12 bytes for ObjectId.");
-            }
-            $this->rawData = $rawData;
-        } else {
+        if ($rawData === null) {
             $this->rawData = self::generator()->nextObjectId();
+            return;
         }
+        if (!is_string($rawData))
+            throw new Invalid("Raw data must be a string.");
+        if (strlen($rawData) !== 12)
+            throw new Invalid("Raw data must be 12 bytes for ObjectId.");
+        $this->rawData = $rawData;
     }
 
     /**
@@ -54,8 +56,10 @@ public function __construct(?string $rawData = null)
      * @return ObjectId
      * @throws Invalid if $rawData is not 12 bytes.
      */
-    public static function fromBinary(string $data): ObjectId
+    public static function fromBinary($data): ObjectId
     {
+        if (!is_string($data))
+            throw new Invalid("The input must be a string.");
         return new self($data);
     }
 
@@ -66,11 +70,12 @@ public static function fromBinary(string $data): ObjectId
      * @return ObjectId
      * @throws Invalid If the provided string is invalid.
      */
-    public static function fromString(string $string): ObjectId
+    public static function fromString($string): ObjectId
     {
-        if (!self::legal($string)) {
-            throw new Invalid("'$string' is an invalid ObjectId.");
-        }
+        if (!is_string($string))
+            throw new Invalid("The input must be a string.");
+        if (!self::legal($string))
+            throw new Invalid("'$string' is not a 24-character hex string.");
         return self::fromBinary(hex2bin($string));
     }
 
@@ -82,9 +87,14 @@ public static function fromString(string $string): ObjectId
      * @return ObjectId The new object id.
      * @throws Invalid
      */
-    public static function fromTime(int|DateTime $time, bool $unique = true): ObjectId
+    public static function fromTime($time, bool $unique = true): ObjectId
     {
-        $timestamp = $time instanceof DateTime ? $time->getTimestamp() : (int)$time;
+        if ($time instanceof DateTime)
+            $timestamp = $time->getTimestamp();
+        elseif (is_integer($time))
+            $timestamp = $time;
+        else
+            throw new Invalid("The input must be a time.");
 
         if ($unique) {
             $data = self::generator()->nextObjectId($timestamp);

tests/Unit/ObjectIdTest.php

@@ -25,6 +25,11 @@
                 Invalid::class,
             );
         }
+        foreach ([null, 1] as $specimen) {
+            expect(fn() => ObjectId::fromBinary($specimen))->toThrow(
+                Invalid::class,
+            );
+        }
     });
 
     it('creates an ObjectId from string', function () {
@@ -35,10 +40,12 @@
         expect($objectId->toBinary())->toBe($rawId);
     });
 
-    it('throws Invalid exception in fromString for a non-hex string', function () {
-        expect(fn() => ObjectId::fromString('ダメ'))->toThrow(
-            Invalid::class,
-        );
+    it('throws Invalid exception in fromString for an invalid string', function () {
+        foreach ([null, 1, 'ダメ'] as $specimen) {
+            expect(fn() => ObjectId::fromString($specimen))->toThrow(
+                Invalid::class,
+            );
+        }
     });
 
     it('throws Invalid exception in fromString when the length is no good', function () {
@@ -65,6 +72,27 @@
         expect(substr($objectId->toString(), -16))->toBe(str_repeat('00', 8));
     });
 
+    it('throws Invalid exception in fromTime for an invalid value', function () {
+        foreach ([null, 'ダメ'] as $specimen) {
+            expect(fn() => ObjectId::fromTime($specimen))->toThrow(
+                Invalid::class,
+            );
+        }
+    });
+
+    it('should allow timestamps to wrap over', function () {
+        foreach ([
+            [Carbon::createFromTimestamp(0x100000000), 0],
+            [Carbon::createFromTimestamp(-1), 0xffffffff],
+            [0x100000000, 0],
+            [-1, 0xffffffff],
+        ] as [$time, $expected]) {
+            $objectId = ObjectId::fromTime($time);
+            $embeddedTime = new Carbon($objectId->toTime());
+            expect($embeddedTime->getTimestamp())->toBe($expected);
+        }
+    });
+
     it('returns the 24-char hex string via __toString()', function () {
         $objectId = ObjectId::fromString(str_repeat('00', 12));
         expect((string)$objectId)->toBe(str_repeat('00', 12));