PHPLIB-493: Unified test runner POC

composer.json

@@ -16,7 +16,7 @@
         "jean85/pretty-package-versions": "^1.2"
     },
     "require-dev": {
-        "phpunit/phpunit": "^6.4",
+        "phpunit/phpunit": "^6.5",
         "sebastian/comparator": "^2.0 || ^3.0",
         "squizlabs/php_codesniffer": "^3.5, <3.5.5",
         "symfony/phpunit-bridge": "^4.4@dev"
@@ -26,7 +26,10 @@
         "files": [ "src/functions.php" ]
     },
     "autoload-dev": {
-        "psr-4": { "MongoDB\\Tests\\": "tests/" }
+        "psr-4": { "MongoDB\\Tests\\": "tests/" },
+        "// Manually include assertion functions for PHPUnit 8.x and earlier ":"",
+        "// See: https://github.com/sebastianbergmann/phpunit/issues/3746 ":"",
+        "files": [ "vendor/phpunit/phpunit/src/Framework/Assert/Functions.php" ]
     },
     "extra": {
         "branch-alias": {

tests/FunctionalTestCase.php

@@ -308,11 +308,7 @@ protected function isReplicaSet()
 
     protected function isShardedCluster()
     {
-        if ($this->getPrimaryServer()->getType() == Server::TYPE_MONGOS) {
-            return true;
-        }
-
-        return false;
+        return $this->getPrimaryServer()->getType() == Server::TYPE_MONGOS;
     }
 
     protected function isShardedClusterUsingReplicasets()

tests/UnifiedSpecTests/CollectionData.php

@@ -0,0 +1,90 @@
+<?php
+
+namespace MongoDB\Tests\UnifiedSpecTests;
+
+use ArrayIterator;
+use IteratorIterator;
+use MongoDB\Client;
+use MongoDB\Driver\ReadConcern;
+use MongoDB\Driver\ReadPreference;
+use MongoDB\Driver\WriteConcern;
+use MongoDB\Tests\UnifiedSpecTests\Constraint\Matches;
+use MultipleIterator;
+use stdClass;
+use function assertContainsOnly;
+use function assertInternalType;
+use function assertNotNull;
+use function assertThat;
+use function sprintf;
+
+class CollectionData
+{
+    /** @var string */
+    private $collectionName;
+
+    /** @var string */
+    private $databaseName;
+
+    /** @var array */
+    private $documents;
+
+    public function __construct(stdClass $o)
+    {
+        assertInternalType('string', $o->collectionName);
+        $this->collectionName = $o->collectionName;
+
+        assertInternalType('string', $o->databaseName);
+        $this->databaseName = $o->databaseName;
+
+        assertInternalType('array', $o->documents);
+        assertContainsOnly('object', $o->documents);
+        $this->documents = $o->documents;
+    }
+
+    public function prepareInitialData(Client $client)
+    {
+        $database = $client->selectDatabase(
+            $this->databaseName,
+            ['writeConcern' => new WriteConcern(WriteConcern::MAJORITY)]
+        );
+
+        $database->dropCollection($this->collectionName);
+
+        if (empty($this->documents)) {
+            $database->createCollection($this->collectionName);
+
+            return;
+        }
+
+        $database->selectCollection($this->collectionName)->insertMany($this->documents);
+    }
+
+    public function assertOutcome(Client $client)
+    {
+        $collection = $client->selectCollection(
+            $this->databaseName,
+            $this->collectionName,
+            [
+                'readConcern' => new ReadConcern(ReadConcern::LOCAL),
+                'readPreference' => new ReadPreference(ReadPreference::PRIMARY),
+            ]
+        );
+
+        $cursor = $collection->find([], ['sort' => ['_id' => 1]]);
+
+        $mi = new MultipleIterator(MultipleIterator::MIT_NEED_ANY);
+        $mi->attachIterator(new ArrayIterator($this->documents));
+        $mi->attachIterator(new IteratorIterator($cursor));
+
+        foreach ($mi as $i => $documents) {
+            list($expectedDocument, $actualDocument) = $documents;
+            assertNotNull($expectedDocument);
+            assertNotNull($actualDocument);
+
+            /* Prohibit extra root keys and disable operators to enforce exact
+             * matching of documents. Key order variation is still allowed. */
+            $constraint = new Matches($expectedDocument, null, false, false);
+            assertThat($actualDocument, $constraint, sprintf('documents[%d] match', $i));
+        }
+    }
+}

tests/UnifiedSpecTests/Constraint/IsBsonType.php

@@ -0,0 +1,210 @@
+<?php
+
+namespace MongoDB\Tests\UnifiedSpecTests\Constraint;
+
+use LogicException;
+use MongoDB\BSON\BinaryInterface;
+use MongoDB\BSON\DBPointer;
+use MongoDB\BSON\Decimal128Interface;
+use MongoDB\BSON\Int64;
+use MongoDB\BSON\JavascriptInterface;
+use MongoDB\BSON\MaxKeyInterface;
+use MongoDB\BSON\MinKeyInterface;
+use MongoDB\BSON\ObjectIdInterface;
+use MongoDB\BSON\RegexInterface;
+use MongoDB\BSON\Serializable;
+use MongoDB\BSON\Symbol;
+use MongoDB\BSON\TimestampInterface;
+use MongoDB\BSON\Type;
+use MongoDB\BSON\Undefined;
+use MongoDB\BSON\UTCDateTimeInterface;
+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 in_array;
+use function is_array;
+use function is_bool;
+use function is_float;
+use function is_int;
+use function is_object;
+use function is_string;
+use function range;
+use function sprintf;
+use const PHP_INT_SIZE;
+
+final class IsBsonType extends Constraint
+{
+    use ConstraintTrait;
+
+    /** @var array */
+    private static $types = [
+        'double',
+        'string',
+        'object',
+        'array',
+        'binData',
+        'undefined',
+        'objectId',
+        'bool',
+        'date',
+        'null',
+        'regex',
+        'dbPointer',
+        'javascript',
+        'symbol',
+        'javascriptWithScope',
+        'int',
+        'timestamp',
+        'long',
+        'decimal',
+        'minKey',
+        'maxKey',
+    ];
+
+    /** @var string */
+    private $type;
+
+    public function __construct(string $type)
+    {
+        if (! in_array($type, self::$types)) {
+            throw new RuntimeException(sprintf('Type specified for %s <%s> is not a valid type', self::class, $type));
+        }
+
+        $this->type = $type;
+    }
+
+    public static function any() : LogicalOr
+    {
+        return self::anyOf(...self::$types);
+    }
+
+    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) {
+            case 'double':
+                return is_float($other);
+            case 'string':
+                return is_string($other);
+            case 'object':
+                return self::isObject($other);
+            case 'array':
+                return self::isArray($other);
+            case 'binData':
+                return $other instanceof BinaryInterface;
+            case 'undefined':
+                return $other instanceof Undefined;
+            case 'objectId':
+                return $other instanceof ObjectIdInterface;
+            case 'bool':
+                return is_bool($other);
+            case 'date':
+                return $other instanceof UTCDateTimeInterface;
+            case 'null':
+                return $other === null;
+            case 'regex':
+                return $other instanceof RegexInterface;
+            case 'dbPointer':
+                return $other instanceof DBPointer;
+            case 'javascript':
+                return $other instanceof JavascriptInterface && $other->getScope() === null;
+            case 'symbol':
+                return $other instanceof Symbol;
+            case 'javascriptWithScope':
+                return $other instanceof JavascriptInterface && $other->getScope() !== null;
+            case 'int':
+                return is_int($other);
+            case 'timestamp':
+                return $other instanceof TimestampInterface;
+            case 'long':
+                if (PHP_INT_SIZE == 4) {
+                    return $other instanceof Int64;
+                }
+
+                return is_int($other);
+            case 'decimal':
+                return $other instanceof Decimal128Interface;
+            case 'minKey':
+                return $other instanceof MinKeyInterface;
+            case 'maxKey':
+                return $other instanceof MaxKeyInterface;
+            default:
+                // This should already have been caught in the constructor
+                throw new LogicException('Unsupported type: ' . $this->type);
+        }
+    }
+
+    private function doToString() : string
+    {
+        return sprintf('is of BSON type "%s"', $this->type);
+    }
+
+    private static function isArray($other) : bool
+    {
+        if ($other instanceof BSONArray) {
+            return true;
+        }
+
+        // Serializable can produce an array or object, so recurse on its output
+        if ($other instanceof Serializable) {
+            return self::isArray($other->bsonSerialize());
+        }
+
+        if (! is_array($other)) {
+            return false;
+        }
+
+        // Empty and indexed arrays serialize as BSON arrays
+        return self::isArrayEmptyOrIndexed($other);
+    }
+
+    private static function isObject($other) : bool
+    {
+        if ($other instanceof BSONDocument) {
+            return true;
+        }
+
+        // Serializable can produce an array or object, so recurse on its output
+        if ($other instanceof Serializable) {
+            return self::isObject($other->bsonSerialize());
+        }
+
+        // Non-empty, associative arrays serialize as BSON objects
+        if (is_array($other)) {
+            return ! self::isArrayEmptyOrIndexed($other);
+        }
+
+        if (! is_object($other)) {
+            return false;
+        }
+
+        /* Serializable has already been handled, so any remaining instances of
+         * Type will not serialize as BSON objects */
+        return ! $other instanceof Type;
+    }
+
+    private static function isArrayEmptyOrIndexed(array $a) : bool
+    {
+        if (empty($a)) {
+            return true;
+        }
+
+        return array_keys($a) === range(0, count($a) - 1);
+    }
+}