mongo 2.10.5 → 2.15.1

data/spec/{support → runners}/crud/operation.rb

@@ -1,4 +1,7 @@
-# Copyright (C) 2014-2019 MongoDB, Inc.
+# frozen_string_literal: true
+# encoding: utf-8
+
+# 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.
@@ -28,10 +31,16 @@ module Mongo
         @crud_test = crud_test
         @spec = IceNine.deep_freeze(spec)
         @name = spec['name']
-        @arguments = spec['arguments'] || {}
+        if spec['arguments']
+          @arguments = BSON::ExtJSON.parse_obj(spec['arguments'])
+        else
+          @arguments = {}
+        end
         @outcome = Outcome.new(outcome_spec || spec)
       end
 
+      attr_reader :spec
+
       # The operation name.
       #
       # @return [ String ] name The operation name.
@@ -82,17 +91,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
@@ -100,31 +117,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
@@ -138,34 +155,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
@@ -179,7 +168,7 @@ module Mongo
       end
 
       def download(fs_bucket, context)
-        stream = fs_bucket.open_download_stream(BSON::ObjectId.from_string(arguments['id']['$oid']))
+        stream = fs_bucket.open_download_stream(arguments['id'])
         stream.read
       end
 
@@ -190,14 +179,14 @@ module Mongo
 
       def map_reduce(collection, context)
         view = Mongo::Collection::View.new(collection)
-        mr = Mongo::Collection::View::MapReduce.new(view, arguments['map']['$code'], arguments['reduce']['$code'])
+        mr = Mongo::Collection::View::MapReduce.new(view, arguments['map'].javascript, arguments['reduce'].javascript)
         mr.to_a
       end
 
       # 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
@@ -211,50 +200,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
@@ -266,7 +374,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
@@ -296,8 +404,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"
@@ -312,7 +420,7 @@ module Mongo
       end
 
       def transform_return_document(v)
-        Utils.underscore(v).to_sym
+        ::Utils.underscore(v).to_sym
       end
 
       def update
@@ -320,7 +428,7 @@ module Mongo
       end
 
       def transform_read_preference(v)
-        Utils.snakeize_hash(v)
+        ::Utils.snakeize_hash(v)
       end
 
       def read_preference
@@ -335,6 +443,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/{support → runners}/crud/outcome.rb

@@ -1,4 +1,7 @@
-# Copyright (C) 2014-2019 MongoDB, Inc.
+# frozen_string_literal: true
+# encoding: utf-8
+
+# 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/requirement.rb

@@ -0,0 +1,133 @@
+# frozen_string_literal: true
+# encoding: utf-8
+
+module Mongo
+  module CRUD
+    class Requirement
+      YAML_KEYS = %w(auth minServerVersion maxServerVersion topology topologies serverParameters serverless).freeze
+
+      def initialize(spec)
+        spec = spec.dup
+        # Legacy tests have the requirements mixed with other test fields
+        spec.delete('data')
+        spec.delete('tests')
+
+        unless (unhandled_keys = spec.keys - YAML_KEYS).empty?
+          raise "Unhandled requirement specification keys: #{unhandled_keys}"
+        end
+
+        @min_server_version = spec['minServerVersion']
+        @max_server_version = spec['maxServerVersion']
+        # topologies is for unified test format.
+        # topology is for legacy tests.
+        @topologies = if topologies = spec['topology'] || spec['topologies']
+          topologies.map do |topology|
+            {
+              'replicaset' => :replica_set,
+              'single' => :single,
+              'sharded' => :sharded,
+              'sharded-replicaset' => :sharded,
+            }[topology].tap do |v|
+              unless v
+                raise "Unknown topology #{topology}"
+              end
+            end
+          end
+        else
+          nil
+        end
+        @server_parameters = spec['serverParameters']
+        @serverless = if serverless = spec['serverless']
+          case spec['serverless']
+          when 'require' then :require
+          when 'forbid' then :forbid
+          when 'allow' then :allow
+          else raise "Unknown serverless requirement: #{serverless}"
+          end
+        else
+          nil
+        end
+        @auth = spec['auth']
+      end
+
+      attr_reader :min_server_version
+      attr_reader :max_server_version
+      attr_reader :topologies
+      attr_reader :serverless
+
+      def short_min_server_version
+        if min_server_version
+          min_server_version.split('.')[0..1].join('.')
+        else
+          nil
+        end
+      end
+
+      def short_max_server_version
+        if max_server_version
+          max_server_version.split('.')[0..1].join('.')
+        else
+          nil
+        end
+      end
+
+      def satisfied?
+        cc = ClusterConfig.instance
+        ok = true
+        if short_min_server_version
+          ok &&= cc.fcv_ish >= short_min_server_version
+        end
+        if max_server_version
+          ok &&= cc.short_server_version <= max_server_version
+        end
+        if topologies
+          ok &&= topologies.include?(cc.topology)
+        end
+        if @server_parameters
+          @server_parameters.each do |k, required_v|
+            actual_v = cc.server_parameters[k]
+            if actual_v.nil? && !required_v.nil?
+              ok = false
+            elsif actual_v != required_v
+              if Numeric === actual_v && Numeric === required_v
+                if actual_v.to_f != required_v.to_f
+                  ok = false
+                end
+              else
+                ok = false
+              end
+            end
+          end
+        end
+        if @serverless
+          if SpecConfig.instance.serverless?
+            ok = ok && [:allow, :require].include?(serverless)
+          else
+            ok = ok && [:allow, :forbid].include?(serverless)
+          end
+        end
+        if @auth == true
+          ok &&= cc.auth_enabled?
+        elsif @auth == false
+          ok &&= !cc.auth_enabled?
+        end
+        ok
+      end
+
+      def description
+        versions = [min_server_version, max_server_version].compact
+        if versions.any?
+          versions = versions.join('-')
+        else
+          versions = nil
+        end
+        topologies = if self.topologies
+          self.topologies.map(&:to_s).join(',')
+        else
+          nil
+        end
+        [versions, topologies].compact.join('/')
+      end
+    end
+  end
+end

data/spec/{support → runners}/crud/spec.rb

@@ -1,3 +1,6 @@
+# frozen_string_literal: true
+# encoding: utf-8
+
 module Mongo
   module CRUD
     # Represents a CRUD specification test.
@@ -5,27 +8,21 @@ module Mongo
 
       # Instantiate the new spec.
       #
-      # @example Create the spec.
-      #   Spec.new(file)
-      #
-      # @param [ String ] file The name of the file.
+      # @param [ String ] test_path The path to the file.
       #
       # @since 2.0.0
-      def initialize(file)
-        contents = ERB.new(File.read(file)).result
-
-        # 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"')
+      def initialize(test_path)
+        contents = File.read(test_path)
 
-        @spec = YAML.load(ERB.new(contents).result)
-        @description = File.basename(file)
-        @data = @spec['data']
+        @spec = YAML.load(contents)
+        @description = File.basename(test_path)
+        @data = BSON::ExtJSON.parse_obj(@spec['data'])
         @tests = @spec['tests']
 
+        # Introduced with Client-Side Encryption tests
+        @json_schema = BSON::ExtJSON.parse_obj(@spec['json_schema'])
+        @key_vault_data = BSON::ExtJSON.parse_obj(@spec['key_vault_data'])
+
         @requirements = if run_on = @spec['runOn']
           run_on.map do |spec|
             Requirement.new(spec)
@@ -44,6 +41,13 @@ module Mongo
 
       attr_reader :requirements
 
+      # @return [ Hash ] The jsonSchema collection validator.
+      attr_reader :json_schema
+
+      # @return [ Array<Hash> ] Data to insert into the key vault before
+      #   running each test.
+      attr_reader :key_vault_data
+
       def collection_name
         # Older spec tests do not specify a collection name, thus
         # we provide a default here

data/spec/{support → runners}/crud/test.rb

@@ -1,3 +1,6 @@
+# frozen_string_literal: true
+# encoding: utf-8
+
 module Mongo
   module CRUD
 
@@ -6,13 +9,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 +30,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 +44,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 +61,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 +111,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'