Spec tests for Client::bulkWrite()

jmikola · jmikola · commit 6a692405e0da · 2025-04-01T16:03:48.000-04:00
diff --git a/tests/UnifiedSpecTests/Constraint/Matches.php b/tests/UnifiedSpecTests/Constraint/Matches.php
@@ -5,6 +5,7 @@
 use LogicException;
 use MongoDB\BSON\Document;
 use MongoDB\BSON\Int64;
+use MongoDB\BSON\PackedArray;
 use MongoDB\BSON\Serializable;
 use MongoDB\BSON\Type;
 use MongoDB\Model\BSONArray;
@@ -457,8 +458,14 @@ private static function prepare(mixed $bson): mixed
             return self::prepare($bson->bsonSerialize());
         }
 
-        /* Serializable has already been handled, so any remaining instances of
-         * Type will not serialize as BSON arrays or objects */
+        // Recurse on the PHP representation of Document and PackedArray types
+        if ($bson instanceof Document || $bson instanceof PackedArray) {
+            return self::prepare($bson->toPHP());
+        }
+
+        /* Serializable, Document, and PackedArray have already been handled.
+         * Any remaining Type instances will not serialize as BSON arrays or
+         * objects. */
         if ($bson instanceof Type) {
             return $bson;
         }
diff --git a/tests/UnifiedSpecTests/ExpectedError.php b/tests/UnifiedSpecTests/ExpectedError.php
@@ -2,6 +2,7 @@
 
 namespace MongoDB\Tests\UnifiedSpecTests;
 
+use MongoDB\Driver\Exception\BulkWriteCommandException;
 use MongoDB\Driver\Exception\BulkWriteException;
 use MongoDB\Driver\Exception\CommandException;
 use MongoDB\Driver\Exception\ExecutionTimeoutException;
@@ -12,6 +13,7 @@
 use stdClass;
 use Throwable;
 
+use function count;
 use function PHPUnit\Framework\assertArrayHasKey;
 use function PHPUnit\Framework\assertContainsOnly;
 use function PHPUnit\Framework\assertCount;
@@ -56,14 +58,18 @@ final class ExpectedError
 
     private ?string $codeName = null;
 
-    private ?Matches $matchesResultDocument = null;
+    private ?Matches $matchesErrorResponse = null;
 
     private array $includedLabels = [];
 
     private array $excludedLabels = [];
 
     private ?ExpectedResult $expectedResult = null;
 
+    private ?array $writeErrors = null;
+
+    private ?array $writeConcernErrors = null;
+
     public function __construct(?stdClass $o, EntityMap $entityMap)
     {
         if ($o === null) {
@@ -102,7 +108,7 @@ public function __construct(?stdClass $o, EntityMap $entityMap)
 
         if (isset($o->errorResponse)) {
             assertIsObject($o->errorResponse);
-            $this->matchesResultDocument = new Matches($o->errorResponse, $entityMap);
+            $this->matchesErrorResponse = new Matches($o->errorResponse, $entityMap);
         }
 
         if (isset($o->errorLabelsContain)) {
@@ -120,6 +126,24 @@ public function __construct(?stdClass $o, EntityMap $entityMap)
         if (property_exists($o, 'expectResult')) {
             $this->expectedResult = new ExpectedResult($o, $entityMap);
         }
+
+        if (isset($o->writeErrors)) {
+            assertIsObject($o->writeErrors);
+            assertContainsOnly('object', (array) $o->writeErrors);
+
+            foreach ($o->writeErrors as $i => $writeError) {
+                $this->writeErrors[$i] = new Matches($writeError, $entityMap);
+            }
+        }
+
+        if (isset($o->writeConcernErrors)) {
+            assertIsArray($o->writeConcernErrors);
+            assertContainsOnly('object', $o->writeConcernErrors);
+
+            foreach ($o->writeConcernErrors as $i => $writeConcernError) {
+                $this->writeConcernErrors[$i] = new Matches($writeConcernError, $entityMap);
+            }
+        }
     }
 
     /**
@@ -159,15 +183,21 @@ public function assert(?Throwable $e = null): void
             $this->assertCodeName($e);
         }
 
-        if (isset($this->matchesResultDocument)) {
-            assertThat($e, logicalOr(isInstanceOf(CommandException::class), isInstanceOf(BulkWriteException::class)));
+        if (isset($this->matchesErrorResponse)) {
+            assertThat($e, logicalOr(
+                isInstanceOf(CommandException::class),
+                isInstanceOf(BulkWriteException::class),
+                isInstanceOf(BulkWriteCommandException::class),
+            ));
 
             if ($e instanceof CommandException) {
-                assertThat($e->getResultDocument(), $this->matchesResultDocument, 'CommandException result document matches');
+                assertThat($e->getResultDocument(), $this->matchesErrorResponse, 'CommandException result document matches expected errorResponse');
+            } elseif ($e instanceof BulkWriteCommandException) {
+                assertThat($e->getErrorReply(), $this->matchesErrorResponse, 'BulkWriteCommandException error reply matches expected errorResponse');
             } elseif ($e instanceof BulkWriteException) {
                 $writeErrors = $e->getWriteResult()->getErrorReplies();
                 assertCount(1, $writeErrors);
-                assertThat($writeErrors[0], $this->matchesResultDocument, 'BulkWriteException result document matches');
+                assertThat($writeErrors[0], $this->matchesErrorResponse, 'BulkWriteException first error reply matches expected errorResponse');
             }
         }
 
@@ -184,16 +214,34 @@ public function assert(?Throwable $e = null): void
         }
 
         if (isset($this->expectedResult)) {
-            assertInstanceOf(BulkWriteException::class, $e);
-            $this->expectedResult->assert($e->getWriteResult());
+            assertThat($e, logicalOr(
+                isInstanceOf(BulkWriteException::class),
+                isInstanceOf(BulkWriteCommandException::class),
+            ));
+
+            if ($e instanceof BulkWriteCommandException) {
+                $this->expectedResult->assert($e->getPartialResult());
+            } elseif ($e instanceof BulkWriteException) {
+                $this->expectedResult->assert($e->getWriteResult());
+            }
+        }
+
+        if (isset($this->writeErrors)) {
+            assertInstanceOf(BulkWriteCommandException::class, $e);
+            $this->assertWriteErrors($e->getWriteErrors());
+        }
+
+        if (isset($this->writeConcernErrors)) {
+            assertInstanceOf(BulkWriteCommandException::class, $e);
+            $this->assertWriteConcernErrors($e->getWriteConcernErrors());
         }
     }
 
     private function assertIsClientError(Throwable $e): void
     {
-        /* Note: BulkWriteException may proxy a previous exception. Unwrap it
-         * to check the original error. */
-        if ($e instanceof BulkWriteException && $e->getPrevious() !== null) {
+        /* Note: BulkWriteException and BulkWriteCommandException may proxy a
+         * previous exception. Unwrap it to check the original error. */
+        if (($e instanceof BulkWriteException || $e instanceof BulkWriteCommandException) && $e->getPrevious() !== null) {
             $e = $e->getPrevious();
         }
 
@@ -230,4 +278,47 @@ private function assertCodeName(ServerException $e): void
         assertObjectHasProperty('codeName', $result);
         assertSame($this->codeName, $result->codeName);
     }
+
+    private function assertWriteErrors(array $writeErrors): void
+    {
+        assertCount(count($this->writeErrors), $writeErrors);
+
+        foreach ($this->writeErrors as $i => $matchesWriteError) {
+            assertArrayHasKey($i, $writeErrors);
+            $writeError = $writeErrors[$i];
+
+            // Not required by the spec test, but asserts PHPC correctness
+            assertSame((int) $i, $writeError->getIndex());
+
+            /* Convert the WriteError into a document for matching. These
+             * field names are derived from the CRUD spec. */
+            $writeErrorDocument = [
+                'code' => $writeError->getCode(),
+                'message' => $writeError->getMessage(),
+                'details' => $writeError->getInfo(),
+            ];
+
+            assertThat($writeErrorDocument, $matchesWriteError);
+        }
+    }
+
+    private function assertWriteConcernErrors(array $writeConcernErrors): void
+    {
+        assertCount(count($this->writeConcernErrors), $writeConcernErrors);
+
+        foreach ($this->writeConcernErrors as $i => $matchesWriteConcernError) {
+            assertArrayHasKey($i, $writeConcernErrors);
+            $writeConcernError = $writeConcernErrors[$i];
+
+            /* Convert the WriteConcernError into a document for matching.
+             * These field names are derived from the CRUD spec. */
+            $writeConcernErrorDocument = [
+                'code' => $writeConcernError->getCode(),
+                'message' => $writeConcernError->getMessage(),
+                'details' => $writeConcernError->getInfo(),
+            ];
+
+            assertThat($writeConcernErrorDocument, $matchesWriteConcernError);
+        }
+    }
 }
diff --git a/tests/UnifiedSpecTests/ExpectedResult.php b/tests/UnifiedSpecTests/ExpectedResult.php
@@ -4,13 +4,15 @@
 
 use MongoDB\BulkWriteResult;
 use MongoDB\DeleteResult;
+use MongoDB\Driver\BulkWriteCommandResult;
 use MongoDB\Driver\WriteResult;
 use MongoDB\InsertManyResult;
 use MongoDB\InsertOneResult;
 use MongoDB\Tests\UnifiedSpecTests\Constraint\Matches;
 use MongoDB\UpdateResult;
 use stdClass;
 
+use function array_filter;
 use function is_object;
 use function PHPUnit\Framework\assertThat;
 use function property_exists;
@@ -57,6 +59,10 @@ private static function prepare($value)
             return $value;
         }
 
+        if ($value instanceof BulkWriteCommandResult) {
+            return self::prepareBulkWriteCommandResult($value);
+        }
+
         if (
             $value instanceof BulkWriteResult ||
             $value instanceof WriteResult ||
@@ -71,7 +77,31 @@ private static function prepare($value)
         return $value;
     }
 
-    private static function prepareWriteResult($value)
+    private static function prepareBulkWriteCommandResult(BulkWriteCommandResult $result): array
+    {
+        $retval = [
+            'deletedCount' => $result->getDeletedCount(),
+            'insertedCount' => $result->getInsertedCount(),
+            'matchedCount' => $result->getMatchedCount(),
+            'modifiedCount' => $result->getModifiedCount(),
+            'upsertedCount' => $result->getUpsertedCount(),
+        ];
+
+        /* Tests use $$unsetOrMatches to expect either no key or an empty
+         * document when verboseResults=false, so filter out null values. */
+        $retval += array_filter(
+            [
+                'deleteResults' => $result->getDeleteResults()?->toPHP(),
+                'insertResults' => $result->getInsertResults()?->toPHP(),
+                'updateResults' => $result->getUpdateResults()?->toPHP(),
+            ],
+            fn ($value) => $value !== null,
+        );
+
+        return $retval;
+    }
+
+    private static function prepareWriteResult($value): array
     {
         $result = ['acknowledged' => $value->isAcknowledged()];
 
diff --git a/tests/UnifiedSpecTests/Operation.php b/tests/UnifiedSpecTests/Operation.php
@@ -7,6 +7,7 @@
 use MongoDB\Client;
 use MongoDB\Collection;
 use MongoDB\Database;
+use MongoDB\Driver\BulkWriteCommand;
 use MongoDB\Driver\ClientEncryption;
 use MongoDB\Driver\Cursor;
 use MongoDB\Driver\Server;
@@ -87,10 +88,7 @@ final class Operation
             'assertNumberConnectionsCheckedOut' => 'PHP does not implement CMAP',
             'createEntities' => 'createEntities is not implemented (PHPC-1760)',
         ],
-        Client::class => [
-            'clientBulkWrite' => 'clientBulkWrite is not implemented (PHPLIB-847)',
-            'listDatabaseObjects' => 'listDatabaseObjects is not implemented',
-        ],
+        Client::class => ['listDatabaseObjects' => 'listDatabaseObjects is not implemented'],
         Cursor::class => ['iterateOnce' => 'iterateOnce is not implemented (PHPC-1760)'],
         Database::class => [
             'createCommandCursor' => 'commandCursor API is not yet implemented (PHPLIB-1077)',
@@ -257,6 +255,18 @@ private function executeForClient(Client $client)
         Util::assertArgumentsBySchema(Client::class, $this->name, $args);
 
         switch ($this->name) {
+            case 'clientBulkWrite':
+                assertArrayHasKey('models', $args);
+                assertIsArray($args['models']);
+
+                // Options for BulkWriteCommand and Server::executeBulkWriteCommand() will be mixed
+                $options = array_diff_key($args, ['models' => 1]);
+
+                return $client->bulkWrite(
+                    self::prepareBulkWriteCommand($args['models'], $options),
+                    $options,
+                );
+
             case 'createChangeStream':
                 assertArrayHasKey('pipeline', $args);
                 assertIsArray($args['pipeline']);
@@ -1001,6 +1011,82 @@ private function skipIfOperationIsNotSupported(string $executingObjectName): voi
         Assert::markTestSkipped($skipReason);
     }
 
+    private static function prepareBulkWriteCommand(array $models, array $options): BulkWriteCommand
+    {
+        $bulk = new BulkWriteCommand($options);
+
+        foreach ($models as $model) {
+            $model = (array) $model;
+            assertCount(1, $model);
+
+            $type = key($model);
+            $args = current($model);
+            assertIsObject($args);
+            $args = (array) $args;
+
+            assertArrayHasKey('namespace', $args);
+            assertIsString($args['namespace']);
+
+            switch ($type) {
+                case 'deleteMany':
+                case 'deleteOne':
+                    assertArrayHasKey('filter', $args);
+                    assertInstanceOf(stdClass::class, $args['filter']);
+
+                    $bulk->{$type}(
+                        $args['namespace'],
+                        $args['filter'],
+                        array_diff_key($args, ['namespace' => 1, 'filter' => 1]),
+                    );
+                    break;
+
+                case 'insertOne':
+                    assertArrayHasKey('document', $args);
+                    assertInstanceOf(stdClass::class, $args['document']);
+
+                    $bulk->insertOne(
+                        $args['namespace'],
+                        $args['document'],
+                    );
+                    break;
+
+                case 'replaceOne':
+                    assertArrayHasKey('filter', $args);
+                    assertArrayHasKey('replacement', $args);
+                    assertInstanceOf(stdClass::class, $args['filter']);
+                    assertInstanceOf(stdClass::class, $args['replacement']);
+
+                    $bulk->replaceOne(
+                        $args['namespace'],
+                        $args['filter'],
+                        $args['replacement'],
+                        array_diff_key($args, ['namespace' => 1, 'filter' => 1, 'replacement' => 1]),
+                    );
+                    break;
+
+                case 'updateMany':
+                case 'updateOne':
+                    assertArrayHasKey('filter', $args);
+                    assertArrayHasKey('update', $args);
+                    assertInstanceOf(stdClass::class, $args['filter']);
+                    assertThat($args['update'], logicalOr(new IsType('array'), new IsType('object')));
+
+                    $bulk->{$type}(
+                        $args['namespace'],
+                        $args['filter'],
+                        $args['update'],
+                        array_diff_key($args, ['namespace' => 1, 'filter' => 1, 'update' => 1]),
+                    );
+                    break;
+
+                default:
+                    Assert::fail('Unsupported bulk write model: ' . $type);
+            }
+        }
+
+        return $bulk;
+    }
+
     private static function prepareBulkWriteRequest(stdClass $request): array
     {
         $request = (array) $request;
@@ -1026,6 +1112,7 @@ private static function prepareBulkWriteRequest(stdClass $request): array
 
             case 'insertOne':
                 assertArrayHasKey('document', $args);
+                assertInstanceOf(stdClass::class, $args['document']);
 
                 return ['insertOne' => [$args['document']]];
 
diff --git a/tests/UnifiedSpecTests/UnifiedTestRunner.php b/tests/UnifiedSpecTests/UnifiedTestRunner.php
diff --git a/tests/UnifiedSpecTests/Util.php b/tests/UnifiedSpecTests/Util.php
