mongo 2.13.0.beta1 → 2.14.0

data/spec/mongo/utils_spec.rb

@@ -0,0 +1,39 @@
+require 'lite_spec_helper'
+
+describe Mongo::Utils do
+  describe '#shallow_symbolize_keys' do
+    it 'symbolizes' do
+      described_class.shallow_symbolize_keys(
+        'foo' => 'bar',
+        'aKey' => 'aValue',
+        'a_key' => 'a_value',
+        key: :value,
+      ).should == {
+        foo: 'bar',
+        aKey: 'aValue',
+        a_key: 'a_value',
+        key: :value,
+      }
+    end
+  end
+
+  describe '#shallow_camelize_keys' do
+    it 'camelizes' do
+      described_class.shallow_camelize_keys(
+        'foo' => 'bar',
+        'aKey' => 'aValue',
+        'aa_key' => 'a_value',
+        key: :value,
+        sKey: :sValue,
+        us_key: :us_value,
+      ).should == {
+        'foo' => 'bar',
+        'aKey' => 'aValue',
+        'aaKey' => 'a_value',
+        'key' => :value,
+        'sKey' => :sValue,
+        'usKey' => :us_value,
+      }
+    end
+  end
+end

data/spec/runners/auth.rb

@@ -83,6 +83,9 @@ module Mongo
 
         if credential['username']
           expected_credential['user'] = credential['username']
+        end
+
+        if credential['password']
           expected_credential['password'] = credential['password']
         end
 

data/spec/runners/change_streams/test.rb

@@ -67,10 +67,10 @@ module Mongo
         end
 
         # Work around https://jira.mongodb.org/browse/SERVER-17397
-        if ClusterConfig.instance.server_version < '4.3' &&
+        if ClusterConfig.instance.server_version < '4.4' &&
           global_client.cluster.servers.length > 1
         then
-          mongos_each_direct_client do |client|
+          ::Utils.mongos_each_direct_client do |client|
             client.database.command(flushRouterConfig: 1)
           end
         end
@@ -107,7 +107,7 @@ module Mongo
 
       def run
         change_stream = begin
-          @target.watch(@pipeline, Utils.snakeize_hash(@options))
+          @target.watch(@pipeline, ::Utils.snakeize_hash(@options))
         rescue Mongo::Error::OperationFailure => e
           return {
             result: {

data/spec/runners/cmap.rb

@@ -40,7 +40,7 @@ module Mongo
         @test = YAML.load(File.read(test_path))
 
         @description = @test['description']
-        @pool_options = Utils.snakeize_hash(process_options(@test['poolOptions']))
+        @pool_options = ::Utils.snakeize_hash(process_options(@test['poolOptions']))
         @spec_ops = @test['operations'].map { |o| Operation.new(self, o) }
         @processed_ops = []
         @expected_error = @test['error']

data/spec/runners/command_monitoring.rb

@@ -135,7 +135,7 @@ module Mongo
         if expected.keys.first == '$numberLong'
           converted = expected.values.first.to_i
           if actual.is_a?(BSON::Int64)
-            actual = Utils.int64_value(actual)
+            actual = ::Utils.int64_value(actual)
           elsif actual.is_a?(BSON::Int32)
             return false
           end
@@ -260,8 +260,9 @@ module Mongo
       # @param [ Mongo::Collection ] collection The collection.
       #
       # @since 2.1.0
-      def run(collection)
+      def run(collection, subscriber)
         collection.insert_many(@data)
+        subscriber.clear_events!
         @operation.execute(collection)
       end
     end
@@ -338,37 +339,5 @@ module Mongo
         "match_#{event_type}"
       end
     end
-
-    # The test subscriber to track the events.
-    #
-    # @since 2.1.0
-    class TestSubscriber
-
-      def started(event)
-        command_started_event[event.command_name] = event
-      end
-
-      def succeeded(event)
-        command_succeeded_event[event.command_name] = event
-      end
-
-      def failed(event)
-        command_failed_event[event.command_name] = event
-      end
-
-      private
-
-      def command_started_event
-        @started_events ||= BSON::Document.new
-      end
-
-      def command_succeeded_event
-        @succeeded_events ||= BSON::Document.new
-      end
-
-      def command_failed_event
-        @failed_events ||= BSON::Document.new
-      end
-    end
   end
 end

data/spec/runners/connection_string.rb

@@ -84,20 +84,6 @@ RSpec::Matchers.define :match_auth do |test|
   end
 end
 
-RSpec::Matchers.define :match_options do |test|
-
-  match do |client|
-    options = test.options
-    return true unless options
-    options.match?(client.options)
-  end
-
-  failure_message do |client|
-    "With URI: #{test.uri_string}\n" +
-      "Expected that test options: #{test.options.options} would match client options: #{client.options}"
-  end
-end
-
 module Mongo
   module ConnectionString
 
@@ -159,7 +145,7 @@ module Mongo
       end
 
       def options
-        @options ||= Options.new(@spec['options']) if @spec['options']
+        @spec['options']
       end
 
       def client
@@ -239,115 +225,31 @@ module Mongo
       end
     end
 
-    class Options
-
-      MAPPINGS = {
-        # Connection and Replica Set Options
-        'replicaset' => :replica_set,
-        'directconnection' => :direct_connection,
-
-        # Timeout Options
-        'connecttimeoutms' => :connect_timeout,
-        'sockettimeoutms' => :socket_timeout,
-        'serverselectiontimeoutms' => :server_selection_timeout,
-        'localthresholdms' => :local_threshold,
-        'heartbeatfrequencyms' => :heartbeat_frequency,
-        'maxidletimems' => :max_idle_time,
-
-         # Write  Options
-        'journal' => [:write_concern, 'j'],
-        'w' => [:write_concern, 'w'],
-        'wtimeoutms' => [:write_concern, 'wtimeout'],
-
-        # Read Options
-        'readpreference' => ['read', 'mode'],
-        'readpreferencetags' => ['read', 'tag_sets'],
-        'maxstalenessseconds' => ['read', 'max_staleness'],
-
-        # Pool Options
-        'minpoolsize' => :min_pool_size,
-        'maxpoolsize' => :max_pool_size,
-
-        # Security Options
-        'tls' => :ssl,
-        'tlsallowinvalidcertificates' => :ssl_verify_certificate,
-        'tlsallowinvalidhostnames' => :ssl_verify_hostname,
-        'tlscafile' => :ssl_ca_cert,
-        'tlscertificatekeyfile' => :ssl_cert,
-        'tlscertificatekeyfilepassword' => :ssl_key_pass_phrase,
-        'tlsinsecure' => :ssl_verify,
-
-        # Auth Options
-        'authsource' => :auth_source,
-        'authmechanism' => :auth_mech,
-        'authmechanismproperties' => :auth_mech_properties,
-
-        # Client Options
-        'appname' => :app_name,
-        'readconcernlevel' => [:read_concern, 'level'],
-        'retrywrites' => :retry_writes,
-        'zlibcompressionlevel' => :zlib_compression_level,
-      }
-
-      attr_reader :options
-
-      def initialize(options)
-        @options = options
-      end
-
-      def match?(opts)
-        @options.all? do |k, v|
-          k = k.downcase
-
-          expected =
-            case k
-            when 'authmechanism'
-              Mongo::URI::AUTH_MECH_MAP[v].downcase.to_s
-            when 'authmechanismproperties'
-              v.reduce({}) do |new_v, prop|
-                prop_key = prop.first.downcase
-                prop_val = prop.last == 'true' ? true : prop.last
-                new_v[prop_key] = prop_val
-
-                new_v
-              end
-            when 'compressors'
-              v.dup.tap do |compressors|
-                # The Ruby driver doesn't support snappy
-                compressors.delete('snappy')
-              end
-            when 'readpreference'
-              Mongo::URI::READ_MODE_MAP[v.downcase].to_s
-            when 'tlsallowinvalidcertificates', 'tlsallowinvalidhostnames', 'tlsinsecure'
-              !v
-            else
-              if k.end_with?('ms') && k != 'wtimeoutms'
-                v / 1000.0
-              elsif v.is_a?(String)
-                v.downcase
-              else
-                v
-              end
-            end
-
-          actual =
-            case MAPPINGS[k]
-            when nil
-              opts[k]
-            when Array
-              opts[MAPPINGS[k].first][MAPPINGS[k].last]
-            else
-              opts[MAPPINGS[k]]
-            end
-
-          if actual.is_a?(Symbol)
-            actual = actual.to_s
+    module_function def adjust_expected_mongo_client_options(options)
+      expected = options.dup.tap do |expected|
+        expected.each do |k, v|
+          # Ruby driver downcases auth mechanism properties when
+          # constructing the client.
+          #
+          # Some tests give options in all lower case.
+          if k.downcase == 'authmechanismproperties'
+            expected[k] = ::Utils.downcase_keys(v)
           end
-          if actual.is_a?(String)
-            actual = actual.downcase
+          # Ruby driver does not support snappy.
+          if k == 'compressors'
+            expected[k] = v.reject { |sub_v| sub_v == 'snappy' }
           end
-
-          expected == actual
+        end
+        # We omit retryReads/retryWrites=true because some tests do not
+        # provide those.
+        %w(retryReads retryWrites).each do |k, v|
+          if expected[k] == true
+            expected.delete(k)
+          end
+        end
+        # Fix appName case.
+        if expected.key?('appname') && !expected.key?('appName')
+          expected['appName'] = expected.delete('appname')
         end
       end
     end
@@ -406,8 +308,17 @@ def define_connection_string_spec_tests(test_paths, spec_cls = Mongo::Connection
               expect(test.client).to match_auth(test)
             end
 
-            it 'creates a client with the correct options' do
-              expect(test.client).to match_options(test)
+            if test.options
+              it 'creates a client with the correct options' do
+                mapped = Mongo::URI::OptionsMapper.new.ruby_to_smc(test.client.options)
+                # Connection string spec tests do not use canonical URI option names
+                actual = Utils.downcase_keys(mapped)
+                actual.delete('authsource')
+                expected = Mongo::ConnectionString.adjust_expected_mongo_client_options(
+                  test.options,
+                )
+                actual.should == expected
+              end
             end
 
             if test.read_concern_expectation

data/spec/runners/crud/context.rb

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

@@ -88,7 +88,7 @@ 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)
@@ -99,14 +99,14 @@ module Mongo
 
       def database_options
         if opts = @spec['databaseOptions']
-          Utils.convert_operation_options(opts)
+          ::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
@@ -114,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
@@ -183,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
@@ -197,50 +197,50 @@ 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
@@ -270,7 +270,8 @@ module Mongo
       end
 
       def create_collection(database, context)
-        database[arguments.fetch('collection')].create(session: context.session)
+        opts = transformed_options(context)
+        database[arguments.fetch('collection')].create(session: opts[:session])
       end
 
       def rename(collection, context)
@@ -351,6 +352,16 @@ module Mongo
         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
 
       def options
@@ -360,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
@@ -390,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"
@@ -406,7 +417,7 @@ module Mongo
       end
 
       def transform_return_document(v)
-        Utils.underscore(v).to_sym
+        ::Utils.underscore(v).to_sym
       end
 
       def update
@@ -414,7 +425,7 @@ module Mongo
       end
 
       def transform_read_preference(v)
-        Utils.snakeize_hash(v)
+        ::Utils.snakeize_hash(v)
       end
 
       def read_preference
@@ -429,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