mongo 2.12.4 → 2.14.0.rc1

data/spec/runners/crud.rb

@@ -1,4 +1,4 @@
-# Copyright (C) 2014-2019 MongoDB, Inc.
+# Copyright (C) 2014-2020 MongoDB Inc.
 #
 # Licensed under the Apache License, Version 2.0 (the "License");
 # you may not use this file except in compliance with the License.
@@ -47,7 +47,7 @@ def crud_execute_operations(spec, test, num_ops, event_subscriber, expect_error,
       res = nil
       begin
         res = test.run(client, num_ops)
-      rescue => e
+      rescue Mongo::Error => e
         res = e
       end
       res

data/spec/runners/crud/context.rb

@@ -1,4 +1,4 @@
-# Copyright (C) 2019 MongoDB, Inc.
+# Copyright (C) 2019-2020 MongoDB Inc.
 #
 # Licensed under the Apache License, Version 2.0 (the "License");
 # you may not use this file except in compliance with the License.
@@ -12,12 +12,16 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
+require 'support/keyword_struct'
+
 module Mongo
   module CRUD
-    class Context
-      def transform_arguments(arguments)
-        arguments
-      end
-    end
+    Context = KeywordStruct.new(
+      :session0,
+      :session1,
+      :sdam_subscriber,
+      :threads,
+      :primary_address,
+    )
   end
 end

data/spec/runners/crud/operation.rb

@@ -1,4 +1,4 @@
-# Copyright (C) 2014-2019 MongoDB, Inc.
+# Copyright (C) 2014-2020 MongoDB Inc.
 #
 # Licensed under the Apache License, Version 2.0 (the "License");
 # you may not use this file except in compliance with the License.
@@ -36,6 +36,8 @@ module Mongo
         @outcome = Outcome.new(outcome_spec || spec)
       end
 
+      attr_reader :spec
+
       # The operation name.
       #
       # @return [ String ] name The operation name.
@@ -86,17 +88,25 @@ module Mongo
       #
       # @since 2.0.0
       def execute(target)
-        op_name = Utils.underscore(name)
+        op_name = ::Utils.underscore(name)
         if target.is_a?(Mongo::Database)
           op_name = "db_#{op_name}"
         elsif target.is_a?(Mongo::Client)
-          op_name= "client_#{op_name}"
+          op_name = "client_#{op_name}"
         end
         send(op_name, target, Context.new)
       end
 
+      def database_options
+        if opts = @spec['databaseOptions']
+          ::Utils.convert_operation_options(opts)
+        else
+          nil
+        end
+      end
+
       def collection_options
-        Utils.convert_operation_options(@spec['collectionOptions'])
+        ::Utils.convert_operation_options(@spec['collectionOptions'])
       end
 
       private
@@ -104,31 +114,31 @@ module Mongo
       # read operations
 
       def aggregate(collection, context)
-        collection.aggregate(arguments['pipeline'], context.transform_arguments(options)).to_a
+        collection.aggregate(arguments['pipeline'], transformed_options(context)).to_a
       end
 
       def db_aggregate(database, context)
-        database.aggregate(arguments['pipeline'], context.transform_arguments(options)).to_a
+        database.aggregate(arguments['pipeline'], transformed_options(context)).to_a
       end
 
       def count(collection, context)
-        collection.count(arguments['filter'], context.transform_arguments(options))
+        collection.count(arguments['filter'], transformed_options(context))
       end
 
       def count_documents(collection, context)
-        collection.count_documents(arguments['filter'], context.transform_arguments(options))
+        collection.count_documents(arguments['filter'], transformed_options(context))
       end
 
       def distinct(collection, context)
-        collection.distinct(arguments['fieldName'], arguments['filter'], context.transform_arguments(options))
+        collection.distinct(arguments['fieldName'], arguments['filter'], transformed_options(context))
       end
 
       def estimated_document_count(collection, context)
-        collection.estimated_document_count(context.transform_arguments(options))
+        collection.estimated_document_count(transformed_options(context))
       end
 
       def find(collection, context)
-        opts = context.transform_arguments(options)
+        opts = transformed_options(context)
         if arguments['modifiers']
           opts = opts.merge(modifiers: BSON::Document.new(arguments['modifiers']))
         end
@@ -142,34 +152,6 @@ module Mongo
         find(collection, context).first
       end
 
-      def client_list_databases(client, context)
-        client.list_databases
-      end
-
-      def client_list_database_names(client, context)
-        client.list_databases({}, true)
-      end
-
-      def client_list_database_objects(client, context)
-        client.list_mongo_databases
-      end
-
-      def db_list_collections(database, context)
-        database.list_collections
-      end
-
-      def db_list_collection_names(database, context)
-        database.collection_names
-      end
-
-      def db_list_collection_objects(database, context)
-        database.collections
-      end
-
-      def list_indexes(collection, context)
-        collection.indexes.to_a
-      end
-
       def watch(collection, context)
         collection.watch
       end
@@ -201,7 +183,7 @@ module Mongo
       # write operations
 
       def bulk_write(collection, context)
-        result = collection.bulk_write(requests, context.transform_arguments(options))
+        result = collection.bulk_write(requests, transformed_options(context))
         return_doc = {}
         return_doc['deletedCount'] = result.deleted_count || 0
         return_doc['insertedIds'] = result.inserted_ids if result.inserted_ids
@@ -215,50 +197,169 @@ module Mongo
       end
 
       def delete_many(collection, context)
-        result = collection.delete_many(arguments['filter'], context.transform_arguments(options))
+        result = collection.delete_many(arguments['filter'], transformed_options(context))
         { 'deletedCount' => result.deleted_count }
       end
 
       def delete_one(collection, context)
-        result = collection.delete_one(arguments['filter'], context.transform_arguments(options))
+        result = collection.delete_one(arguments['filter'], transformed_options(context))
         { 'deletedCount' => result.deleted_count }
       end
 
       def insert_many(collection, context)
-        result = collection.insert_many(arguments['documents'], context.transform_arguments(options))
+        result = collection.insert_many(arguments['documents'], transformed_options(context))
         { 'insertedIds' => result.inserted_ids }
       end
 
       def insert_one(collection, context)
-        result = collection.insert_one(arguments['document'], context.transform_arguments(options))
+        result = collection.insert_one(arguments['document'], transformed_options(context))
         { 'insertedId' => result.inserted_id }
       end
 
       def replace_one(collection, context)
-        result = collection.replace_one(arguments['filter'], arguments['replacement'], context.transform_arguments(options))
+        result = collection.replace_one(arguments['filter'], arguments['replacement'], transformed_options(context))
         update_return_doc(result)
       end
 
       def update_many(collection, context)
-        result = collection.update_many(arguments['filter'], arguments['update'], context.transform_arguments(options))
+        result = collection.update_many(arguments['filter'], arguments['update'], transformed_options(context))
         update_return_doc(result)
       end
 
       def update_one(collection, context)
-        result = collection.update_one(arguments['filter'], arguments['update'], context.transform_arguments(options))
+        result = collection.update_one(arguments['filter'], arguments['update'], transformed_options(context))
         update_return_doc(result)
       end
 
       def find_one_and_delete(collection, context)
-        collection.find_one_and_delete(arguments['filter'], context.transform_arguments(options))
+        collection.find_one_and_delete(arguments['filter'], transformed_options(context))
       end
 
       def find_one_and_replace(collection, context)
-        collection.find_one_and_replace(arguments['filter'], arguments['replacement'], context.transform_arguments(options))
+        collection.find_one_and_replace(arguments['filter'], arguments['replacement'], transformed_options(context))
       end
 
       def find_one_and_update(collection, context)
-        collection.find_one_and_update(arguments['filter'], arguments['update'], context.transform_arguments(options))
+        collection.find_one_and_update(arguments['filter'], arguments['update'], transformed_options(context))
+      end
+
+      # ddl
+
+      def client_list_databases(client, context)
+        client.list_databases
+      end
+
+      def client_list_database_names(client, context)
+        client.list_databases({}, true)
+      end
+
+      def client_list_database_objects(client, context)
+        client.list_mongo_databases
+      end
+
+      def db_list_collections(database, context)
+        database.list_collections
+      end
+
+      def db_list_collection_names(database, context)
+        database.collection_names
+      end
+
+      def db_list_collection_objects(database, context)
+        database.collections
+      end
+
+      def create_collection(database, context)
+        opts = transformed_options(context)
+        database[arguments.fetch('collection')].create(session: opts[:session])
+      end
+
+      def rename(collection, context)
+        collection.client.use(:admin).command({
+          renameCollection: "#{collection.database.name}.#{collection.name}",
+          to: "#{collection.database.name}.#{arguments['to']}"
+        })
+      end
+
+      def drop(collection, context)
+        collection.drop
+      end
+
+      def drop_collection(database, context)
+        database[arguments.fetch('collection')].drop
+      end
+
+      def create_index(collection, context)
+        # The Ruby driver method uses `key` while the createIndexes server
+        # command and the test specifiecation use 'keys`.
+        opts = BSON::Document.new(options)
+        if opts.key?(:keys)
+          opts[:key] = opts.delete(:keys)
+        end
+        session = opts.delete(:session)
+        collection.indexes(session: session && context.send(session)).create_many([opts])
+      end
+
+      def drop_index(collection, context)
+        unless options.keys == %i(name)
+          raise "Only name is allowed when dropping the index"
+        end
+        name = options[:name]
+        collection.indexes.drop_one(name)
+      end
+
+      def list_indexes(collection, context)
+        collection.indexes.to_a
+      end
+
+      # special
+
+      def assert_collection_exists(client, context)
+        c = client.use(dn = arguments.fetch('database'))
+        unless c.database.collection_names.include?(cn = arguments.fetch('collection'))
+          raise "Collection #{cn} does not exist in database #{dn}, but must"
+        end
+      end
+
+      def assert_collection_not_exists(client, context)
+        c = client.use(dn = arguments.fetch('database'))
+        if c.database.collection_names.include?(cn = arguments.fetch('collection'))
+          raise "Collection #{cn} exists in database #{dn}, but must not"
+        end
+      end
+
+      def assert_index_exists(client, context)
+        c = client.use(dn = arguments.fetch('database'))
+        coll = c[cn = arguments.fetch('collection')]
+        unless coll.indexes.map { |doc| doc['name'] }.include?(ixn = arguments.fetch('index'))
+          raise "Index #{ixn} does not exist in collection #{cn} in database #{dn}, but must"
+        end
+      end
+
+      def assert_index_not_exists(client, context)
+        c = client.use(dn = arguments.fetch('database'))
+        coll = c[cn = arguments.fetch('collection')]
+        begin
+          if coll.indexes.map { |doc| doc['name'] }.include?(ixn = arguments.fetch('index'))
+            raise "Index #{ixn} exists in collection #{cn} in database #{dn}, but must not"
+          end
+        rescue Mongo::Error::OperationFailure => e
+          if e.to_s =~ /ns does not exist/
+            # Success.
+          else
+            raise
+          end
+        end
+      end
+
+      def configure_fail_point(client, context)
+        fp = arguments.fetch('failPoint')
+        $disable_fail_points ||= []
+        $disable_fail_points << [
+          fp,
+          ClusterConfig.instance.primary_address,
+        ]
+        client.use('admin').database.command(fp)
       end
 
       # options & arguments
@@ -270,7 +371,7 @@ module Mongo
         # bulk write test is an exception in that it has an "options" key
         # with the options.
         arguments.merge(arguments['options'] || {}).each do |spec_k, v|
-          ruby_k = Utils.underscore(spec_k).to_sym
+          ruby_k = ::Utils.underscore(spec_k).to_sym
 
           if v.is_a?(Hash) && v['$numberLong']
             v = v['$numberLong'].to_i
@@ -300,8 +401,8 @@ module Mongo
       end
 
       def bulk_request(request)
-        op_name = Utils.underscore(request['name'])
-        args = Utils.shallow_snakeize_hash(request['arguments'])
+        op_name = ::Utils.underscore(request['name'])
+        args = ::Utils.shallow_snakeize_hash(request['arguments'])
         if args[:document]
           unless args.keys == [:document]
             raise "If :document is given, it must be the only key"
@@ -316,7 +417,7 @@ module Mongo
       end
 
       def transform_return_document(v)
-        Utils.underscore(v).to_sym
+        ::Utils.underscore(v).to_sym
       end
 
       def update
@@ -324,7 +425,7 @@ module Mongo
       end
 
       def transform_read_preference(v)
-        Utils.snakeize_hash(v)
+        ::Utils.snakeize_hash(v)
       end
 
       def read_preference
@@ -339,6 +440,27 @@ module Mongo
         return_doc['modifiedCount'] = result.modified_count if result.modified_count
         return_doc
       end
+
+      def transformed_options(context)
+        opts = options.dup
+        if opts[:session]
+          opts[:session] = case opts[:session]
+          when 'session0'
+            unless context.session0
+              raise "Trying to use session0 but it is not in context"
+            end
+            context.session0
+          when 'session1'
+            unless context.session1
+              raise "Trying to use session1 but it is not in context"
+            end
+            context.session1
+          else
+            raise "Invalid session name '#{opts[:session]}'"
+          end
+        end
+        opts
+      end
     end
   end
 end

data/spec/runners/crud/outcome.rb

@@ -1,4 +1,4 @@
-# Copyright (C) 2014-2019 MongoDB, Inc.
+# Copyright (C) 2014-2020 MongoDB Inc.
 #
 # Licensed under the Apache License, Version 2.0 (the "License");
 # you may not use this file except in compliance with the License.

data/spec/runners/crud/spec.rb

@@ -11,13 +11,6 @@ module Mongo
       def initialize(test_path)
         contents = File.read(test_path)
 
-        # Since Ruby driver binds a client to a database, change the
-        # database name in the spec to the one we are using
-        contents.sub!(/"crud-tests"/, '"ruby-driver"')
-        contents.sub!(/"retryable-reads-tests"/, '"ruby-driver"')
-        contents.sub!(/"transaction-tests"/, '"ruby-driver"')
-        contents.sub!(/"withTransaction-tests"/, '"ruby-driver"')
-
         @spec = YAML.load(contents)
         @description = File.basename(test_path)
         @data = BSON::ExtJSON.parse_obj(@spec['data'])

data/spec/runners/crud/test.rb

@@ -6,13 +6,6 @@ module Mongo
     # @since 2.0.0
     class CRUDTest < CRUDTestBase
 
-      # The test description.
-      #
-      # @return [ String ] description The test description.
-      #
-      # @since 2.0.0
-      attr_reader :description
-
       # Spec tests have configureFailPoint as a string, make it a string here too
       FAIL_POINT_BASE_COMMAND = BSON::Document.new(
         'configureFailPoint' => "onPrimaryTransactionalWrite",
@@ -34,11 +27,13 @@ module Mongo
       def initialize(crud_spec, data, test)
         @spec = crud_spec
         @data = data
+        @description = test['description']
+        @client_options = ::Utils.convert_client_options(test['clientOptions'] || {})
+
         if test['failPoint']
           @fail_point_command = FAIL_POINT_BASE_COMMAND.merge(test['failPoint'])
         end
-        @description = test['description']
-        @client_options = Utils.convert_client_options(test['clientOptions'] || {})
+
         if test['operations']
           @operations = test['operations'].map do |op_spec|
             Operation.new(self, op_spec)
@@ -46,10 +41,12 @@ module Mongo
         else
           @operations = [Operation.new(self, test['operation'], test['outcome'])]
         end
+
+        @expectations = BSON::ExtJSON.parse_obj(test['expectations'], mode: :bson)
+
         if test['outcome']
-          @outcome = Mongo::CRUD::Outcome.new(test['outcome'])
+          @outcome = Mongo::CRUD::Outcome.new(BSON::ExtJSON.parse_obj(test['outcome'], mode: :bson))
         end
-        @expectations = test['expectations']
       end
 
       attr_reader :client_options
@@ -61,9 +58,6 @@ module Mongo
       # an array of operations.
       attr_reader :operations
 
-      # The expected command monitoring events
-      attr_reader :expectations
-
       attr_reader :outcome
 
       # Run the test.
@@ -114,18 +108,6 @@ module Mongo
         setup_fail_point(client)
       end
 
-      def setup_fail_point(client)
-        if @fail_point_command
-          client.use(:admin).command(@fail_point_command)
-        end
-      end
-
-      def clear_fail_point(client)
-        if @fail_point_command
-          client.use(:admin).command(@fail_point_command.merge(mode: "off"))
-        end
-      end
-
       def actual_collection_contents(client)
         unless @spec.collection_name
           raise ArgumentError, 'Spec does not specify a global collection'