Merge pull request #671

Author: alcaeus

src/Operation/ListCollections.php

@@ -130,7 +130,7 @@ private function executeCommand(Server $server)
             $cmd['maxTimeMS'] = $this->options['maxTimeMS'];
         }
 
-        $cursor = $server->executeCommand($this->databaseName, new Command($cmd), $this->createOptions());
+        $cursor = $server->executeReadCommand($this->databaseName, new Command($cmd), $this->createOptions());
         $cursor->setTypeMap(['root' => 'array', 'document' => 'array']);
 
         return new CollectionInfoCommandIterator(new CachingIterator($cursor));

src/Operation/ListDatabases.php

@@ -98,7 +98,7 @@ public function execute(Server $server)
             $cmd['maxTimeMS'] = $this->options['maxTimeMS'];
         }
 
-        $cursor = $server->executeCommand('admin', new Command($cmd), $this->createOptions());
+        $cursor = $server->executeReadCommand('admin', new Command($cmd), $this->createOptions());
         $cursor->setTypeMap(['root' => 'array', 'document' => 'array']);
         $result = current($cursor->toArray());
 

src/Operation/ListIndexes.php

@@ -126,7 +126,7 @@ private function executeCommand(Server $server)
         }
 
         try {
-            $cursor = $server->executeCommand($this->databaseName, new Command($cmd), $this->createOptions());
+            $cursor = $server->executeReadCommand($this->databaseName, new Command($cmd), $this->createOptions());
         } catch (DriverRuntimeException $e) {
             /* The server may return an error if the collection does not exist.
              * Check for possible error codes (see: SERVER-20463) and return an

src/Operation/MapReduce.php

@@ -271,9 +271,15 @@ public function execute(Server $server)
         $command = $this->createCommand($server);
         $options = $this->createOptions($hasOutputCollection);
 
+        /* If the mapReduce operation results in a write, use
+         * executeReadWriteCommand to ensure we're handling the writeConcern
+         * option.
+         * In other cases, we use executeCommand as this will prevent the
+         * mapReduce operation from being retried when retryReads is enabled.
+         * See https://github.com/mongodb/specifications/blob/master/source/retryable-reads/retryable-reads.rst#unsupported-read-operations. */
         $cursor = $hasOutputCollection
             ? $server->executeReadWriteCommand($this->databaseName, $command, $options)
-            : $server->executeReadCommand($this->databaseName, $command, $options);
+            : $server->executeCommand($this->databaseName, $command, $options);
 
         if (isset($this->options['typeMap']) && ! $hasOutputCollection) {
             $cursor->setTypeMap(create_field_path_type_map($this->options['typeMap'], 'results.$'));

tests/SpecTests/CommandExpectations.php

@@ -77,6 +77,21 @@ public static function fromCrud(array $expectedEvents)
         return $o;
     }
 
+    public static function fromRetryableReads(array $expectedEvents)
+    {
+        $o = new self($expectedEvents);
+
+        $o->ignoreCommandFailed = true;
+        $o->ignoreCommandSucceeded = true;
+
+        /* Retryable read spec tests don't include extra commands, e.g. the
+         * killCursors command issued when a change stream is garbage collected.
+         * We ignore any extra events for that reason. \*/
+        $o->ignoreExtraEvents = true;
+
+        return $o;
+    }
+
     public static function fromTransactions(array $expectedEvents)
     {
         $o = new self($expectedEvents);

tests/SpecTests/Context.php

@@ -21,6 +21,7 @@
  */
 final class Context
 {
+    public $bucketName;
     public $client;
     public $collectionName;
     public $databaseName;
@@ -81,6 +82,19 @@ public static function fromCrud(stdClass $test, $databaseName, $collectionName)
         return $o;
     }
 
+    public static function fromRetryableReads(stdClass $test, $databaseName, $collectionName, $bucketName)
+    {
+        $o = new self($databaseName, $collectionName);
+
+        $o->bucketName = $bucketName;
+
+        $clientOptions = isset($test->clientOptions) ? (array) $test->clientOptions : [];
+
+        $o->client = new Client(FunctionalTestCase::getUri(), $clientOptions);
+
+        return $o;
+    }
+
     public static function fromRetryableWrites(stdClass $test, $databaseName, $collectionName)
     {
         $o = new self($databaseName, $collectionName);
@@ -133,6 +147,14 @@ public static function fromTransactions(stdClass $test, $databaseName, $collecti
         return $o;
     }
 
+    /**
+     * @return Client
+     */
+    public function getClient()
+    {
+        return $this->client;
+    }
+
     public function getCollection(array $collectionOptions = [])
     {
         return $this->selectCollection(
@@ -147,6 +169,11 @@ public function getDatabase(array $databaseOptions = [])
         return $this->selectDatabase($this->databaseName, $databaseOptions);
     }
 
+    public function getGridFSBucket(array $bucketOptions = [])
+    {
+        return $this->selectGridFSBucket($this->databaseName, $this->bucketName, $bucketOptions);
+    }
+
     /**
      * Prepare options readConcern, readPreference, and writeConcern options by
      * creating value objects.
@@ -272,6 +299,20 @@ public function selectDatabase($databaseName, array $databaseOptions = [])
         );
     }
 
+    public function selectGridFSBucket($databaseName, $bucketName, array $bucketOptions = [])
+    {
+        return $this->selectDatabase($databaseName)->selectGridFSBucket($this->prepareGridFSBucketOptions($bucketOptions, $bucketName));
+    }
+
+    private function prepareGridFSBucketOptions(array $options, $bucketPrefix)
+    {
+        if ($bucketPrefix !== null) {
+            $options['bucketPrefix'] = $bucketPrefix;
+        }
+
+        return $options;
+    }
+
     private function prepareSessionOptions(array $options)
     {
         if (isset($options['defaultTransactionOptions'])) {

tests/SpecTests/ErrorExpectation.php

@@ -60,6 +60,17 @@ public static function fromChangeStreams(stdClass $result)
         return $o;
     }
 
+    public static function fromRetryableReads(stdClass $operation)
+    {
+        $o = new self();
+
+        if (isset($operation->error)) {
+            $o->isExpected = $operation->error;
+        }
+
+        return $o;
+    }
+
     public static function fromRetryableWrites(stdClass $outcome)
     {
         $o = new self();

tests/SpecTests/FunctionalTestCase.php

@@ -185,31 +185,44 @@ protected function dropTestAndOutcomeCollections()
     {
         $context = $this->getContext();
 
-        $collection = $context->getCollection();
-        $collection->drop($context->defaultWriteOptions);
+        if ($context->bucketName !== null) {
+            $bucket = $context->getGridFSBucket($context->defaultWriteOptions);
+            $bucket->drop();
+        }
 
-        $outcomeCollection = $this->getOutcomeCollection();
+        $collection = null;
+        if ($context->collectionName !== null) {
+            $collection = $context->getCollection();
+            $collection->drop($context->defaultWriteOptions);
+        }
 
-        // Avoid redundant drop if the test and outcome collections are the same
-        if ($outcomeCollection->getNamespace() !== $collection->getNamespace()) {
-            $outcomeCollection->drop($context->defaultWriteOptions);
+        if ($context->outcomeCollectionName !== null) {
+            $outcomeCollection = $this->getOutcomeCollection();
+
+            // Avoid redundant drop if the test and outcome collections are the same
+            if ($collection === null || $outcomeCollection->getNamespace() !== $collection->getNamespace()) {
+                $outcomeCollection->drop($context->defaultWriteOptions);
+            }
         }
     }
 
     /**
      * Insert data fixtures into the test collection.
      *
-     * @param array $documents
+     * @param array       $documents
+     * @param string|null $collectionName
      */
-    protected function insertDataFixtures(array $documents)
+    protected function insertDataFixtures(array $documents, $collectionName = null)
     {
         if (empty($documents)) {
             return;
         }
 
         $context = $this->getContext();
-        $collection = $context->getCollection();
+        $collection = $collectionName ? $context->selectCollection($context->databaseName, $collectionName) : $context->getCollection();
         $collection->insertMany($documents, $context->defaultWriteOptions);
+
+        return;
     }
 
     private function getOutcomeCollection()