mongo 2.19.1 → 2.21.0

data/spec/spec_tests/data/client_side_operations_timeout/command-execution.yml

@@ -0,0 +1,250 @@
+description: "timeoutMS behaves correctly during command execution"
+
+schemaVersion: "1.9"
+
+runOnRequirements:
+  # The appName filter cannot be used to set a fail point on connection handshakes until server version 4.9 due to
+  # SERVER-49220/SERVER-49336.
+  - minServerVersion: "4.9"
+    # Skip load-balanced and serverless which do not support RTT measurements.
+    topologies: [ single, replicaset, sharded ]
+    serverless: forbid
+
+createEntities:
+  - client:
+      id: &failPointClient failPointClient
+      useMultipleMongoses: false
+
+initialData:
+  # The corresponding entities for the collections defined here are created in test-level createEntities operations.
+  # This is done so that tests can set fail points that will affect all of the handshakes and heartbeats done by a
+  # client. The collection and database names are listed here so that the collections will be dropped and re-created at
+  # the beginning of each test.
+  - collectionName: &regularCollectionName coll
+    databaseName: &databaseName test
+    documents: []
+  - collectionName: &timeoutCollectionName timeoutColl
+    databaseName: &databaseName test
+    documents: []
+
+tests:
+  - description: "maxTimeMS value in the command is less than timeoutMS"
+    operations:
+      # Artificially increase the server RTT to ~50ms.
+      - name: failPoint
+        object: testRunner
+        arguments:
+          client: *failPointClient
+          failPoint:
+            configureFailPoint: failCommand
+            mode: "alwaysOn"
+            data:
+              failCommands: ["hello", "isMaster"]
+              appName: &appName reduceMaxTimeMSTest
+              blockConnection: true
+              blockTimeMS: 50
+      # Create a client with the app name specified in the fail point and timeoutMS higher than blockTimeMS.
+      # Also create database and collection entities derived from the new client.
+      - name: createEntities
+        object: testRunner
+        arguments:
+          entities:
+            - client:
+                id: &client client
+                useMultipleMongoses: false
+                uriOptions:
+                  appName: *appName
+                  w: 1  # Override server's w:majority default to speed up the test.
+                  timeoutMS: 500
+                  heartbeatFrequencyMS: 500
+                observeEvents:
+                  - commandStartedEvent
+            - database:
+                id: &database database
+                client: *client
+                databaseName: *databaseName
+            - collection:
+                id: &timeoutCollection timeoutCollection
+                database: *database
+                collectionName: *timeoutCollectionName
+      # Do an operation with a large timeout to ensure the servers are discovered.
+      - name: insertOne
+        object: *timeoutCollection
+        arguments:
+          document: { _id: 1 }
+          timeoutMS: 100000
+      # Wait until short-circuiting has been enabled (at least 2 RTT measurements).
+      - name: wait
+        object: testRunner
+        arguments:
+          ms: 1000
+      # Do an operation with timeoutCollection so the event will include a maxTimeMS field.
+      - name: insertOne
+        object: *timeoutCollection
+        arguments:
+          document: { _id: 2 }
+    expectEvents:
+      - client: *client
+        events:
+          - commandStartedEvent:
+              commandName: insert
+              databaseName: *databaseName
+              command:
+                insert: *timeoutCollectionName
+          - commandStartedEvent:
+              commandName: insert
+              databaseName: *databaseName
+              command:
+                insert: *timeoutCollectionName
+                maxTimeMS: { $$lte: 450 }
+
+  - description: "command is not sent if RTT is greater than timeoutMS"
+    operations:
+      # Artificially increase the server RTT to ~50ms.
+      - name: failPoint
+        object: testRunner
+        arguments:
+          client: *failPointClient
+          failPoint:
+            configureFailPoint: failCommand
+            mode: "alwaysOn"
+            data:
+              failCommands: ["hello", "isMaster"]
+              appName: &appName rttTooHighTest
+              blockConnection: true
+              blockTimeMS: 50
+      # Create a client with the app name specified in the fail point. Also create database and collection entities
+      # derived from the new client. There is one collection entity with no timeoutMS and another with a timeoutMS
+      # that's lower than the fail point's blockTimeMS value.
+      - name: createEntities
+        object: testRunner
+        arguments:
+          entities:
+            - client:
+                id: &client client
+                useMultipleMongoses: false
+                uriOptions:
+                  appName: *appName
+                  w: 1  # Override server's w:majority default to speed up the test.
+                  timeoutMS: 10
+                  heartbeatFrequencyMS: 500
+                observeEvents:
+                  - commandStartedEvent
+            - database:
+                id: &database database
+                client: *client
+                databaseName: *databaseName
+            - collection:
+                id: &timeoutCollection timeoutCollection
+                database: *database
+                collectionName: *timeoutCollectionName
+      # Do an operation with a large timeout to ensure the servers are discovered.
+      - name: insertOne
+        object: *timeoutCollection
+        arguments:
+          document: { _id: 1 }
+          timeoutMS: 100000
+      # Wait until short-circuiting has been enabled (at least 2 RTT measurements).
+      - name: wait
+        object: testRunner
+        arguments:
+          ms: 1000
+      # Do an operation with timeoutCollection which will error.
+      - name: insertOne
+        object: *timeoutCollection
+        arguments:
+          document: { _id: 2 }
+        expectError:
+          isTimeoutError: true
+      # Do an operation with timeoutCollection which will error.
+      - name: insertOne
+        object: *timeoutCollection
+        arguments:
+          document: { _id: 3 }
+        expectError:
+          isTimeoutError: true
+      # Do an operation with timeoutCollection which will error.
+      - name: insertOne
+        object: *timeoutCollection
+        arguments:
+          document: { _id: 4 }
+        expectError:
+          isTimeoutError: true
+    expectEvents:
+      # There should only be one event, which corresponds to the first
+      # insertOne call. For the subsequent insertOne calls, drivers should
+      # fail client-side.
+      - client: *client
+        events:
+          - commandStartedEvent:
+              commandName: insert
+              databaseName: *databaseName
+              command:
+                insert: *timeoutCollectionName
+
+  - description: "short-circuit is not enabled with only 1 RTT measurement"
+    operations:
+      # Artificially increase the server RTT to ~300ms.
+      - name: failPoint
+        object: testRunner
+        arguments:
+          client: *failPointClient
+          failPoint:
+            configureFailPoint: failCommand
+            mode: "alwaysOn"
+            data:
+              failCommands: ["hello", "isMaster"]
+              appName: &appName reduceMaxTimeMSTest
+              blockConnection: true
+              blockTimeMS: 100
+      # Create a client with the app name specified in the fail point and timeoutMS lower than blockTimeMS.
+      # Also create database and collection entities derived from the new client.
+      - name: createEntities
+        object: testRunner
+        arguments:
+          entities:
+            - client:
+                id: &client client
+                useMultipleMongoses: false
+                uriOptions:
+                  appName: *appName
+                  w: 1  # Override server's w:majority default to speed up the test.
+                  timeoutMS: 90
+                  heartbeatFrequencyMS: 100000  # Override heartbeatFrequencyMS to ensure only 1 RTT is recorded.
+                observeEvents:
+                  - commandStartedEvent
+            - database:
+                id: &database database
+                client: *client
+                databaseName: *databaseName
+            - collection:
+                id: &timeoutCollection timeoutCollection
+                database: *database
+                collectionName: *timeoutCollectionName
+      # Do an operation with a large timeout to ensure the servers are discovered.
+      - name: insertOne
+        object: *timeoutCollection
+        arguments:
+          document: { _id: 1 }
+          timeoutMS: 100000
+      # Do an operation with timeoutCollection which will succeed. If this
+      # fails it indicates the driver mistakenly used the min RTT even though
+      # there has only been one sample.
+      - name: insertOne
+        object: *timeoutCollection
+        arguments:
+          document: { _id: 2 }
+    expectEvents:
+      - client: *client
+        events:
+          - commandStartedEvent:
+              commandName: insert
+              databaseName: *databaseName
+              command:
+                insert: *timeoutCollectionName
+          - commandStartedEvent:
+              commandName: insert
+              databaseName: *databaseName
+              command:
+                insert: *timeoutCollectionName
+                maxTimeMS: { $$lte: 450 }

data/spec/spec_tests/data/client_side_operations_timeout/convenient-transactions.yml

@@ -0,0 +1,113 @@
+description: "timeoutMS behaves correctly for the withTransaction API"
+
+schemaVersion: "1.9"
+
+runOnRequirements:
+  - minServerVersion: "4.4"
+    topologies: ["replicaset", "sharded"]
+
+createEntities:
+  - client:
+      id: &failPointClient failPointClient
+      useMultipleMongoses: false
+  - client:
+      id: &client client
+      uriOptions:
+        timeoutMS: 50
+      useMultipleMongoses: false
+      observeEvents:
+        - commandStartedEvent
+  - database:
+      id: &database database
+      client: *client
+      databaseName: &databaseName test
+  - collection:
+      id: &collection collection
+      database: *database
+      collectionName: &collectionName coll
+  - session:
+      id: &session session
+      client: *client
+
+initialData:
+  - collectionName: *collectionName
+    databaseName: *databaseName
+    documents: []
+
+tests:
+  - description: "withTransaction raises a client-side error if timeoutMS is overridden inside the callback"
+    operations:
+      - name: withTransaction
+        object: *session
+        arguments:
+          callback:
+            - name: insertOne
+              object: *collection
+              arguments:
+                document: { _id: 1 }
+                session: *session
+                timeoutMS: 100
+              expectError:
+                isClientError: true
+    expectEvents:
+      # The only operation run fails with a client-side error, so there should be no events for the client.
+      - client: *client
+        events: []
+
+  - description: "timeoutMS is not refreshed for each operation in the callback"
+    operations:
+      - name: failPoint
+        object: testRunner
+        arguments:
+          client: *failPointClient
+          failPoint:
+            configureFailPoint: failCommand
+            mode: { times: 2 }
+            data:
+              failCommands: ["insert"]
+              blockConnection: true
+              # Was 30, but JRuby was taking too long in preparing and issuing
+              # the operation. We now specify the timeoutMS below, and set this
+              # value to just more than half of it (so that two inserts will
+              # exceed the timeout, but one won't--or shouldn't).
+              blockTimeMS: 51
+      - name: withTransaction
+        object: *session
+        arguments:
+          # Was originally not specified here, inheriting the client value of 50ms.
+          # That wasn't giving JRuby enough time, so we specify a larger value
+          # here.
+          timeoutMS: 100
+          callback:
+            - name: insertOne
+              object: *collection
+              arguments:
+                document: { _id: 1 }
+                session: *session
+            - name: insertOne
+              object: *collection
+              arguments:
+                document: { _id: 2 }
+                session: *session
+              expectError:
+                isTimeoutError: true
+        expectError:
+          isTimeoutError: true
+    expectEvents:
+      - client: *client
+        events:
+          # Because the second insert expects an error and gets an error, it technically succeeds, so withTransaction
+          # will try to run commitTransaction. This will fail client-side, though, because the timeout has already
+          # expired, so no command is sent.
+          - commandStartedEvent:
+              commandName: insert
+              databaseName: *databaseName
+              command:
+                insert: *collectionName
+                maxTimeMS: { $$type: ["int", "long"] }
+          - commandStartedEvent:
+              commandName: insert
+              databaseName: *databaseName
+              command:
+                insert: *collectionName
+                maxTimeMS: { $$type: ["int", "long"] }

data/spec/spec_tests/data/client_side_operations_timeout/cursors.yml

@@ -0,0 +1,70 @@
+description: "tests for timeoutMS behavior that applies to all cursor types"
+
+schemaVersion: "1.0"
+
+createEntities:
+  - client:
+      id: &client client
+  - database:
+      id: &database database
+      client: *client
+      databaseName: &databaseName test
+  - collection:
+      id: &collection collection
+      database: *database
+      collectionName: &collectionName coll
+
+initialData:
+  - collectionName: *collectionName
+    databaseName: *databaseName
+    documents: []
+
+tests:
+  - description: "find errors if timeoutMode is set and timeoutMS is not"
+    operations:
+      - name: find
+        object: *collection
+        arguments:
+          filter: {}
+          timeoutMode: cursorLifetime
+        expectError:
+          isClientError: true
+
+  - description: "collection aggregate errors if timeoutMode is set and timeoutMS is not"
+    operations:
+      - name: aggregate
+        object: *collection
+        arguments:
+          pipeline: []
+          timeoutMode: cursorLifetime
+        expectError:
+          isClientError: true
+
+  - description: "database aggregate errors if timeoutMode is set and timeoutMS is not"
+    operations:
+      - name: aggregate
+        object: *database
+        arguments:
+          pipeline: []
+          timeoutMode: cursorLifetime
+        expectError:
+          isClientError: true
+
+  - description: "listCollections errors if timeoutMode is set and timeoutMS is not"
+    operations:
+      - name: listCollections
+        object: *database
+        arguments:
+          filter: {}
+          timeoutMode: cursorLifetime
+        expectError:
+          isClientError: true
+
+  - description: "listIndexes errors if timeoutMode is set and timeoutMS is not"
+    operations:
+      - name: listIndexes
+        object: *collection
+        arguments:
+          timeoutMode: cursorLifetime
+        expectError:
+          isClientError: true