mongo 2.14.1 → 2.15.0.alpha

data/spec/spec_tests/data/unified/valid-pass/poc-change-streams.yml

@@ -0,0 +1,220 @@
+description: "poc-change-streams"
+
+schemaVersion: "1.0"
+
+createEntities:
+  # Entities for creating changeStreams
+  - client:
+      id: &client0 client0
+      useMultipleMongoses: false
+      observeEvents: [ commandStartedEvent ]
+      # Original tests do not observe getMore commands but only because event
+      # assertions ignore extra events. killCursors is explicitly ignored.
+      ignoreCommandMonitoringEvents: [ getMore, killCursors ]
+  - database:
+      id: &database0 database0
+      client: *client0
+      databaseName: &database0Name change-stream-tests
+  - collection:
+      id: &collection0 collection0
+      database: *database0
+      collectionName: &collection0Name test
+  # Entities for executing insert operations
+  - client:
+      id: &client1 client1
+      useMultipleMongoses: false
+  - database:
+      id: &database1 database1
+      client: *client1
+      databaseName: &database1Name change-stream-tests
+  - database:
+      id: &database2 database2
+      client: *client1
+      databaseName: &database2Name change-stream-tests-2
+  - collection:
+      id: &collection1 collection1
+      database: *database1
+      collectionName: &collection1Name test
+  - collection:
+      id: &collection2 collection2
+      database: *database1
+      collectionName: &collection2Name test2
+  - collection:
+      id: &collection3 collection3
+      database: *database2
+      collectionName: &collection3Name test
+
+initialData:
+  - collectionName: *collection1Name
+    databaseName: *database1Name
+    documents: []
+  - collectionName: *collection2Name
+    databaseName: *database1Name
+    documents: []
+  - collectionName: *collection3Name
+    databaseName: *database2Name
+    documents: []
+
+tests:
+  - description: "Executing a watch helper on a MongoClient results in notifications for changes to all collections in all databases in the cluster."
+    runOnRequirements:
+      - minServerVersion: "3.8.0"
+        topologies: [ replicaset ]
+    operations:
+      - name: createChangeStream
+        object: *client0
+        arguments:
+          pipeline: []
+        saveResultAsEntity: &changeStream0 changeStream0
+      - name: insertOne
+        object: *collection2
+        arguments:
+          document: { x: 1 }
+      - name: insertOne
+        object: *collection3
+        arguments:
+          document: { y: 1 }
+      - name: insertOne
+        object: *collection1
+        arguments:
+          document: { z: 1 }
+      - name: iterateUntilDocumentOrError
+        object: *changeStream0
+        expectResult:
+          operationType: insert
+          ns:
+            db: *database1Name
+            coll: *collection2Name
+          fullDocument:
+            _id: { $$type: objectId }
+            x: 1
+      - name: iterateUntilDocumentOrError
+        object: *changeStream0
+        expectResult:
+          operationType: insert
+          ns:
+            db: *database2Name
+            coll: *collection3Name
+          fullDocument:
+            # Original tests did not include _id, but matching now only permits
+            # extra keys for root-level documents.
+            _id: { $$type: objectId }
+            y: 1
+      - name: iterateUntilDocumentOrError
+        object: *changeStream0
+        expectResult:
+          operationType: insert
+          ns:
+            db: *database1Name
+            coll: *collection1Name
+          fullDocument:
+            _id: { $$type: objectId }
+            z: 1
+    expectEvents:
+      - client: *client0
+        events:
+          - commandStartedEvent:
+              command:
+                aggregate: 1
+                cursor: {}
+                pipeline:
+                  - $changeStream:
+                      allChangesForCluster: true
+                      # Some drivers may send a default value for fullDocument
+                      # or omit it entirely (see: SPEC-1350).
+                      fullDocument: { $$unsetOrMatches: default }
+              commandName: aggregate
+              databaseName: admin
+
+  - description: "Test consecutive resume"
+    runOnRequirements:
+      - minServerVersion: "4.1.7"
+        topologies: [ replicaset ]
+    operations:
+      - name: failPoint
+        object: testRunner
+        arguments:
+          client: *client0
+          failPoint:
+            configureFailPoint: failCommand
+            mode: { times: 2 }
+            data:
+              failCommands: [ getMore ]
+              closeConnection: true
+      - name: createChangeStream
+        object: *collection0
+        arguments:
+          batchSize: 1
+          pipeline: []
+        saveResultAsEntity: *changeStream0
+      - name: insertOne
+        object: *collection1
+        arguments:
+          document: { x: 1 }
+      - name: insertOne
+        object: *collection1
+        arguments:
+          document: { x: 2 }
+      - name: insertOne
+        object: *collection1
+        arguments:
+          document: { x: 3 }
+      - name: iterateUntilDocumentOrError
+        object: *changeStream0
+        expectResult:
+          operationType: insert
+          ns:
+            db: *database1Name
+            coll: *collection1Name
+          fullDocument:
+            _id: { $$type: objectId }
+            x: 1
+      - name: iterateUntilDocumentOrError
+        object: *changeStream0
+        expectResult:
+          operationType: insert
+          ns:
+            db: *database1Name
+            coll: *collection1Name
+          fullDocument:
+            _id: { $$type: objectId }
+            x: 2
+      - name: iterateUntilDocumentOrError
+        object: *changeStream0
+        expectResult:
+          operationType: insert
+          ns:
+            db: *database1Name
+            coll: *collection1Name
+          fullDocument:
+            _id: { $$type: objectId }
+            x: 3
+    expectEvents:
+      - client: *client0
+        events:
+          - commandStartedEvent:
+              command:
+                aggregate: *collection1Name
+                cursor: { batchSize: 1 }
+                pipeline:
+                  - $changeStream:
+                      fullDocument: { $$unsetOrMatches: default }
+              commandName: aggregate
+              databaseName: *database1Name
+          # The original test only asserted the first command, since expected
+          # events were only an ordered subset. This file does ignore getMore
+          # commands but we must expect the subsequent aggregate commands, since
+          # each failed getMore will resume. While doing so we can also assert
+          # that those commands include a resume token.
+          - &resumingAggregate
+            commandStartedEvent:
+              command:
+                aggregate: *collection1Name
+                cursor: { batchSize: 1 }
+                pipeline:
+                  - $changeStream:
+                      fullDocument: { $$unsetOrMatches: default }
+                      resumeAfter: { $$exists: true }
+              commandName: aggregate
+              databaseName: *database0Name
+          - *resumingAggregate

data/spec/spec_tests/data/unified/valid-pass/poc-command-monitoring.yml

@@ -0,0 +1,102 @@
+description: "poc-command-monitoring"
+
+schemaVersion: "1.0"
+
+createEntities:
+  - client:
+      id: &client0 client0
+      observeEvents:
+        - commandStartedEvent
+        - commandSucceededEvent
+        - commandFailedEvent
+  - database:
+      id: &database0 database0
+      client: *client0
+      databaseName: &database0Name command-monitoring-tests
+  - collection:
+      id: &collection0 collection0
+      database: *database0
+      collectionName: &collection0Name test
+
+initialData:
+  - collectionName: *collection0Name
+    databaseName: *database0Name
+    documents:
+      - { _id: 1, x: 11 }
+      - { _id: 2, x: 22 }
+      - { _id: 3, x: 33 }
+      - { _id: 4, x: 44 }
+      - { _id: 5, x: 55 }
+
+tests:
+  - description: "A successful find event with a getmore and the server kills the cursor"
+    runOnRequirements:
+      - minServerVersion: "3.1"
+        topologies: [ single, replicaset ]
+    operations:
+      - name: find
+        object: *collection0
+        arguments:
+          filter: { _id: { $gte: 1 }}
+          sort: { _id: 1 }
+          batchSize: 3
+          limit: 4
+    expectEvents:
+      - client: *client0
+        events:
+          - commandStartedEvent:
+              command:
+                find: *collection0Name
+                filter: { _id: { $gte : 1 } }
+                sort: { _id: 1 }
+                batchSize: 3
+                limit: 4
+              commandName: find
+              databaseName: *database0Name
+          - commandSucceededEvent:
+              reply:
+                ok: 1
+                cursor:
+                  id: { $$type: [ int, long ] }
+                  ns: &namespace command-monitoring-tests.test
+                  firstBatch:
+                    - { _id: 1, x: 11 }
+                    - { _id: 2, x: 22 }
+                    - { _id: 3, x: 33 }
+              commandName: find
+          - commandStartedEvent:
+              command:
+                getMore: { $$type: [ int, long ] }
+                collection: *collection0Name
+                # https://jira.mongodb.org/browse/RUBY-2443
+                batchSize: 3
+              commandName: getMore
+              databaseName: *database0Name
+          - commandSucceededEvent:
+              reply:
+                ok: 1
+                cursor:
+                  id: 0
+                  ns: *namespace
+                  nextBatch:
+                    - { _id: 4, x: 44 }
+              commandName: getMore
+
+  - description: "A failed find event"
+    operations:
+      - name: find
+        object: *collection0
+        arguments:
+          filter: { $or: true }
+        expectError: { isError: true }
+    expectEvents:
+      - client: *client0
+        events:
+          - commandStartedEvent:
+              command:
+                find: *collection0Name
+                filter: { $or: true }
+              commandName: find
+              databaseName: *database0Name
+          - commandFailedEvent:
+              commandName: find

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

@@ -0,0 +1,184 @@
+description: "poc-crud"
+
+schemaVersion: "1.0"
+
+createEntities:
+  - client:
+      id: &client0 client0
+      observeEvents: [ commandStartedEvent ]
+  - database:
+      id: &database0 database0
+      client: *client0
+      databaseName: &database0Name crud-tests
+  - database:
+      id: &database1 database1
+      client: *client0
+      databaseName: &database1Name admin
+  - collection:
+      id: &collection0 collection0
+      database: *database0
+      collectionName: &collection0Name coll0
+  - collection:
+      id: &collection1 collection1
+      database: *database0
+      collectionName: &collection1Name coll1
+  - collection:
+      id: &collection2 collection2
+      database: *database0
+      collectionName: &collection2Name coll2
+      collectionOptions:
+        readConcern: { level: majority }
+
+initialData:
+  - collectionName: *collection0Name
+    databaseName: *database0Name
+    documents:
+      - { _id: 1, x: 11 }
+      - { _id: 2, x: 22 }
+  - collectionName: *collection1Name
+    databaseName: *database0Name
+    documents:
+      - { _id: 1, x: 11 }
+  - collectionName: *collection2Name
+    databaseName: *database0Name
+    documents:
+      - { _id: 1, x: 11 }
+      - { _id: 2, x: 22 }
+      - { _id: 3, x: 33 }
+  - collectionName: &out aggregate_out
+    databaseName: *database0Name
+    documents: []
+
+tests:
+  - description: "BulkWrite with mixed ordered operations"
+    operations:
+      - name: bulkWrite
+        object: *collection0
+        arguments:
+          requests:
+            - insertOne:
+                document: { _id: 3, x: 33 }
+            - updateOne:
+                filter: { _id: 2 }
+                update: { $inc: { x: 1 } }
+            - updateMany:
+                filter: { _id: { $gt: 1 } }
+                update: { $inc: { x: 1 } }
+            - insertOne:
+                document: { _id: 4, x: 44 }
+            - deleteMany:
+                filter: { x: { $nin: [ 24, 34 ] } }
+            - replaceOne:
+                filter: { _id: 4 }
+                replacement: { _id: 4, x: 44 }
+                upsert: true
+          ordered: true
+        expectResult:
+          deletedCount: 2
+          insertedCount: 2
+          insertedIds: { $$unsetOrMatches: { 0: 3, 3: 4 } }
+          matchedCount: 3
+          modifiedCount: 3
+          upsertedCount: 1
+          upsertedIds: { 5: 4 }
+    outcome:
+      - collectionName: *collection0Name
+        databaseName: *database0Name
+        documents:
+          - {_id: 2, x: 24 }
+          - {_id: 3, x: 34 }
+          - {_id: 4, x: 44 }
+
+  - description: "InsertMany continue-on-error behavior with unordered (duplicate key in requests)"
+    operations:
+      - name: insertMany
+        object: *collection1
+        arguments:
+          documents:
+            - { _id: 2, x: 22 }
+            - { _id: 2, x: 22 }
+            - { _id: 3, x: 33 }
+          ordered: false
+        expectError:
+          expectResult:
+            deletedCount: 0
+            insertedCount: 2
+            # Since the map of insertedIds is generated before execution it
+            # could indicate inserts that did not actually succeed. We omit
+            # this field rather than expect drivers to provide an accurate
+            # map filtered by write errors.
+            matchedCount: 0
+            modifiedCount: 0
+            upsertedCount: 0
+            upsertedIds: { }
+    outcome:
+      - collectionName: *collection1Name
+        databaseName: *database0Name
+        documents:
+          - { _id: 1, x: 11 }
+          - { _id: 2, x: 22 }
+          - { _id: 3, x: 33 }
+
+  - description: "ReplaceOne prohibits atomic modifiers"
+    skipReason: RUBY-2437
+    operations:
+      - name: replaceOne
+        object: *collection1
+        arguments:
+          filter: { _id: 1 }
+          replacement: { $set: { x: 22 }}
+        expectError:
+          isClientError: true
+    expectEvents:
+      - client: *client0
+        events: []
+    outcome:
+      - collectionName: *collection1Name
+        databaseName: *database0Name
+        documents:
+          - { _id: 1, x: 11 }
+
+  - description: "readConcern majority with out stage"
+    runOnRequirements:
+      - minServerVersion: "4.1.0"
+        topologies: [ replicaset, sharded-replicaset ]
+    operations:
+      - name: aggregate
+        object: *collection2
+        arguments:
+          pipeline: &pipeline
+            - $sort: { x : 1 }
+            - $match: { _id: { $gt: 1 } }
+            - $out: *out
+    expectEvents:
+      - client: *client0
+        events:
+          - commandStartedEvent:
+              command:
+                aggregate: *collection2Name
+                pipeline: *pipeline
+                readConcern: { level: majority }
+              # The following two assertions were not in the original test
+              commandName: aggregate
+              databaseName: *database0Name
+    outcome:
+      - collectionName: *out
+        databaseName: *database0Name
+        documents:
+          - { _id: 2, x: 22 }
+          - { _id: 3, x: 33 }
+
+  - description: "Aggregate with $listLocalSessions"
+    runOnRequirements:
+      - minServerVersion: "3.6.0"
+    operations:
+      - name: aggregate
+        object: *database1
+        arguments:
+          pipeline:
+            - $listLocalSessions: { }
+            - $limit: 1
+            - $addFields: { dummy: "dummy field"}
+            - $project: { _id: 0, dummy: 1}
+        expectResult:
+          - { dummy: "dummy field" }

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

@@ -0,0 +1,155 @@
+description: "poc-gridfs"
+
+schemaVersion: "1.0"
+
+createEntities:
+  - client:
+      id: &client0 client0
+  - database:
+      id: &database0 database0
+      client: *client0
+      databaseName: &database0Name gridfs-tests
+  - bucket:
+      id: &bucket0 bucket0
+      database: *database0
+  - collection:
+      id: &bucket0_files_collection bucket0_files_collection
+      database: *database0
+      collectionName: &bucket0_files_collectionName fs.files
+  - collection:
+      id: &bucket0_chunks_collection bucket0_chunks_collection
+      database: *database0
+      collectionName: &bucket0_chunks_collectionName fs.chunks
+
+initialData:
+  - collectionName: *bucket0_files_collectionName
+    databaseName: *database0Name
+    documents:
+      - _id: { $oid: "000000000000000000000005" }
+        length: 10
+        chunkSize: 4
+        uploadDate: { $date: "1970-01-01T00:00:00.000Z" }
+        md5: "57d83cd477bfb1ccd975ab33d827a92b"
+        filename: "length-10"
+        contentType: "application/octet-stream"
+        aliases: []
+        metadata: {}
+  - collectionName: *bucket0_chunks_collectionName
+    databaseName: *database0Name
+    documents:
+      - _id: { $oid: "000000000000000000000005" }
+        files_id: { $oid: "000000000000000000000005" }
+        n: 0
+        data: { $binary: { base64: "ESIzRA==", subType: "00" } } # hex: 11223344
+      - _id: { $oid: "000000000000000000000006" }
+        files_id: { $oid: "000000000000000000000005" }
+        n: 1
+        data: { $binary: { base64: "VWZ3iA==", subType: "00" } } # hex: 55667788
+      - _id: { $oid: "000000000000000000000007" }
+        files_id: { $oid: "000000000000000000000005" }
+        n: 2
+        data: { $binary: { base64: "mao=", subType: "00" } } # hex: 99aa
+
+tests:
+  # Changed from original test ("length is 8") to operate on same initialData
+  - description: "Delete when length is 10"
+    operations:
+      - name: delete
+        object: *bucket0
+        arguments:
+          id: { $oid: "000000000000000000000005" }
+    # Original test uses "assert.data" syntax to modify outcome collection for
+    # comparison. This can be accomplished using "outcome" directly.
+    outcome:
+      - collectionName: *bucket0_files_collectionName
+        databaseName: *database0Name
+        documents: []
+      - collectionName: *bucket0_chunks_collectionName
+        databaseName: *database0Name
+        documents: []
+
+  - description: "Download when there are three chunks"
+    operations:
+      # Original test uses "download" operation. We use an explicit operation
+      # that returns a stream and then assert the contents of that stream.
+      - name: download
+        object: *bucket0
+        arguments:
+          id: { $oid: "000000000000000000000005" }
+        expectResult: { $$matchesHexBytes: "112233445566778899aa" }
+
+  - description: "Download when files entry does not exist"
+    operations:
+      - name: download
+        object: *bucket0
+        arguments:
+          id: { $oid: "000000000000000000000000" }
+        # Original test expects "FileNotFound" error, which isn't specified
+        expectError: { isError: true }
+
+  - description: "Download when an intermediate chunk is missing"
+    operations:
+      # Original test uses "arrange" syntax to modify initialData. This can be
+      # accomplished as a delete operation on the chunks collection.
+      - name: deleteOne
+        object: *bucket0_chunks_collection
+        arguments:
+          filter:
+            files_id: { $oid: "000000000000000000000005" }
+            n: 1
+        expectResult:
+          deletedCount: 1
+      - name: download
+        object: *bucket0
+        arguments:
+          id: { $oid: "000000000000000000000005" }
+        # Original test expects "ChunkIsMissing" error, which isn't specified
+        expectError: { isError: true }
+
+  - description: "Upload when length is 5"
+    operations:
+      # Original test uses "upload" operation. We use an explicit operation
+      # that takes a stream, which has been created from the expected hex bytes.
+      - name: upload
+        object: *bucket0
+        arguments:
+          filename: filename
+          source: { $$hexBytes: "1122334455" }
+          chunkSizeBytes: 4
+        # Original test references the result directly in "assert.data". Here,
+        # we need to save the result as an entity, which we can later reference.
+        expectResult: { $$type: objectId }
+        saveResultAsEntity: &oid0 oid0
+      # "outcome" does not allow operators, but we can perform the assertions
+      # with separate find operations.
+      - name: find
+        object: *bucket0_files_collection
+        arguments:
+          filter: {}
+          sort: { uploadDate: -1 }
+          limit: 1
+        expectResult:
+          - _id: { $$matchesEntity: *oid0 }
+            length: 5
+            chunkSize: 4
+            uploadDate: { $$type: date }
+            # The md5 field is deprecated so some drivers do not calculate it when uploading files.
+            md5: { $$unsetOrMatches: "283d4fea5dded59cf837d3047328f5af" }
+            filename: filename
+      - name: find
+        object: *bucket0_chunks_collection
+        arguments:
+          # We cannot use the saved ObjectId when querying, but filtering by a
+          # non-zero timestamp will exclude initialData and sort can return the
+          # expected chunks in order.
+          filter: { _id: { $gt: { $oid: "000000000000000000000007" } } }
+          sort: { n: 1 }
+        expectResult:
+          - _id: { $$type: objectId }
+            files_id: { $$matchesEntity: *oid0 }
+            n: 0
+            data: { $binary: { base64: "ESIzRA==", subType: "00" } } # hex 11223344
+          - _id: { $$type: objectId }
+            files_id: { $$matchesEntity: *oid0 }
+            n: 1
+            data: { $binary: { base64: "VQ==", subType: "00" } } # hex 55