mongo 2.19.3 → 2.20.0

data/spec/spec_tests/data/run_command_unified/runCommand.yml

@@ -0,0 +1,319 @@
+description: runCommand
+
+schemaVersion: "1.3"
+
+createEntities:
+  - client:
+      id: &client client
+      useMultipleMongoses: false
+      observeEvents: [commandStartedEvent]
+  - database:
+      id: &db db
+      client: *client
+      databaseName: *db
+  - collection:
+      id: &collection collection
+      database: *db
+      collectionName: *collection
+  - database:
+      id: &dbWithRC dbWithRC
+      client: *client
+      databaseName: *dbWithRC
+      databaseOptions:
+        readConcern: { level: 'local' }
+  - database:
+      id: &dbWithWC dbWithWC
+      client: *client
+      databaseName: *dbWithWC
+      databaseOptions:
+        writeConcern: { w: 0 }
+  - session:
+      id: &session session
+      client: *client
+  # Stable API test
+  - client:
+      id: &clientWithStableApi clientWithStableApi
+      observeEvents: [commandStartedEvent]
+      serverApi:
+        version: "1"
+        strict: true
+  - database:
+      id: &dbWithStableApi dbWithStableApi
+      client: *clientWithStableApi
+      databaseName: *dbWithStableApi
+
+initialData:
+- collectionName: *collection
+  databaseName: *db
+  documents: []
+
+tests:
+  - description: always attaches $db and implicit lsid to given command and omits default readPreference
+    operations:
+      - name: runCommand
+        object: *db
+        arguments:
+          commandName: ping
+          command: { ping: 1 }
+        expectResult: { ok: 1 }
+    expectEvents:
+      - client: *client
+        events:
+          - commandStartedEvent:
+              command:
+                ping: 1
+                $db: *db
+                lsid: { $$exists: true }
+                $readPreference: { $$exists: false }
+              commandName: ping
+
+  - description: always gossips the $clusterTime on the sent command
+    runOnRequirements:
+      # Only replicasets and sharded clusters have a $clusterTime
+      - topologies: [ replicaset, sharded ]
+    operations:
+      # We have to run one command to obtain a clusterTime to gossip
+      - name: runCommand
+        object: *db
+        arguments:
+          commandName: ping
+          command: { ping: 1 }
+        expectResult: { ok: 1 }
+      - name: runCommand
+        object: *db
+        arguments:
+          commandName: ping
+          command: { ping: 1 }
+        expectResult: { ok: 1 }
+    expectEvents:
+      - client: *client
+        events:
+          - commandStartedEvent:
+              commandName: ping
+          # Only check the shape of the second ping which should have the $clusterTime received from the first operation
+          - commandStartedEvent:
+              command:
+                ping: 1
+                $clusterTime: { $$exists: true }
+              commandName: ping
+
+  - description: attaches the provided session lsid to given command
+    operations:
+      - name: runCommand
+        object: *db
+        arguments:
+          commandName: ping
+          command: { ping: 1 }
+          session: *session
+        expectResult: { ok: 1 }
+    expectEvents:
+      - client: *client
+        events:
+          - commandStartedEvent:
+              command:
+                ping: 1
+                lsid: { $$sessionLsid: *session }
+                $db: *db
+              commandName: ping
+
+  - description: attaches the provided $readPreference to given command
+    runOnRequirements:
+      # Exclude single topology, which is most likely a standalone server
+      - topologies: [ replicaset, load-balanced, sharded ]
+    operations:
+      - name: runCommand
+        object: *db
+        arguments:
+          commandName: ping
+          command: { ping: 1 }
+          readPreference:  &readPreference { mode: 'nearest' }
+        expectResult: { ok: 1 }
+    expectEvents:
+      - client: *client
+        events:
+          - commandStartedEvent:
+              command:
+                ping: 1
+                $readPreference: *readPreference
+                $db: *db
+              commandName: ping
+
+  - description: does not attach $readPreference to given command on standalone
+    runOnRequirements:
+      # This test assumes that the single topology contains a standalone server;
+      # however, it is possible for a single topology to contain a direct
+      # connection to another server type.
+      # See: https://github.com/mongodb/specifications/blob/master/source/server-selection/server-selection.rst#topology-type-single
+      - topologies: [ single ]
+    operations:
+      - name: runCommand
+        object: *db
+        arguments:
+          commandName: ping
+          command: { ping: 1 }
+          readPreference: { mode: 'nearest' }
+        expectResult: { ok: 1 }
+    expectEvents:
+      - client: *client
+        events:
+          - commandStartedEvent:
+              command:
+                ping: 1
+                $readPreference: { $$exists: false }
+                $db: *db
+              commandName: ping
+
+  - description: does not attach primary $readPreference to given command
+    operations:
+      - name: runCommand
+        object: *db
+        arguments:
+          commandName: ping
+          command: { ping: 1 }
+          readPreference: { mode: 'primary' }
+        expectResult: { ok: 1 }
+    expectEvents:
+      - client: *client
+        events:
+          - commandStartedEvent:
+              command:
+                ping: 1
+                $readPreference: { $$exists: false }
+                $db: *db
+              commandName: ping
+
+  - description: does not inherit readConcern specified at the db level
+    operations:
+      - name: runCommand
+        object: *dbWithRC
+        # Test with a command that supports a readConcern option.
+        # expectResult is intentionally omitted because some drivers
+        # may automatically convert command responses into cursors.
+        arguments:
+          commandName: aggregate
+          command: { aggregate: *collection, pipeline: [], cursor: {} }
+    expectEvents:
+      - client: *client
+        events:
+          - commandStartedEvent:
+              command:
+                aggregate: *collection
+                readConcern: { $$exists: false }
+                $db: *dbWithRC
+              commandName: aggregate
+
+  - description: does not inherit writeConcern specified at the db level
+    operations:
+      - name: runCommand
+        object: *dbWithWC
+        arguments:
+          commandName: insert
+          command:
+            insert: *collection
+            documents: [ { foo: 'bar' } ]
+            ordered: true
+        expectResult: { ok: 1 }
+    expectEvents:
+      - client: *client
+        events:
+          - commandStartedEvent:
+              command:
+                insert: *collection
+                writeConcern: { $$exists: false }
+                $db: *dbWithWC
+              commandName: insert
+
+  - description: does not retry retryable errors on given command
+    runOnRequirements:
+      - minServerVersion: "4.2"
+    operations:
+      - name: failPoint
+        object: testRunner
+        arguments:
+          client: *client
+          failPoint:
+            configureFailPoint: failCommand
+            mode: { times: 1 }
+            data:
+              failCommands: [ping]
+              closeConnection: true
+      - name: runCommand
+        object: *db
+        arguments:
+          commandName: ping
+          command: { ping: 1 }
+        expectError:
+          isClientError: true
+
+  - description: attaches transaction fields to given command
+    runOnRequirements:
+      - minServerVersion: "4.0"
+        topologies: [ replicaset ]
+      - minServerVersion: "4.2"
+        topologies: [ sharded, load-balanced ]
+    operations:
+      - name: withTransaction
+        object: *session
+        arguments:
+          callback:
+            - name: runCommand
+              object: *db
+              arguments:
+                session: *session
+                commandName: insert
+                command:
+                  insert: *collection
+                  documents: [ { foo: 'transaction' } ]
+                  ordered: true
+              expectResult: { $$unsetOrMatches: { insertedId: { $$unsetOrMatches: 1 } } }
+    expectEvents:
+      - client: *client
+        events:
+          - commandStartedEvent:
+              command:
+                insert: *collection
+                documents: [ { foo: 'transaction' } ]
+                ordered: true
+                lsid: { $$sessionLsid: *session }
+                txnNumber: 1
+                startTransaction: true
+                autocommit: false
+                # omitted fields
+                readConcern: { $$exists: false }
+                writeConcern: { $$exists: false }
+              commandName: insert
+              databaseName: *db
+          - commandStartedEvent:
+              command:
+                commitTransaction: 1
+                lsid: { $$sessionLsid: *session }
+                txnNumber: 1
+                autocommit: false
+                # omitted fields
+                writeConcern: { $$exists: false }
+                readConcern: { $$exists: false }
+              commandName: commitTransaction
+              databaseName: admin
+
+  - description: attaches apiVersion fields to given command when stableApi is configured on the client
+    runOnRequirements:
+      - minServerVersion: "5.0"
+    operations:
+      - name: runCommand
+        object: *dbWithStableApi
+        arguments:
+          commandName: ping
+          command:
+            ping: 1
+        expectResult: { ok: 1 }
+    expectEvents:
+      - client: *clientWithStableApi
+        events:
+          - commandStartedEvent:
+              command:
+                ping: 1
+                $db: *dbWithStableApi
+                apiVersion: "1"
+                apiStrict: true
+                apiDeprecationErrors: { $$unsetOrMatches: false }
+              commandName: ping

data/spec/spec_tests/data/sessions_unified/driver-sessions-dirty-session-errors.yml

@@ -0,0 +1,351 @@
+description: "driver-sessions-dirty-session-errors"
+
+schemaVersion: "1.0"
+
+runOnRequirements:
+  - minServerVersion: "4.0"
+    topologies: [ replicaset ]
+  - minServerVersion: "4.1.8"
+    topologies: [ sharded ]
+
+createEntities:
+  - client:
+      id: &client0 client0
+      useMultipleMongoses: false
+      observeEvents: [ commandStartedEvent ]
+  - database:
+      id: &database0 database0
+      client: *client0
+      databaseName: &database0Name session-tests
+  - collection:
+      id: &collection0 collection0
+      database: *database0
+      collectionName: &collection0Name test
+  - session:
+      id: &session0 session0
+      client: *client0
+
+initialData:
+  - collectionName: *collection0Name
+    databaseName: *database0Name
+    documents:
+      - { _id: 1 }
+
+tests:
+  - description: "Dirty explicit session is discarded (insert)"
+    operations:
+      - name: failPoint
+        object: testRunner
+        arguments:
+          client: *client0
+          failPoint:
+            configureFailPoint: failCommand
+            mode: { times: 1 }
+            data:
+              failCommands: [ insert ]
+              closeConnection: true
+      - name: assertSessionNotDirty
+        object: testRunner
+        arguments:
+          session: *session0
+      - name: insertOne
+        object: *collection0
+        arguments:
+          session: *session0
+          document: { _id: 2 }
+        expectResult: { $$unsetOrMatches: { insertedId: { $$unsetOrMatches: 2 } } }
+      - name: assertSessionDirty
+        object: testRunner
+        arguments:
+          session: *session0
+      - name: insertOne
+        object: *collection0
+        arguments:
+          session: *session0
+          document: { _id: 3 }
+        expectResult: { $$unsetOrMatches: { insertedId: { $$unsetOrMatches: 3 } } }
+      - name: assertSessionDirty
+        object: testRunner
+        arguments:
+          session: *session0
+      - name: endSession
+        object: *session0
+      - &find_with_implicit_session
+        name: find
+        object: *collection0
+        arguments:
+          filter: { _id: -1 }
+        expectResult: []
+      - name: assertDifferentLsidOnLastTwoCommands
+        object: testRunner
+        arguments:
+          client: *client0
+    expectEvents:
+      - client: *client0
+        events:
+          - commandStartedEvent: &insert_attempt
+              command:
+                insert: *collection0Name
+                documents: 
+                  - { _id: 2 }
+                ordered: true
+                lsid: { $$sessionLsid: *session0 }
+                txnNumber: 1
+              commandName: insert
+              databaseName: *database0Name
+          - commandStartedEvent: *insert_attempt
+          - commandStartedEvent:
+              command:
+                insert: *collection0Name
+                documents: 
+                  - { _id: 3 }
+                ordered: true
+                lsid: { $$sessionLsid: *session0 }
+                txnNumber: 2
+              commandName: insert
+              databaseName: *database0Name
+          - commandStartedEvent: &find_with_implicit_session_event
+              command:
+                find: *collection0Name
+                filter: { _id: -1 }
+                # There is no explicit session to use with $$sessionLsid, so
+                # just assert an arbitrary lsid document
+                lsid: { $$type: object }
+              commandName: find
+              databaseName: *database0Name
+    outcome:
+      - collectionName: *collection0Name
+        databaseName: *database0Name
+        documents:
+          - { _id: 1 }
+          - { _id: 2 }
+          - { _id: 3 }
+
+  - description: "Dirty explicit session is discarded (findAndModify)"
+    operations:
+      - name: failPoint
+        object: testRunner
+        arguments:
+          client: *client0
+          failPoint:
+            configureFailPoint: failCommand
+            mode: { times: 1 }
+            data:
+              failCommands: [ findAndModify ]
+              closeConnection: true
+      - name: assertSessionNotDirty
+        object: testRunner
+        arguments:
+          session: *session0
+      - name: findOneAndUpdate
+        object: *collection0
+        arguments:
+          session: *session0
+          filter: { _id: 1 }
+          update: { $inc: { x: 1 } }
+          returnDocument: Before
+        expectResult: { _id: 1 }
+      - name: assertSessionDirty
+        object: testRunner
+        arguments:
+          session: *session0
+      - name: endSession
+        object: *session0
+      - *find_with_implicit_session
+      - name: assertDifferentLsidOnLastTwoCommands
+        object: testRunner
+        arguments:
+          client: *client0
+    expectEvents:
+      - client: *client0
+        events:
+          - commandStartedEvent: &findAndModify_attempt
+              command:
+                findAndModify: *collection0Name
+                query: { _id: 1 }
+                update: { $inc: { x: 1 } }
+                new: false
+                lsid: { $$sessionLsid: *session0 }
+                txnNumber: 1
+                readConcern: { $$exists: false }
+                writeConcern: { $$exists: false }
+              commandName: findAndModify
+              databaseName: *database0Name
+          - commandStartedEvent: *findAndModify_attempt
+          - commandStartedEvent: *find_with_implicit_session_event
+    outcome:
+      - collectionName: *collection0Name
+        databaseName: *database0Name
+        documents:
+          - { _id: 1, x: 1 }
+
+  - description: "Dirty implicit session is discarded (insert)"
+    operations:
+      - name: failPoint
+        object: testRunner
+        arguments:
+          client: *client0
+          failPoint:
+            configureFailPoint: failCommand
+            mode: { times: 1 }
+            data:
+              failCommands: [ insert ]
+              closeConnection: true
+      - name: insertOne
+        object: *collection0
+        arguments:
+          document: { _id: 2 }
+        expectResult: { $$unsetOrMatches: { insertedId: { $$unsetOrMatches: 2 } } }
+      - *find_with_implicit_session
+      - name: assertDifferentLsidOnLastTwoCommands
+        object: testRunner
+        arguments:
+          client: *client0
+    expectEvents:
+      - client: *client0
+        events:
+          - commandStartedEvent: &insert_attempt
+              command:
+                insert: *collection0Name
+                documents: 
+                  - { _id: 2 }
+                ordered: true
+                lsid: { $$type: object }
+                txnNumber: 1
+              commandName: insert
+              databaseName: *database0Name
+          - commandStartedEvent: *insert_attempt
+          - commandStartedEvent: *find_with_implicit_session_event
+    outcome:
+      - collectionName: *collection0Name
+        databaseName: *database0Name
+        documents:
+          - { _id: 1 }
+          - { _id: 2 }
+
+  - description: "Dirty implicit session is discarded (findAndModify)"
+    operations:
+      - name: failPoint
+        object: testRunner
+        arguments:
+          client: *client0
+          failPoint:
+            configureFailPoint: failCommand
+            mode: { times: 1 }
+            data:
+              failCommands: [ findAndModify ]
+              closeConnection: true
+      - name: findOneAndUpdate
+        object: *collection0
+        arguments:
+          filter: { _id: 1 }
+          update: { $inc: { x: 1 } }
+          returnDocument: Before
+        expectResult: { _id: 1 }
+      - *find_with_implicit_session
+      - name: assertDifferentLsidOnLastTwoCommands
+        object: testRunner
+        arguments:
+          client: *client0
+    expectEvents:
+      - client: *client0
+        events:
+          - commandStartedEvent: &findAndModify_attempt
+              command:
+                findAndModify: *collection0Name
+                query: { _id: 1 }
+                update: { $inc: { x: 1 } }
+                new: false
+                lsid: { $$type: object }
+                txnNumber: 1
+                readConcern: { $$exists: false }
+                writeConcern: { $$exists: false }
+              commandName: findAndModify
+              databaseName: *database0Name
+          - commandStartedEvent: *findAndModify_attempt
+          - commandStartedEvent: *find_with_implicit_session_event
+    outcome:
+      - collectionName: *collection0Name
+        databaseName: *database0Name
+        documents:
+          - { _id: 1, x: 1 }
+
+  - description: "Dirty implicit session is discarded (read returning cursor)"
+    operations:
+      - name: failPoint
+        object: testRunner
+        arguments:
+          client: *client0
+          failPoint:
+            configureFailPoint: failCommand
+            mode: { times: 1 }
+            data:
+              failCommands: [ aggregate ]
+              closeConnection: true
+      - name: aggregate
+        object: *collection0
+        arguments:
+          pipeline: [ { $project: { _id: 1 } } ]
+        expectResult: [ { _id: 1 } ]
+      - *find_with_implicit_session
+      - name: assertDifferentLsidOnLastTwoCommands
+        object: testRunner
+        arguments:
+          client: *client0
+    expectEvents:
+      - client: *client0
+        events:
+          - commandStartedEvent: &aggregate_attempt
+              command:
+                aggregate: *collection0Name
+                pipeline: [ { $project: { _id: 1 } } ]
+                lsid: { $$type: object }
+              commandName: aggregate
+              databaseName: *database0Name
+          - commandStartedEvent: *aggregate_attempt
+          - commandStartedEvent: *find_with_implicit_session_event
+    outcome:
+      - collectionName: *collection0Name
+        databaseName: *database0Name
+        documents:
+          - { _id: 1 }
+
+  - description: "Dirty implicit session is discarded (read not returning cursor)"
+    operations:
+      - name: failPoint
+        object: testRunner
+        arguments:
+          client: *client0
+          failPoint:
+            configureFailPoint: failCommand
+            mode: { times: 1 }
+            data:
+              failCommands: [ aggregate ]
+              closeConnection: true
+      - name: countDocuments
+        object: *collection0
+        arguments:
+          filter: {}
+        expectResult: 1
+      - *find_with_implicit_session
+      - name: assertDifferentLsidOnLastTwoCommands
+        object: testRunner
+        arguments:
+          client: *client0
+    expectEvents:
+      - client: *client0
+        events:
+          - commandStartedEvent: &countDocuments_attempt
+              command:
+                aggregate: *collection0Name
+                pipeline: [ { $match: {} }, { $group: { _id: 1, n: { $sum: 1 } } } ]
+                lsid: { $$type: object }
+              commandName: aggregate
+              databaseName: *database0Name
+          - commandStartedEvent: *countDocuments_attempt
+          - commandStartedEvent: *find_with_implicit_session_event
+    outcome:
+      - collectionName: *collection0Name
+        databaseName: *database0Name
+        documents:
+          - { _id: 1 }

data/spec/spec_tests/data/unified/valid-pass/poc-crud.yml

@@ -143,7 +143,7 @@ tests:
   - description: "readConcern majority with out stage"
     runOnRequirements:
       - minServerVersion: "4.1.0"
-        topologies: [ replicaset, sharded-replicaset ]
+        topologies: [ replicaset, sharded ]
         serverless: "forbid"
     operations:
       - name: aggregate