PHPLIB-1011: Support asserting multiple types in legacy $$type operator

This refactors DocumentsMatchConstraint to use the IsBsonType constraint from the unified test runner.

Author: jmikola

tests/SpecTests/DocumentsMatchConstraint.php

@@ -4,28 +4,11 @@
 
 use ArrayObject;
 use InvalidArgumentException;
-use LogicException;
-use MongoDB\BSON\BinaryInterface;
-use MongoDB\BSON\DBPointer;
-use MongoDB\BSON\Decimal128;
 use MongoDB\BSON\Int64;
-use MongoDB\BSON\Javascript;
-use MongoDB\BSON\MaxKey;
-use MongoDB\BSON\MinKey;
-use MongoDB\BSON\ObjectId;
-use MongoDB\BSON\Regex;
-use MongoDB\BSON\Symbol;
-use MongoDB\BSON\Timestamp;
-use MongoDB\BSON\Undefined;
-use MongoDB\BSON\UTCDateTime;
 use MongoDB\Model\BSONArray;
 use MongoDB\Model\BSONDocument;
+use MongoDB\Tests\UnifiedSpecTests\Constraint\IsBsonType;
 use PHPUnit\Framework\Constraint\Constraint;
-use PHPUnit\Framework\Constraint\IsInstanceOf;
-use PHPUnit\Framework\Constraint\IsNull;
-use PHPUnit\Framework\Constraint\IsType;
-use PHPUnit\Framework\Constraint\LogicalNot;
-use PHPUnit\Framework\Constraint\LogicalOr;
 use RuntimeException;
 use SebastianBergmann\Comparator\ComparisonFailure;
 use SebastianBergmann\Comparator\Factory;
@@ -39,6 +22,12 @@
 use function is_float;
 use function is_int;
 use function is_object;
+use function PHPUnit\Framework\assertThat;
+use function PHPUnit\Framework\containsOnly;
+use function PHPUnit\Framework\isInstanceOf;
+use function PHPUnit\Framework\isType;
+use function PHPUnit\Framework\logicalAnd;
+use function PHPUnit\Framework\logicalOr;
 use function sprintf;
 
 use const PHP_INT_SIZE;
@@ -131,133 +120,18 @@ private function doEvaluate($other, $description = '', $returnResult = false)
     }
 
     /**
-     * @param mixed $actualValue
+     * @param string|string[] $expectedType
+     * @param mixed           $actualValue
      */
-    private function assertBSONType(string $expectedType, $actualValue): void
+    private function assertBSONType($expectedType, $actualValue): void
     {
-        switch ($expectedType) {
-            case 'double':
-                (new IsType('float'))->evaluate($actualValue);
+        assertThat(
+            $expectedType,
+            logicalOr(isType('string'), logicalAnd(isInstanceOf(BSONArray::class), containsOnly('string'))),
+            '$$type requires string or string[]'
+        );
 
-                return;
-
-            case 'string':
-                (new IsType('string'))->evaluate($actualValue);
-
-                return;
-
-            case 'object':
-                LogicalOr::fromConstraints(
-                    new IsType('object'),
-                    new LogicalNot(new IsInstanceOf(BSONArray::class))
-                )->evaluate($actualValue);
-
-                return;
-
-            case 'array':
-                LogicalOr::fromConstraints(
-                    new IsType('array'),
-                    new IsInstanceOf(BSONArray::class)
-                )->evaluate($actualValue);
-
-                return;
-
-            case 'binData':
-                (new IsInstanceOf(BinaryInterface::class))->evaluate($actualValue);
-
-                return;
-
-            case 'undefined':
-                (new IsInstanceOf(Undefined::class))->evaluate($actualValue);
-
-                return;
-
-            case 'objectId':
-                (new IsInstanceOf(ObjectId::class))->evaluate($actualValue);
-
-                return;
-
-            case 'boolean':
-                (new IsType('bool'))->evaluate($actualValue);
-
-                return;
-
-            case 'date':
-                (new IsInstanceOf(UTCDateTime::class))->evaluate($actualValue);
-
-                return;
-
-            case 'null':
-                (new IsNull())->evaluate($actualValue);
-
-                return;
-
-            case 'regex':
-                (new IsInstanceOf(Regex::class))->evaluate($actualValue);
-
-                return;
-
-            case 'dbPointer':
-                (new IsInstanceOf(DBPointer::class))->evaluate($actualValue);
-
-                return;
-
-            case 'javascript':
-                (new IsInstanceOf(Javascript::class))->evaluate($actualValue);
-
-                return;
-
-            case 'symbol':
-                (new IsInstanceOf(Symbol::class))->evaluate($actualValue);
-
-                return;
-
-            case 'int':
-                (new IsType('int'))->evaluate($actualValue);
-
-                return;
-
-            case 'timestamp':
-                (new IsInstanceOf(Timestamp::class))->evaluate($actualValue);
-
-                return;
-
-            case 'long':
-                LogicalOr::fromConstraints(
-                    new IsType('int'),
-                    new IsInstanceOf(Int64::class)
-                )->evaluate($actualValue);
-
-                return;
-
-            case 'decimal':
-                (new IsInstanceOf(Decimal128::class))->evaluate($actualValue);
-
-                return;
-
-            case 'minKey':
-                (new IsInstanceOf(MinKey::class))->evaluate($actualValue);
-
-                return;
-
-            case 'maxKey':
-                (new IsInstanceOf(MaxKey::class))->evaluate($actualValue);
-
-                return;
-
-            case 'number':
-                LogicalOr::fromConstraints(
-                    new IsType('int'),
-                    new IsInstanceOf(Int64::class),
-                    new IsType('float'),
-                    new IsInstanceOf(Decimal128::class)
-                )->evaluate($actualValue);
-
-                return;
-
-            default:
-                throw new LogicException('Unsupported type: ' . $expectedType);
-        }
+        IsBsonType::anyOf(...(array) $expectedType)->evaluate($actualValue);
     }
 
     /**

tests/SpecTests/DocumentsMatchConstraintTest.php

@@ -98,7 +98,7 @@ public function provideBSONTypes()
             'binData' => ['binData', new Binary('', 0)],
             'undefined' => ['undefined', $undefined],
             'objectId' => ['objectId', new ObjectId()],
-            'boolean' => ['boolean', true],
+            'bool' => ['bool', true],
             'date' => ['date', new UTCDateTime()],
             'null' => ['null', null],
             'regex' => ['regex', new Regex('.*')],
@@ -120,6 +120,22 @@ public function provideBSONTypes()
         ];
     }
 
+    public function testBSONTypeAssertionsWithMultipleTypes(): void
+    {
+        $c1 = new DocumentsMatchConstraint(['x' => ['$$type' => ['double', 'int']]]);
+
+        $this->assertResult(true, $c1, ['x' => 1], 'int is double or int');
+        $this->assertResult(true, $c1, ['x' => 1.4], 'double is double or int');
+        $this->assertResult(false, $c1, ['x' => 'foo'], 'string is not double or int');
+
+        $c2 = new DocumentsMatchConstraint(['x' => ['$$type' => ['number', 'string']]]);
+
+        $this->assertResult(true, $c2, ['x' => 1], 'int is number or string');
+        $this->assertResult(true, $c2, ['x' => 1.4], 'double is number or string');
+        $this->assertResult(true, $c2, ['x' => 'foo'], 'string is number or string');
+        $this->assertResult(false, $c2, ['x' => true], 'bool is not number or string');
+    }
+
     /**
      * @dataProvider errorMessageProvider
      */