IsBsonType helpers and new IsStream constraint

Author: jmikola

tests/UnifiedSpecTests/Constraint/IsBsonType.php

@@ -21,9 +21,11 @@
 use MongoDB\Model\BSONArray;
 use MongoDB\Model\BSONDocument;
 use PHPUnit\Framework\Constraint\Constraint;
+use PHPUnit\Framework\Constraint\LogicalOr;
 use RuntimeException;
 use Symfony\Bridge\PhpUnit\ConstraintTrait;
 use function array_keys;
+use function array_map;
 use function count;
 use function is_array;
 use function is_bool;
@@ -76,6 +78,22 @@ public function __construct(string $type)
         $this->type = $type;
     }
 
+    public static function any() : LogicalOr
+    {
+        return self::anyOf(...array_keys(self::$knownTypes));
+    }
+
+    public static function anyOf(string ...$types) : Constraint
+    {
+        if (count($types) === 1) {
+            return new self(...$types);
+        }
+
+        return LogicalOr::fromConstraints(...array_map(function ($type) {
+            return new self($type);
+        }, $types));
+    }
+
     private function doMatches($other) : bool
     {
         switch ($this->type) {

tests/UnifiedSpecTests/Constraint/IsBsonTypeTest.php

@@ -15,8 +15,10 @@
 use MongoDB\Model\BSONArray;
 use MongoDB\Model\BSONDocument;
 use MongoDB\Tests\TestCase;
+use PHPUnit\Framework\Constraint\Constraint;
 use PHPUnit\Framework\ExpectationFailedException;
 use stdClass;
+use function fopen;
 use function MongoDB\BSON\fromJSON;
 use function MongoDB\BSON\toPHP;
 use function unserialize;
@@ -29,9 +31,7 @@ class IsBsonTypeTest extends TestCase
      */
     public function testConstraint($type, $value)
     {
-        $c = new IsBsonType($type);
-
-        $this->assertTrue($c->evaluate($value, '', true));
+        $this->assertResult(true, new IsBsonType($type), $value, $this->dataName() . ' is ' . $type);
     }
 
     public function provideTypes()
@@ -69,6 +69,28 @@ public function provideTypes()
         ];
     }
 
+    /**
+     * @dataProvider provideTypes
+     */
+    public function testAny($type, $value)
+    {
+        $this->assertResult(true, IsBsonType::any(), $value, $this->dataName() . ' is a BSON type');
+    }
+
+    public function testAnyExcludesStream()
+    {
+        $this->assertResult(false, IsBsonType::any(), fopen('php://temp', 'w+b'), 'stream is not a BSON type');
+    }
+
+    public function testAnyOf()
+    {
+        $c = IsBsonType::anyOf('double', 'int');
+
+        $this->assertResult(true, $c, 1, 'int is double or int');
+        $this->assertResult(true, $c, 1.4, 'int is double or int');
+        $this->assertResult(false, $c, 'foo', 'string is not double or int');
+    }
+
     public function testErrorMessage()
     {
         $c = new IsBsonType('string');
@@ -129,7 +151,7 @@ public function testTypeJavascriptWithScope()
         $this->assertResult(false, $c, new Javascript('foo = 1;'), 'javascript is not javascriptWithScope');
     }
 
-    private function assertResult($expected, IsBsonType $constraint, $value, $message)
+    private function assertResult($expected, Constraint $constraint, $value, string $message = '')
     {
         $this->assertSame($expected, $constraint->evaluate($value, '', true), $message);
     }

tests/UnifiedSpecTests/Constraint/IsStream.php

@@ -0,0 +1,23 @@
+<?php
+
+namespace MongoDB\Tests\UnifiedSpecTests\Constraint;
+
+use PHPUnit\Framework\Constraint\Constraint;
+use Symfony\Bridge\PhpUnit\ConstraintTrait;
+use function get_resource_type;
+use function is_resource;
+
+final class IsStream extends Constraint
+{
+    use ConstraintTrait;
+
+    private function doMatches($other) : bool
+    {
+        return is_resource($other) && get_resource_type($other) === 'stream';
+    }
+
+    private function doToString() : string
+    {
+        return 'is a stream';
+    }
+}

tests/UnifiedSpecTests/Constraint/IsStreamTest.php

@@ -0,0 +1,18 @@
+<?php
+
+namespace MongoDB\Tests\UnifiedSpecTests\Constraint;
+
+use MongoDB\Tests\TestCase;
+use function fopen;
+
+class IsStreamTest extends TestCase
+{
+    public function testConstraint()
+    {
+        $c = new IsStream();
+
+        $this->assertTrue($c->evaluate(fopen('php://temp', 'w+b'), '', true));
+        $this->assertFalse($c->evaluate(1, '', true));
+        $this->assertFalse($c->evaluate('foo', '', true));
+    }
+}

tests/UnifiedSpecTests/Constraint/Matches.php

@@ -10,7 +10,6 @@
 use MongoDB\Model\BSONDocument;
 use MongoDB\Tests\UnifiedSpecTests\EntityMap;
 use PHPUnit\Framework\Constraint\Constraint;
-use PHPUnit\Framework\Constraint\LogicalOr;
 use PHPUnit\Framework\ExpectationFailedException;
 use RuntimeException;
 use SebastianBergmann\Comparator\ComparisonFailure;
@@ -24,14 +23,11 @@
 use function containsOnly;
 use function count;
 use function get_class;
-use function get_resource_type;
 use function gettype;
 use function hex2bin;
 use function implode;
 use function is_array;
 use function is_object;
-use function is_resource;
-use function is_string;
 use function isInstanceOf;
 use function isType;
 use function logicalAnd;
@@ -244,14 +240,7 @@ private function assertMatchesOperator(BSONDocument $operator, $actual, string $
                 '$$type requires string or string[]'
             );
 
-            $types = (array) $operator['$$type'];
-            $constraints = [];
-
-            foreach ($types as $type) {
-                $constraints[] = new IsBsonType($type);
-            }
-
-            $constraint = LogicalOr::fromConstraints(...$constraints);
+            $constraint = IsBsonType::anyOf(...(array) $operator['$$type']);
 
             if (! $constraint->evaluate($actual, '', true)) {
                 self::failAt(sprintf('%s is not an expected BSON type: %s', $this->exporter()->shortenedExport($actual), implode(', ', $types)), $keyPath);
@@ -275,10 +264,7 @@ private function assertMatchesOperator(BSONDocument $operator, $actual, string $
         if ($name === '$$matchesHexBytes') {
             assertInternalType('string', $operator['$$matchesHexBytes'], '$$matchesHexBytes requires string');
             assertRegExp('/^([0-9a-fA-F]{2})*$/', $operator['$$matchesHexBytes'], '$$matchesHexBytes requires pairs of hex chars');
-
-            if (! is_resource($actual) || get_resource_type($actual) != "stream") {
-                self::failAt(sprintf('%s is not a stream', $this->exporter()->shortenedExport($actual)), $keyPath);
-            }
+            assertThat($actual, new IsStream());
 
             if (stream_get_contents($actual, -1, 0) !== hex2bin($operator['$$matchesHexBytes'])) {
                 self::failAt(sprintf('%s does not match expected hex bytes: %s', $this->exporter()->shortenedExport($actual), $operator['$$matchesHexBytes']), $keyPath);

tests/UnifiedSpecTests/Constraint/MatchesTest.php

@@ -108,12 +108,10 @@ public function testOperatorMatchesHexBytes()
         $c = new Matches(['$$matchesHexBytes' => 'DEADBEEF']);
         $this->assertResult(true, $c, $stream1, 'value matches hex bytes (root-level)');
         $this->assertResult(false, $c, $stream2, 'value does not match hex bytes (root-level)');
-        $this->assertResult(false, $c, 1, 'value is not a stream');
 
         $c = new Matches(['x' => ['$$matchesHexBytes' => '90ABCDEF']]);
         $this->assertResult(true, $c, ['x' => $stream2], 'value matches hex bytes (embedded)');
         $this->assertResult(false, $c, ['x' => $stream1], 'value does not match hex bytes (embedded)');
-        $this->assertResult(false, $c, ['x' => 1], 'value is not a stream');
     }
 
     public function testOperatorUnsetOrMatches()
@@ -303,7 +301,7 @@ public function operatorErrorMessageProvider()
         ];
     }
 
-    private function assertResult($expected, Matches $constraint, $value, $message)
+    private function assertResult($expected, Matches $constraint, $value, string $message = '')
     {
         $this->assertSame($expected, $constraint->evaluate($value, '', true), $message);
     }