mongo 2.11.2 → 2.13.0.beta1

data/spec/{support → 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.
@@ -12,15 +12,15 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-require 'support/gridfs'
-require 'support/crud/requirement'
-require 'support/crud/spec'
-require 'support/crud/test_base'
-require 'support/crud/test'
-require 'support/crud/outcome'
-require 'support/crud/context'
-require 'support/crud/operation'
-require 'support/crud/verifier'
+require 'runners/gridfs'
+require 'runners/crud/requirement'
+require 'runners/crud/spec'
+require 'runners/crud/test_base'
+require 'runners/crud/test'
+require 'runners/crud/outcome'
+require 'runners/crud/context'
+require 'runners/crud/operation'
+require 'runners/crud/verifier'
 
 def collection_data(collection)
   collection.find.to_a
@@ -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/{support → 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.

data/spec/{support → 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.
@@ -28,10 +28,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.
@@ -86,11 +92,19 @@ module Mongo
         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'])
       end
@@ -138,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
@@ -179,7 +165,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,7 +176,7 @@ 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
 
@@ -257,6 +243,114 @@ module Mongo
         collection.find_one_and_update(arguments['filter'], arguments['update'], context.transform_arguments(options))
       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)
+        database[arguments.fetch('collection')].create(session: context.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
+
       # options & arguments
 
       def options

data/spec/{support → 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/{support → runners}/crud/requirement.rb

@@ -42,7 +42,7 @@ module Mongo
           ok &&= cc.fcv_ish >= short_min_server_version
         end
         if max_server_version
-          ok &&= cc.server_version <= max_server_version
+          ok &&= cc.short_server_version <= max_server_version
         end
         if topologies
           ok &&= topologies.include?(cc.topology)

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

@@ -17,12 +17,17 @@ module Mongo
         contents.sub!(/"retryable-reads-tests"/, '"ruby-driver"')
         contents.sub!(/"transaction-tests"/, '"ruby-driver"')
         contents.sub!(/"withTransaction-tests"/, '"ruby-driver"')
+        contents.sub!(/ default_write_concern_db/, ' ruby-driver')
 
         @spec = YAML.load(contents)
         @description = File.basename(test_path)
-        @data = @spec['data']
+        @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)
@@ -41,6 +46,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

@@ -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'

data/spec/runners/crud/test_base.rb

@@ -0,0 +1,69 @@
+module Mongo
+  module CRUD
+
+    class CRUDTestBase
+
+      # The test description.
+      #
+      # @return [ String ] description The test description.
+      attr_reader :description
+
+      # The expected command monitoring events.
+      attr_reader :expectations
+
+      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(BSON::Document.new(@fail_point_command).merge(mode: "off"))
+        end
+      end
+
+      private
+
+      def resolve_target(client, operation)
+        if operation.database_options
+          # Some CRUD spec tests specify "database options". In Ruby there is
+          # no facility to specify options on a database, hence these are
+          # lifted to the client.
+          client = client.with(operation.database_options)
+        end
+        case operation.object
+        when 'collection'
+          client[@spec.collection_name].with(operation.collection_options)
+        when 'database'
+          client.database
+        when 'client'
+          client
+        when 'gridfsbucket'
+          client.database.fs
+        else
+          raise "Unknown target #{operation.object}"
+        end
+      end
+
+      # If the deployment is a sharded cluster, creates a direct client
+      # to each of the mongos nodes and yields each in turn to the
+      # provided block. Does nothing in other topologies.
+      def mongos_each_direct_client
+        if ClusterConfig.instance.topology == :sharded
+          client = ClientRegistry.instance.global_client('basic')
+          client.cluster.next_primary
+          client.cluster.servers.each do |server|
+            direct_client = ClientRegistry.instance.new_local_client(
+              [server.address.to_s],
+              SpecConfig.instance.test_options.merge(
+                connect: :sharded
+              ).merge(SpecConfig.instance.auth_options))
+            yield direct_client
+            direct_client.close
+          end
+        end
+      end
+    end
+  end
+end

data/spec/{support → runners}/crud/verifier.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.
@@ -34,12 +34,7 @@ module Mongo
           expect(actual_collection_data).to be_empty
         else
           expect(actual_collection_data).not_to be nil
-          expected_collection_data.each do |doc|
-            expect(actual_collection_data).to include(doc)
-          end
-          actual_collection_data.each do |doc|
-            expect(expected_collection_data).to include(doc)
-          end
+          expect(actual_collection_data).to match_with_type(expected_collection_data)
         end
       end
 
@@ -76,6 +71,18 @@ EOT
         end
       end
 
+      # This variant used by change stream tests which provide the first N
+      # events rather than all of them.
+      def verify_command_started_event_min_count(expected_events, actual_events)
+        if actual_events.length < expected_events.length
+          raise RSpec::Expectations::ExpectationNotMetError.new, <<-EOT
+Expected at least #{expected_events.length} events, got #{actual_events.length} events.
+Expected events: #{expected_events.pretty_inspect}
+Actual events: #{actual_events.pretty_inspect}
+EOT
+        end
+      end
+
       def verify_command_started_event(expected_events, actual_events, i)
         expect(expected_events.length).to be > i
         expect(actual_events.length).to be > i
@@ -105,15 +112,14 @@ EOT
         expected_absence = expected_command.select { |k, v| v.nil? }
 
         expected_presence.each do |k, v|
-          expect(k => actual_command[k]).to eq(k => v)
+          expect(actual_command[k]).to match_with_type(v)
         end
 
         expected_absence.each do |k, v|
           expect(actual_command).not_to have_key(k)
         end
 
-        # this compares remaining fields in events after command is removed
-        expect(actual_event).to eq(expected_event)
+        expect(actual_event).to match_with_type(expected_event)
       end
 
       private
@@ -122,6 +128,8 @@ EOT
         case expected
         when nil
           expect(actual).to be nil
+        when 42, '42'
+          expect(actual).not_to be nil
         when Hash
           if actual.is_a?(Hash) && actual['error'] &&
             !expected.keys.any? { |key| key.start_with?('error') }
@@ -161,6 +169,10 @@ EOT
           return
         end
 
+        if [42, '42'].include?(expected[k]) && actual[k]
+          return
+        end
+
         if %w(deletedCount matchedCount modifiedCount upsertedCount).include?(k)
           # Some tests assert that some of these counts are zero.
           # The driver may omit the respective key, which is fine.
@@ -181,9 +193,13 @@ EOT
           return
         end
 
-        # This should produce a meaningful error message,
-        # even though we do not actually require that expected[k] == actual[k]
-        expect({k => expected[k]}).to eq({k => actual[k]})
+        if expected[k].is_a?(Time)
+          expect(k => actual[k].utc.to_s).to eq(k => expected[k].utc.to_s)
+        else
+          # This should produce a meaningful error message,
+          # even though we do not actually require that expected[k] == actual[k]
+          expect(k => actual[k]).to eq(k => expected[k])
+        end
       end
     end
   end