mongo 2.19.1 → 2.21.0

data/spec/runners/unified/change_stream_operations.rb

@@ -10,22 +10,9 @@ module Unified
       object = entities.get_any(object_id)
       use_arguments(op) do |args|
         pipeline = args.use!('pipeline')
-        opts = {}
-        if batch_size = args.use('batchSize')
-          opts[:batch_size] = batch_size
-        end
-        if comment = args.use('comment')
-          opts[:comment] = comment
-        end
-        if full_document = args.use('fullDocument')
-          opts[:full_document] = full_document
-        end
-        if full_document_before_change = args.use('fullDocumentBeforeChange')
-          opts[:full_document_before_change] = full_document_before_change
-        end
-        if args.key?('showExpandedEvents')
-          opts[:show_expanded_events] = args.use!('showExpandedEvents')
-        end
+        opts = extract_options(args, 'batchSize', 'comment', 'fullDocument',
+          'fullDocumentBeforeChange', 'showExpandedEvents', 'timeoutMS',
+          'maxAwaitTimeMS')
         cs = object.watch(pipeline, **opts)
         if name = op.use('saveResultAsEntity')
           entities.set(:change_stream, name, cs)
@@ -35,18 +22,21 @@ module Unified
 
     def iterate_until_document_or_error(op)
       object_id = op.use!('object')
-      object = entities.get(:change_stream, object_id)
-      object.to_enum.next
+      object = entities.get_any(object_id)
+      object.try_next
+    end
+
+    def iterate_once(op)
+      stream_id = op.use!('object')
+      stream = entities.get_any(stream_id)
+      stream.try_next
     end
 
     def close(op)
       object_id = op.use!('object')
-      # The Ruby driver unified spec runner does not currently implement
-      # find cursors as created by createFindCursor. This will be done
-      # as part of CSOT implementation. When this is done, the line(s) below
-      # should be changed to retrieve such cursor instances and close them.
-      object = entities.get(:csot_cursor, object_id)
-      object.close
+      opts = op.key?('arguments') ? extract_options(op.use!('arguments'), 'timeoutMS') : {}
+      object = entities.get_any(object_id)
+      object.close(opts)
     end
   end
 end

data/spec/runners/unified/crud_operations.rb

@@ -5,7 +5,7 @@ module Unified
 
   module CrudOperations
 
-    def find(op)
+    def crud_find(op)
       get_find_view(op).to_a
     end
 
@@ -16,23 +16,21 @@ module Unified
     def get_find_view(op)
       collection = entities.get(:collection, op.use!('object'))
       use_arguments(op) do |args|
-        opts = {
-          let: args.use('let'),
-          comment: args.use('comment'),
-          allow_disk_use: args.use('allowDiskUse'),
-          show_disk_loc: args.use('showRecordId'),
-          return_key: args.use('returnKey'),
-          projection: args.use('projection'),
-          skip: args.use('skip'),
-          hint: args.use('hint'),
-          max_value: args.use('max'),
-          max_time_ms: args.use('maxTimeMS'),
-          min_value: args.use('min'),
-        }
-        if session = args.use('session')
-          opts[:session] = entities.get(:session, session)
-        end
-        req = collection.find(args.use!('filter'), **opts)
+        filter = args.use!('filter')
+        session = args.use('session')
+
+        opts = extract_options(args, 'let', 'comment',
+          'allowDiskUse', 'returnKey', 'projection',
+          'skip', 'hint', 'maxTimeMS', 'timeoutMS',
+          'collation', 'noCursorTimeout', 'oplogReplay', 'allowPartialResults',
+          'timeoutMode', 'maxAwaitTimeMS', 'cursorType', 'timeoutMode',
+          { 'showRecordId' => :show_disk_loc, 'max' => :max_value, 'min' => :min_value },
+          allow_extra: true)
+        symbolize_options!(opts, :timeout_mode, :cursor_type)
+
+        opts[:session] = entities.get(:session, session) if session
+
+        req = collection.find(filter, **opts)
         if batch_size = args.use('batchSize')
           req = req.batch_size(batch_size)
         end
@@ -49,15 +47,23 @@ module Unified
       end
     end
 
-    def count_documents(op)
+    def count(op)
       collection = entities.get(:collection, op.use!('object'))
       use_arguments(op) do |args|
-        opts = {}
+        opts = extract_options(args, 'comment', 'timeoutMS', 'maxTimeMS', allow_extra: true)
         if session = args.use('session')
           opts[:session] = entities.get(:session, session)
         end
-        if comment = args.use('comment')
-          opts[:comment] = comment
+        collection.count(args.use!('filter'), **opts)
+      end
+    end
+
+    def count_documents(op)
+      collection = entities.get(:collection, op.use!('object'))
+      use_arguments(op) do |args|
+        opts = extract_options(args, 'comment', 'timeoutMS', 'maxTimeMS', allow_extra: true)
+        if session = args.use('session')
+          opts[:session] = entities.get(:session, session)
         end
         collection.find(args.use!('filter')).count_documents(**opts)
       end
@@ -66,12 +72,9 @@ module Unified
     def estimated_document_count(op)
       collection = entities.get(:collection, op.use!('object'))
       use_arguments(op) do |args|
-        opts = {}
-        if max_time_ms = args.use('maxTimeMS')
-          opts[:max_time_ms] = max_time_ms
-        end
-        if comment = args.use('comment')
-          opts[:comment] = comment
+        opts = extract_options(args, 'comment', 'timeoutMS', 'maxTimeMS', allow_extra: true)
+        if session = args.use('session')
+          opts[:session] = entities.get(:session, session)
         end
         collection.estimated_document_count(**opts)
       end
@@ -80,13 +83,10 @@ module Unified
     def distinct(op)
       collection = entities.get(:collection, op.use!('object'))
       use_arguments(op) do |args|
-        opts = {}
+        opts = extract_options(args, 'comment', 'timeoutMS', 'maxTimeMS', allow_extra: true)
         if session = args.use('session')
           opts[:session] = entities.get(:session, session)
         end
-        if comment = args.use('comment')
-          opts[:comment] = comment
-        end
         req = collection.find(args.use!('filter'), **opts).distinct(args.use!('fieldName'), **opts)
         result = req.to_a
       end
@@ -102,6 +102,8 @@ module Unified
           comment: args.use('comment'),
           hint: args.use('hint'),
           upsert: args.use('upsert'),
+          timeout_ms: args.use('timeoutMS'),
+          max_time_ms: args.use('maxTimeMS')
         }
         if return_document = args.use('returnDocument')
           opts[:return_document] = return_document.downcase.to_sym
@@ -122,6 +124,8 @@ module Unified
           let: args.use('let'),
           comment: args.use('comment'),
           hint: args.use('hint'),
+          timeout_ms: args.use('timeoutMS'),
+          max_time_ms: args.use('maxTimeMS')
         }
         if session = args.use('session')
           opts[:session] = entities.get(:session, session)
@@ -138,6 +142,8 @@ module Unified
           let: args.use('let'),
           comment: args.use('comment'),
           hint: args.use('hint'),
+          timeout_ms: args.use('timeoutMS'),
+          max_time_ms: args.use('maxTimeMS')
         }
         if session = args.use('session')
           opts[:session] = entities.get(:session, session)
@@ -150,7 +156,9 @@ module Unified
       collection = entities.get(:collection, op.use!('object'))
       use_arguments(op) do |args|
         opts = {
-          comment: args.use('comment')
+          comment: args.use('comment'),
+          timeout_ms: args.use('timeoutMS'),
+          max_time_ms: args.use('maxTimeMS')
         }
         if session = args.use('session')
           opts[:session] = entities.get(:session, session)
@@ -163,7 +171,9 @@ module Unified
       collection = entities.get(:collection, op.use!('object'))
       use_arguments(op) do |args|
         opts = {
-          comment: args.use('comment')
+          comment: args.use('comment'),
+          timeout_ms: args.use('timeoutMS'),
+          max_time_ms: args.use('maxTimeMS')
         }
         unless (ordered = args.use('ordered')).nil?
           opts[:ordered] = ordered
@@ -183,6 +193,8 @@ module Unified
           comment: args.use('comment'),
           hint: args.use('hint'),
           upsert: args.use('upsert'),
+          timeout_ms: args.use('timeoutMS'),
+          max_time_ms: args.use('maxTimeMS')
         }
         if session = args.use('session')
           opts[:session] = entities.get(:session, session)
@@ -198,6 +210,8 @@ module Unified
           let: args.use('let'),
           comment: args.use('comment'),
           hint: args.use('hint'),
+          timeout_ms: args.use('timeoutMS'),
+          max_time_ms: args.use('maxTimeMS')
         }
         collection.update_many(args.use!('filter'), args.use!('update'), **opts)
       end
@@ -212,7 +226,9 @@ module Unified
           comment: args.use('comment'),
           upsert: args.use('upsert'),
           let: args.use('let'),
-          hint: args.use('hint')
+          hint: args.use('hint'),
+          timeout_ms: args.use('timeoutMS'),
+          max_time_ms: args.use('maxTimeMS')
         )
       end
     end
@@ -224,6 +240,8 @@ module Unified
           let: args.use('let'),
           comment: args.use('comment'),
           hint: args.use('hint'),
+          timeout_ms: args.use('timeoutMS'),
+          max_time_ms: args.use('maxTimeMS')
         }
         if session = args.use('session')
           opts[:session] = entities.get(:session, session)
@@ -239,6 +257,8 @@ module Unified
           let: args.use('let'),
           comment: args.use('comment'),
           hint: args.use('hint'),
+          timeout_ms: args.use('timeoutMS'),
+          max_time_ms: args.use('maxTimeMS')
         }
         collection.delete_many(args.use!('filter'), **opts)
       end
@@ -260,6 +280,12 @@ module Unified
         if let = args.use('let')
           opts[:let] = let
         end
+        if timeout_ms = args.use('timeoutMS')
+          opts[:timeout_ms] = timeout_ms
+        end
+        if max_time_ms = args.use('maxTimeMS')
+          opts[:max_time_ms] = max_time_ms
+        end
         collection.bulk_write(requests, **opts)
       end
     end
@@ -268,27 +294,36 @@ module Unified
       obj = entities.get_any(op.use!('object'))
       args = op.use!('arguments')
       pipeline = args.use!('pipeline')
-      opts = {
-        let: args.use('let'),
-      }
+
+      opts = extract_options(args, 'let', 'comment', 'batchSize', 'maxTimeMS',
+        'allowDiskUse', 'timeoutMode', 'timeoutMS', 'maxTimeMS', allow_extra: true)
+      symbolize_options!(opts, :timeout_mode)
+
       if session = args.use('session')
         opts[:session] = entities.get(:session, session)
       end
-      if comment = args.use('comment')
-        opts[:comment] = comment
-      end
-      if batch_size = args.use('batchSize')
-        opts[:batch_size] = batch_size
-      end
-      if args.key?('allowDiskUse')
-        opts[:allow_disk_use] = args.use('allowDiskUse')
-      end
+
       unless args.empty?
         raise NotImplementedError, "Unhandled spec keys: #{args} in #{test_spec}"
       end
+
       obj.aggregate(pipeline, **opts).to_a
     end
 
+    def create_find_cursor(op)
+      obj = entities.get_any(op.use!('object'))
+      args = op.use!('arguments')
+
+      filter = args.use('filter')
+      opts = extract_options(args, 'batchSize', 'timeoutMS', 'cursorType', 'maxAwaitTimeMS')
+      symbolize_options!(opts, :cursor_type)
+
+      view = obj.find(filter, opts)
+      view.each # to initialize the cursor
+
+      view.cursor
+    end
+
     private
 
     def convert_bulk_write_spec(spec)

data/spec/runners/unified/ddl_operations.rb

@@ -20,6 +20,9 @@ module Unified
         if session = args.use('session')
           opts[:session] = entities.get(:session, session)
         end
+        if timeout_ms = args.use('timeoutMS')
+          opts[:timeout_ms] = timeout_ms
+        end
         client.list_databases(args.use('filter') || {}, name_only, **opts)
       end
     end
@@ -50,6 +53,15 @@ module Unified
         if pipeline = args.use('pipeline')
           collection_opts[:pipeline] = pipeline
         end
+        if capped = args.use('capped')
+          collection_opts[:capped] = capped
+        end
+        if size = args.use('size')
+          collection_opts[:size] = size
+        end
+        if max = args.use('max')
+          collection_opts[:max] = max
+        end
         database[args.use!('collection'), collection_opts].create(**opts)
       end
     end
@@ -65,13 +77,16 @@ module Unified
     def list_colls(op, name_only: false)
       database = entities.get(:database, op.use!('object'))
       use_arguments(op) do |args|
-        opts = {}
+        opts = extract_options(args, 'filter', 'timeoutMode', allow_extra: true)
+        symbolize_options!(opts, :timeout_mode)
+
         if session = args.use('session')
           opts[:session] = entities.get(:session, session)
         end
-        if filter = args.use('filter')
-          opts[:filter] = filter
+        if timeout_ms = args.use('timeoutMS')
+          opts[:timeout_ms] = timeout_ms
         end
+
         database.list_collections(**opts.merge(name_only: name_only))
       end
     end
@@ -126,14 +141,25 @@ module Unified
     def list_indexes(op)
       collection = entities.get(:collection, op.use!('object'))
       use_arguments(op) do |args|
-        opts = {}
+        opts = extract_options(args, 'timeoutMode', allow_extra: true)
         if session = args.use('session')
           opts[:session] = entities.get(:session, session)
         end
+        if timeout_ms = args.use('timeoutMS')
+          opts[:timeout_ms] = timeout_ms
+        end
         collection.indexes(**opts).to_a
       end
     end
 
+    def drop_indexes(op)
+      collection = entities.get(:collection, op.use!('object'))
+      use_arguments(op) do |args|
+        opts = extract_options(args, 'maxTimeMS', 'timeoutMS', allow_extra: true)
+        collection.indexes.drop_all(**opts)
+      end
+    end
+
     def create_index(op)
       collection = entities.get(:collection, op.use!('object'))
       use_arguments(op) do |args|
@@ -144,7 +170,12 @@ module Unified
         if args.key?('unique')
           opts[:unique] = args.use('unique')
         end
-
+        if timeout_ms = args.use('timeoutMS')
+          opts[:timeout_ms] = timeout_ms
+        end
+        if max_time_ms = args.use('maxTimeMS')
+          opts[:max_time_ms] = max_time_ms
+        end
         collection.indexes.create_one(
           args.use!('keys'),
           name: args.use('name'),
@@ -156,7 +187,7 @@ module Unified
     def drop_index(op)
       collection = entities.get(:collection, op.use!('object'))
       use_arguments(op) do |args|
-        opts = {}
+        opts = extract_options(args, 'maxTimeMS', 'timeoutMS', allow_extra: true)
         if session = args.use('session')
           opts[:session] = entities.get(:session, session)
         end
@@ -188,7 +219,7 @@ module Unified
         begin
           index = collection.indexes.get(args.use!('indexName'))
           raise Error::ResultMismatch, "Index found"
-        rescue Mongo::Error::OperationFailure => e
+        rescue Mongo::Error::OperationFailure::Family => e
           if e.code == 26
             # OK
           else

data/spec/runners/unified/grid_fs_operations.rb

@@ -5,17 +5,38 @@ module Unified
 
   module GridFsOperations
 
+    def gridfs_find(op)
+      bucket = entities.get(:bucket, op.use!('object'))
+      use_arguments(op) do |args|
+        filter = args.use!('filter')
+
+        opts = extract_options(args, 'allowDiskUse',
+          'skip', 'hint','timeoutMS',
+          'noCursorTimeout', 'sort', 'limit')
+
+        bucket.find(filter,opts).to_a
+      end
+    end
+
     def delete(op)
       bucket = entities.get(:bucket, op.use!('object'))
       use_arguments(op) do |args|
-        bucket.delete(args.use!('id'))
+        opts = {}
+        if timeout_ms = args.use('timeoutMS')
+          opts[:timeout_ms] = timeout_ms
+        end
+        bucket.delete(args.use!('id'), opts)
       end
     end
 
     def download(op)
       bucket = entities.get(:bucket, op.use!('object'))
       use_arguments(op) do |args|
-        stream = bucket.open_download_stream(args.use!('id'))
+        opts = {}
+        if timeout_ms = args.use('timeoutMS')
+          opts[:timeout_ms] = timeout_ms
+        end
+        stream = bucket.open_download_stream(args.use!('id'), opts)
         stream.read
       end
     end
@@ -48,6 +69,9 @@ module Unified
         if disable_md5 = args.use('disableMD5')
           opts[:disable_md5] = disable_md5
         end
+        if timeout_ms = args.use('timeoutMS')
+          opts[:timeout_ms] = timeout_ms
+        end
         contents = transform_contents(args.use!('source'))
         file_id = nil
         bucket.open_upload_stream(args.use!('filename'), **opts) do |stream|
@@ -58,6 +82,17 @@ module Unified
       end
     end
 
+    def drop(op)
+      bucket = entities.get(:bucket, op.use!('object'))
+      use_arguments(op) do |args|
+        opts = {}
+        if timeout_ms = args.use('timeoutMS')
+          opts[:timeout_ms] = timeout_ms
+        end
+        bucket.drop(opts)
+      end
+    end
+
     private
 
     def transform_contents(contents)

data/spec/runners/unified/search_index_operations.rb

@@ -0,0 +1,63 @@
+# frozen_string_literal: true
+
+module Unified
+  # The definitions of available search index operations, as used by the
+  # unified tests.
+  module SearchIndexOperations
+    def create_search_index(op)
+      collection = entities.get(:collection, op.use!('object'))
+
+      use_arguments(op) do |args|
+        model = args.use('model')
+        name = model.use('name')
+        definition = model.use('definition')
+        collection.search_indexes.create_one(definition, name: name)
+      end
+    end
+
+    def create_search_indexes(op)
+      collection = entities.get(:collection, op.use!('object'))
+
+      use_arguments(op) do |args|
+        models = args.use('models')
+        collection.search_indexes.create_many(models)
+      end
+    end
+
+    def drop_search_index(op)
+      collection = entities.get(:collection, op.use!('object'))
+
+      use_arguments(op) do |args|
+        collection.search_indexes.drop_one(
+          id: args.use('id'),
+          name: args.use('name')
+        )
+      end
+    end
+
+    def list_search_indexes(op)
+      collection = entities.get(:collection, op.use!('object'))
+
+      use_arguments(op) do |args|
+        agg_opts = args.use('aggregationOptions') || {}
+        collection.search_indexes(
+          id: args.use('id'),
+          name: args.use('name'),
+          aggregate: ::Utils.underscore_hash(agg_opts)
+        ).to_a
+      end
+    end
+
+    def update_search_index(op)
+      collection = entities.get(:collection, op.use!('object'))
+
+      use_arguments(op) do |args|
+        collection.search_indexes.update_one(
+          args.use('definition'),
+          id: args.use('id'),
+          name: args.use('name')
+        )
+      end
+    end
+  end
+end

data/spec/runners/unified/support_operations.rb

@@ -20,6 +20,9 @@ module Unified
         if read_preference = args.use('readPreference')
           opts[:read] = ::Utils.snakeize_hash(read_preference)
         end
+        if timeout_ms = args.use('timeoutMS')
+          opts[:timeout_ms] = timeout_ms
+        end
 
         database.command(cmd, **opts)
       end
@@ -70,8 +73,7 @@ module Unified
       consume_test_runner(op)
       use_arguments(op) do |args|
         session = entities.get(:session, args.use!('session'))
-        # https://jira.mongodb.org/browse/RUBY-1813
-        true
+        session.dirty? || raise(Error::ResultMismatch, 'expected session to be dirty')
       end
     end
 
@@ -79,8 +81,7 @@ module Unified
       consume_test_runner(op)
       use_arguments(op) do |args|
         session = entities.get(:session, args.use!('session'))
-        # https://jira.mongodb.org/browse/RUBY-1813
-        true
+        session.dirty? && raise(Error::ResultMismatch, 'expected session to be not dirty')
       end
     end
 
@@ -92,7 +93,7 @@ module Unified
         unless subscriber.started_events.length >= 2
           raise Error::ResultMismatch, "Must have at least 2 events, have #{subscriber.started_events.length}"
         end
-        lsids = subscriber.started_events[-2...-1].map do |cmd|
+        lsids = subscriber.started_events[-2..-1].map do |cmd|
           cmd.command.fetch('lsid')
         end
         if expected
@@ -131,14 +132,20 @@ module Unified
 
     def commit_transaction(op)
       session = entities.get(:session, op.use!('object'))
-      assert_no_arguments(op)
-      session.commit_transaction
+      opts = {}
+      use_arguments(op) do |args|
+        opts[:timeout_ms] = args.use('timeoutMS')
+      end
+      session.commit_transaction(opts.compact)
     end
 
     def abort_transaction(op)
       session = entities.get(:session, op.use!('object'))
-      assert_no_arguments(op)
-      session.abort_transaction
+      opts = {}
+      use_arguments(op) do |args|
+        opts[:timeout_ms] = args.use('timeoutMS')
+      end
+      session.abort_transaction(opts.compact)
     end
 
     def with_transaction(op)
@@ -313,6 +320,36 @@ module Unified
 
     private
 
+    # @param [ UsingHash ] args the arguments to extract options from
+    # @param [ Array<String | Hash> ] keys an array of strings and Hashes,
+    #   where Hashes represent a mapping from the MDB key to the correspoding
+    #   Ruby key. For Strings, the Ruby key is assumed to be a simple conversion
+    #   of the MDB key, from camel-case to snake-case.
+    # @param [ true | false ] allow_extra whether or not extra keys are allowed
+    #   to exist in the args hash, beyond those listed.
+    def extract_options(args, *keys, allow_extra: false)
+      {}.tap do |opts|
+        keys.each do |key|
+          Array(key).each do |mdb_key, ruby_key|
+            value = args.use(mdb_key)
+            opts[ruby_key || mdb_name_to_ruby(mdb_key)] = value unless value.nil?
+          end
+        end
+
+        raise NotImplementedError, "unhandled keys: #{args}" if !allow_extra && !args.empty?
+      end
+    end
+
+    def symbolize_options!(opts, *keys)
+      keys.each do |key|
+        opts[key] = mdb_name_to_ruby(opts[key]) if opts[key]
+      end
+    end
+
+    def mdb_name_to_ruby(name)
+      name.to_s.gsub(/([a-z])([A-Z])/) { "#{$1}_#{$2}" }.downcase.to_sym
+    end
+
     def assert_no_arguments(op)
       if op.key?('arguments')
         raise NotimplementedError, "Arguments are not allowed"