mongo 2.14.1 → 2.15.0.alpha

data/spec/spec_tests/data/unified/valid-pass/poc-retryable-reads.yml

@@ -0,0 +1,193 @@
+description: "poc-retryable-reads"
+
+schemaVersion: "1.0"
+
+runOnRequirements:
+  - minServerVersion: "4.0"
+    topologies: [ single, replicaset ]
+  - minServerVersion: "4.1.7"
+    topologies: [ sharded ]
+
+createEntities:
+  - client:
+      id: &client0 client0
+      useMultipleMongoses: false
+      observeEvents: [ commandStartedEvent ]
+  - client:
+      id: &client1 client1
+      uriOptions: { retryReads: false }
+      useMultipleMongoses: false
+      observeEvents: [ commandStartedEvent ]
+  - database:
+      id: &database0 database0
+      client: *client0
+      databaseName: &databaseName retryable-reads-tests
+  - database:
+      id: &database1 database1
+      client: *client1
+      databaseName: *databaseName
+  - collection:
+      id: &collection0 collection0
+      database: *database0
+      collectionName: &collectionName coll
+  - collection:
+      id: &collection1 collection1
+      database: *database1
+      collectionName: *collectionName
+
+initialData:
+  - collectionName: *collectionName
+    databaseName: *databaseName
+    documents:
+      - {_id: 1, x: 11}
+      - {_id: 2, x: 22}
+      - {_id: 3, x: 33}
+
+tests:
+  - description: "Aggregate succeeds after InterruptedAtShutdown"
+    operations:
+      - name: failPoint
+        object: testRunner
+        arguments:
+          client: *client0
+          failPoint:
+            configureFailPoint: failCommand
+            mode: { times: 1 }
+            data:
+              failCommands: [ aggregate ]
+              errorCode: 11600 # InterruptedAtShutdown
+      - name: aggregate
+        object: *collection0
+        arguments:
+          pipeline: &pipeline
+            - $match: { _id: { $gt: 1 } }
+            - $sort: { x: 1 }
+        expectResult:
+          - { _id: 2, x: 22 }
+          - { _id: 3, x: 33 }
+    expectEvents:
+      - client: *client0
+        events:
+          - commandStartedEvent:
+              command:
+                aggregate: *collectionName
+                pipeline: *pipeline
+              databaseName: *databaseName
+          - commandStartedEvent:
+              command:
+                aggregate: *collectionName
+                pipeline: *pipeline
+              databaseName: *databaseName
+
+  - description: "Find succeeds on second attempt"
+    operations:
+      - name: failPoint
+        object: testRunner
+        arguments:
+          client: *client0
+          failPoint:
+            configureFailPoint: failCommand
+            mode: { times: 1 }
+            data:
+              failCommands: [ find ]
+              closeConnection: true
+      # Find options and expected result changed to use common initialData
+      - name: find
+        object: collection0
+        arguments:
+          filter: {}
+          sort: { _id: 1 }
+          limit: 2
+        expectResult:
+          - { _id: 1, x: 11 }
+          - { _id: 2, x: 22 }
+    expectEvents:
+      - client: *client0
+        events:
+          - &findAttempt
+            commandStartedEvent:
+              command:
+                find: *collectionName
+                filter: {}
+                sort: { _id: 1 }
+                limit: 2
+              databaseName: *databaseName
+          - *findAttempt
+
+  - description: "Find fails on first attempt"
+    operations:
+      - name: failPoint
+        object: testRunner
+        arguments:
+          client: *client0
+          failPoint:
+            configureFailPoint: failCommand
+            mode: { times: 1 }
+            data:
+              failCommands: [ find ]
+              closeConnection: true
+      - name: find
+        object: collection1 # client uses retryReads=false
+        arguments:
+          filter: {}
+          # Other arguments in the original test are not relevant
+        expectError: { isError: true }
+    expectEvents:
+      - client: *client1
+        events:
+          - commandStartedEvent:
+              command:
+                find: *collectionName
+                filter: {}
+              databaseName: *databaseName
+
+  - description: "Find fails on second attempt"
+    operations:
+      - name: failPoint
+        object: testRunner
+        arguments:
+          client: *client0
+          failPoint:
+            configureFailPoint: failCommand
+            mode: { times: 2 }
+            data:
+              failCommands: [ find ]
+              closeConnection: true
+      - name: find
+        object: collection0
+        arguments:
+          filter: {}
+          # Other arguments in the original test are not relevant
+        expectError: { isError: true }
+    expectEvents:
+      - client: *client0
+        events:
+          - &findAttempt
+            commandStartedEvent:
+              command:
+                find: *collectionName
+                filter: {}
+              databaseName: *databaseName
+          - *findAttempt
+
+  - description: "ListDatabases succeeds on second attempt"
+    operations:
+      - name: failPoint
+        object: testRunner
+        arguments:
+          client: *client0
+          failPoint:
+            configureFailPoint: failCommand
+            mode: { times: 1 }
+            data:
+              failCommands: [ listDatabases ]
+              closeConnection: true
+      - name: listDatabases
+        object: *client0
+    expectEvents:
+      - client: *client0
+        events:
+          - commandStartedEvent:
+              command: { listDatabases: 1 }
+          - commandStartedEvent:
+              command: { listDatabases: 1 }

data/spec/spec_tests/data/unified/valid-pass/poc-retryable-writes.yml

@@ -0,0 +1,210 @@
+description: "poc-retryable-writes"
+
+schemaVersion: "1.0"
+
+runOnRequirements:
+  - minServerVersion: "3.6"
+    topologies: [ replicaset ]
+
+createEntities:
+  - client:
+      id: &client0 client0
+      useMultipleMongoses: false
+      observeEvents: [ commandStartedEvent ]
+  - client:
+      id: &client1 client1
+      uriOptions: { retryWrites: false }
+      useMultipleMongoses: false
+      observeEvents: [ commandStartedEvent ]
+  - database:
+      id: &database0 database0
+      client: *client0
+      databaseName: &databaseName retryable-writes-tests
+  - database:
+      id: &database1 database1
+      client: *client1
+      databaseName: *databaseName
+  - collection:
+      id: &collection0 collection0
+      database: *database0
+      collectionName: &collectionName coll
+  - collection:
+      id: &collection1 collection1
+      database: *database1
+      collectionName: *collectionName
+
+initialData:
+  - collectionName: *collectionName
+    databaseName: *databaseName
+    documents:
+      - { _id: 1, x: 11 }
+      - { _id: 2, x: 22 }
+
+tests:
+  - description: "FindOneAndUpdate is committed on first attempt"
+    operations:
+      - name: failPoint
+        object: testRunner
+        arguments:
+          client: *client0
+          failPoint:
+            configureFailPoint: onPrimaryTransactionalWrite
+            mode: { times: 1 }
+      - name: findOneAndUpdate
+        object: *collection0
+        arguments:
+          filter: { _id: 1 }
+          update: { $inc: { x : 1 } }
+          returnDocument: Before
+        expectResult: { _id: 1, x: 11 }
+    outcome:
+      - collectionName: *collectionName
+        databaseName: *databaseName
+        documents:
+          - { _id: 1, x: 12 }
+          - { _id: 2, x: 22 }
+
+  - description: "FindOneAndUpdate is not committed on first attempt"
+    operations:
+      - name: failPoint
+        object: testRunner
+        arguments:
+          client: *client0
+          failPoint:
+            configureFailPoint: onPrimaryTransactionalWrite
+            mode: { times: 1 }
+            data: { failBeforeCommitExceptionCode: 1 }
+      - name: findOneAndUpdate
+        object: *collection0
+        arguments:
+          filter: { _id: 1 }
+          update: { $inc: { x : 1 } }
+          returnDocument: Before
+        expectResult: { _id: 1, x: 11 }
+    outcome:
+      - collectionName: *collectionName
+        databaseName: *databaseName
+        documents:
+          - { _id: 1, x: 12 }
+          - { _id: 2, x: 22 }
+
+  - description: "FindOneAndUpdate is never committed"
+    operations:
+      - name: failPoint
+        object: testRunner
+        arguments:
+          client: *client0
+          failPoint:
+            configureFailPoint: onPrimaryTransactionalWrite
+            mode: { times: 2 }
+            data: { failBeforeCommitExceptionCode: 1 }
+      - name: findOneAndUpdate
+        object: *collection0
+        arguments:
+          filter: { _id: 1 }
+          update: { $inc: { x : 1 } }
+          returnDocument: Before
+        expectError: { isError: true }
+    outcome:
+      - collectionName: *collectionName
+        databaseName: *databaseName
+        documents:
+          - { _id: 1, x: 11 }
+          - { _id: 2, x: 22 }
+
+  - description: "InsertMany succeeds after PrimarySteppedDown"
+    runOnRequirements: &failCommand_requirements
+      - minServerVersion: "4.0"
+        topologies: [ replicaset ]
+      - minServerVersion: "4.1.7"
+        # Original test uses "sharded", but retryable writes requires a sharded
+        # cluster backed by replica sets
+        topologies: [ sharded-replicaset ]
+    operations:
+      - name: failPoint
+        object: testRunner
+        arguments:
+          client: *client0
+          failPoint:
+            configureFailPoint: failCommand
+            mode: { times: 1 }
+            data:
+              failCommands: [ insert ]
+              errorCode: 189 # PrimarySteppedDown
+              errorLabels: [  RetryableWriteError ]
+      - name: insertMany
+        object: *collection0
+        arguments:
+          documents:
+            # Documents are modified from original test for "initialData"
+            - { _id: 3, x: 33 }
+            - { _id: 4, x: 44 }
+          ordered: true
+        expectResult:
+          insertedCount: { $$unsetOrMatches: 2 }
+          insertedIds: { $$unsetOrMatches: { 0: 3, 1: 4 } }
+    outcome:
+      - collectionName: *collectionName
+        databaseName: *databaseName
+        documents:
+          - { _id: 1, x: 11 }
+          - { _id: 2, x: 22 }
+          - { _id: 3, x: 33 }
+          - { _id: 4, x: 44 }
+
+  - description: "InsertOne fails after connection failure when retryWrites option is false"
+    runOnRequirements: *failCommand_requirements
+    operations:
+      - name: failPoint
+        object: testRunner
+        arguments:
+          client: *client1
+          failPoint:
+            configureFailPoint: failCommand
+            mode: { times: 1 }
+            data:
+                failCommands: [ insert ]
+                closeConnection: true
+      - name: insertOne
+        object: *collection1
+        arguments:
+          document: { _id: 3, x: 33 }
+        expectError:
+          # If retryWrites is false, the driver should not add the
+          # RetryableWriteError label to the error.
+          errorLabelsOmit: [ RetryableWriteError ]
+    outcome:
+      - collectionName: *collectionName
+        databaseName: *databaseName
+        documents:
+          - { _id: 1, x: 11 }
+          - { _id: 2, x: 22 }
+
+  - description: "InsertOne fails after multiple retryable writeConcernErrors"
+    runOnRequirements: *failCommand_requirements
+    operations:
+      - name: failPoint
+        object: testRunner
+        arguments:
+          client: *client0
+          failPoint:
+            configureFailPoint: failCommand
+            mode: { times: 2 }
+            data:
+              failCommands: [ insert ]
+              writeConcernError:
+                code: 91 # ShutdownInProgress
+                errmsg: "Replication is being shut down"
+      - name: insertOne
+        object: *collection0
+        arguments:
+          document: { _id: 3, x: 33 }
+        expectError:
+          errorLabelsContain: [ RetryableWriteError ]
+    outcome:
+      - collectionName: *collectionName
+        databaseName: *databaseName
+        documents:
+          - { _id: 1, x: 11 }
+          - { _id: 2, x: 22 }
+          - { _id: 3, x: 33 }  # The write was still applied

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

@@ -0,0 +1,215 @@
+description: "poc-sessions"
+
+schemaVersion: "1.0"
+
+runOnRequirements:
+  - minServerVersion: "3.6.0"
+
+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: "Server supports explicit sessions"
+    operations:
+      - name: assertSessionNotDirty
+        object: testRunner
+        arguments:
+          session: *session0
+      - name: insertOne
+        object: *collection0
+        arguments:
+          session: *session0
+          document: { _id: 2 }
+        expectResult: { $$unsetOrMatches: { insertedId: { $$unsetOrMatches: 2 } } }
+      - name: assertSessionNotDirty
+        object: testRunner
+        arguments:
+          session: *session0
+      - name: endSession
+        object: *session0
+      - &find_with_implicit_session
+        name: find
+        object: *collection0
+        arguments:
+          filter: { _id: -1 }
+        expectResult: []
+      - name: assertSameLsidOnLastTwoCommands
+        object: testRunner
+        arguments:
+          client: *client0
+    expectEvents:
+      - client: *client0
+        events:
+          - commandStartedEvent:
+              command:
+                insert: *collection0Name
+                documents: [ { _id: 2 } ]
+                ordered: true
+                lsid: { $$sessionLsid: *session0 }
+              commandName: insert
+              databaseName: *database0Name
+          - commandStartedEvent:
+              command:
+                find: *collection0Name
+                filter: { _id: -1 }
+                lsid: { $$sessionLsid: *session0 }
+              commandName: find
+              databaseName: *database0Name
+    outcome:
+      - collectionName: *collection0Name
+        databaseName: *database0Name
+        documents:
+          - { _id: 1 }
+          - { _id: 2 }
+
+  - description: "Server supports implicit sessions"
+    operations:
+      - name: insertOne
+        object: *collection0
+        arguments:
+          document: { _id: 2 }
+        expectResult: { $$unsetOrMatches: { insertedId: { $$unsetOrMatches: 2 } } }
+      - *find_with_implicit_session
+      - name: assertSameLsidOnLastTwoCommands
+        object: testRunner
+        arguments:
+          client: *client0
+    expectEvents:
+      - client: *client0
+        events:
+          - commandStartedEvent:
+              command:
+                insert: *collection0Name
+                documents:
+                  - { _id: 2 }
+                ordered: true
+                # Original test did not include any assertion, but we can use
+                # $$type to expect an arbitrary lsid document
+                lsid: { $$type: object }
+              commandName: insert
+              databaseName: *database0Name
+          - commandStartedEvent:
+              command:
+                find: *collection0Name
+                filter: { _id: -1 }
+                lsid: { $$type: object }
+              commandName: find
+              databaseName: *database0Name
+    outcome:
+      - collectionName: *collection0Name
+        databaseName: *database0Name
+        documents:
+          - { _id: 1 }
+          - { _id: 2 }
+
+  - description: "Dirty explicit session is discarded"
+    skipReason: RUBY-1813
+    # Original test specified retryWrites=true, but that is now the default.
+    # Retryable writes will require a sharded-replicaset, though.
+    runOnRequirements:
+      - minServerVersion: "4.0"
+        topologies: [ replicaset ]
+      - minServerVersion: "4.1.8"
+        topologies: [ sharded-replicaset ]
+    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: assertDifferentLsidOnLastTwoCommands
+        object: testRunner
+        arguments:
+          client: *client0
+    expectEvents:
+      - client: *client0
+        events:
+          # ajv's YAML parser is unable to handle anchors on array elements, so
+          # we define an anchor on the commandStartedEvent object instead
+          - 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:
+              command:
+                find: *collection0Name
+                filter: { _id: -1 }
+                lsid: { $$type: object }
+              commandName: find
+              databaseName: *database0Name
+    outcome:
+      - collectionName: *collection0Name
+        databaseName: *database0Name
+        documents:
+          - { _id: 1 }
+          - { _id: 2 }
+          - { _id: 3 }