mongo 2.13.2 → 2.15.0

data/spec/mongo/uri_spec.rb

@@ -1,3 +1,6 @@
+# frozen_string_literal: true
+# encoding: utf-8
+
 require 'lite_spec_helper'
 
 describe Mongo::URI do
@@ -727,9 +730,9 @@ describe Mongo::URI do
             'readPreference=secondary&maxStalenessSeconds=89'
           end
 
-          it 'does not raise an exception until the read preference is used' do
+          it 'does not raise an exception and drops the option' do
             client = new_local_client_nmio(string)
-            expect(client.read_preference).to eq(BSON::Document.new(mode: :secondary, max_staleness: 89))
+            expect(client.read_preference).to eq(BSON::Document.new(mode: :secondary))
           end
         end
       end
@@ -854,16 +857,16 @@ describe Mongo::URI do
           context 'when a mapping value is missing' do
             let(:options) { "authMechanism=#{mechanism}&authMechanismProperties=SERVICE_NAME:,CANONICALIZE_HOST_NAME:" }
 
-            it 'sets the options on a client created with the uri' do
-              expect(client.options[:auth_mech_properties]).to eq({ 'canonicalize_host_name' => nil, 'service_name' => nil })
+            it 'sets the options to defaults' do
+              expect(client.options[:auth_mech_properties]).to eq({ 'service_name' => 'mongodb' })
             end
           end
 
           context 'when a mapping value is missing but another is present' do
             let(:options) { "authMechanism=#{mechanism}&authMechanismProperties=SERVICE_NAME:foo,CANONICALIZE_HOST_NAME:" }
 
-            it 'sets the options on a client created with the uri' do
-              expect(client.options[:auth_mech_properties]).to eq({ 'canonicalize_host_name' => nil, 'service_name' => 'foo' })
+            it 'only sets the present value' do
+              expect(client.options[:auth_mech_properties]).to eq({ 'service_name' => 'foo' })
             end
           end
         end
@@ -1013,84 +1016,111 @@ describe Mongo::URI do
 
     context 'auth mechanism properties provided' do
 
+      shared_examples 'sets options in the expected manner' do
+        it 'preserves case in auth mechanism properties returned from URI' do
+          expect(uri.uri_options[:auth_mech_properties]).to eq(expected_uri_options)
+        end
+
+        it 'downcases auth mechanism properties keys in client options' do
+          client = new_local_client_nmio(string)
+          expect(client.options[:auth_mech_properties]).to eq(expected_client_options)
+        end
+      end
+
       context 'service_name' do
         let(:options) do
-          "authMechanismProperties=SERVICE_NAME:#{service_name}"
+          "authMechanismProperties=SERVICE_name:#{service_name}"
         end
+
         let(:service_name) { 'foo' }
-        let(:expected) { Mongo::Options::Redacted.new({ service_name: service_name }) }
 
-        it 'sets the auth mechanism properties' do
-          expect(uri.uri_options[:auth_mech_properties]).to eq(expected)
+        let(:expected_uri_options) do
+          Mongo::Options::Redacted.new(
+            SERVICE_name: service_name,
+          )
         end
 
-        it 'sets the options on a client created with the uri' do
-          client = new_local_client_nmio(string)
-          expect(client.options[:auth_mech_properties]).to eq(expected)
+        let(:expected_client_options) do
+          Mongo::Options::Redacted.new(
+            service_name: service_name,
+          )
         end
+
+        include_examples 'sets options in the expected manner'
       end
 
       context 'canonicalize_host_name' do
         let(:options) do
-          "authMechanismProperties=CANONICALIZE_HOST_NAME:#{canonicalize_host_name}"
+          "authMechanismProperties=CANONICALIZE_HOST_name:#{canonicalize_host_name}"
         end
+
         let(:canonicalize_host_name) { 'true' }
-        let(:expected) { Mongo::Options::Redacted.new({ canonicalize_host_name: true }) }
 
-        it 'sets the auth mechanism properties' do
-          expect(uri.uri_options[:auth_mech_properties]).to eq(expected)
+        let(:expected_uri_options) do
+          Mongo::Options::Redacted.new(
+            CANONICALIZE_HOST_name: true,
+          )
         end
 
-        it 'sets the options on a client created with the uri' do
-          client = new_local_client_nmio(string)
-          expect(client.options[:auth_mech_properties]).to eq(expected)
+        let(:expected_client_options) do
+          Mongo::Options::Redacted.new(
+            canonicalize_host_name: true,
+          )
         end
+
+        include_examples 'sets options in the expected manner'
       end
 
       context 'service_realm' do
         let(:options) do
-          "authMechanismProperties=SERVICE_REALM:#{service_realm}"
+          "authMechanismProperties=SERVICE_realm:#{service_realm}"
         end
 
         let(:service_realm) { 'dumdum' }
-        let(:expected) { Mongo::Options::Redacted.new({ service_realm: service_realm }) }
-
 
-        it 'sets the auth mechanism properties' do
-          expect(uri.uri_options[:auth_mech_properties]).to eq(expected)
+        let(:expected_uri_options) do
+          Mongo::Options::Redacted.new(
+            SERVICE_realm: service_realm,
+          )
         end
 
-        it 'sets the options on a client created with the uri' do
-          client = new_local_client_nmio(string)
-          expect(client.options[:auth_mech_properties]).to eq(expected)
+        let(:expected_client_options) do
+          Mongo::Options::Redacted.new(
+            service_realm: service_realm,
+          )
         end
+
+        include_examples 'sets options in the expected manner'
       end
 
       context 'multiple properties' do
         let(:options) do
-          "authMechanismProperties=SERVICE_REALM:#{service_realm}," +
-            "CANONICALIZE_HOST_NAME:#{canonicalize_host_name}," +
-            "SERVICE_NAME:#{service_name}"
+          "authMechanismProperties=SERVICE_realm:#{service_realm}," +
+            "CANONICALIZE_HOST_name:#{canonicalize_host_name}," +
+            "SERVICE_name:#{service_name}"
         end
 
         let(:service_name) { 'foo' }
         let(:canonicalize_host_name) { 'true' }
         let(:service_realm) { 'dumdum' }
 
-        let(:expected) do
-          Mongo::Options::Redacted.new({ service_name: service_name,
-                                         canonicalize_host_name: true,
-                                         service_realm: service_realm })
+        let(:expected_uri_options) do
+          Mongo::Options::Redacted.new(
+            SERVICE_name: service_name,
+            CANONICALIZE_HOST_name: true,
+            SERVICE_realm: service_realm,
+          )
         end
 
-        it 'sets the auth mechanism properties' do
-          expect(uri.uri_options[:auth_mech_properties]).to eq(expected)
+        let(:expected_client_options) do
+          Mongo::Options::Redacted.new(
+            service_name: service_name,
+            canonicalize_host_name: true,
+            service_realm: service_realm,
+          )
         end
 
-        it 'sets the options on a client created with the uri' do
-          client = new_local_client_nmio(string)
-          expect(client.options[:auth_mech_properties]).to eq(expected)
-        end
+        include_examples 'sets options in the expected manner'
       end
     end
 

data/spec/mongo/utils_spec.rb

@@ -0,0 +1,56 @@
+# frozen_string_literal: true
+# encoding: utf-8
+
+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
+
+  describe '#slice_hash' do
+    it do
+      hash = {'key1' => 1, :key2 => 's', :key3 => true}
+      expect(
+        described_class.slice_hash(hash, 'key1', :key3)
+      ).to eq(
+        {
+          'key1' => 1,
+          :key3 => true
+        }
+      )
+    end
+  end
+end

data/spec/mongo/write_concern/acknowledged_spec.rb

@@ -1,3 +1,6 @@
+# frozen_string_literal: true
+# encoding: utf-8
+
 require 'spec_helper'
 
 describe Mongo::WriteConcern::Acknowledged do

data/spec/mongo/write_concern/unacknowledged_spec.rb

@@ -1,3 +1,6 @@
+# frozen_string_literal: true
+# encoding: utf-8
+
 require 'spec_helper'
 
 describe Mongo::WriteConcern::Unacknowledged do

data/spec/mongo/write_concern_spec.rb

@@ -1,3 +1,6 @@
+# frozen_string_literal: true
+# encoding: utf-8
+
 require 'lite_spec_helper'
 
 describe Mongo::WriteConcern do

data/spec/runners/auth.rb

@@ -1,3 +1,6 @@
+# frozen_string_literal: true
+# encoding: utf-8
+
 # Copyright (C) 2014-2020 MongoDB Inc.
 #
 # Licensed under the Apache License, Version 2.0 (the "License");
@@ -83,6 +86,9 @@ module Mongo
 
         if credential['username']
           expected_credential['user'] = credential['username']
+        end
+
+        if credential['password']
           expected_credential['password'] = credential['password']
         end
 
@@ -100,12 +106,30 @@ module Mongo
         expected_credential
       end
 
-      def received_credential
+      def actual_client_options
         client.options.select do |k, _|
           %w(auth_mech auth_mech_properties auth_source password user).include?(k)
         end
       end
 
+      def actual_user_attributes
+        user = Mongo::Auth::User.new(client.options)
+        attrs = {}
+        {
+          auth_mech_properties: 'auth_mech_properties',
+          auth_source: 'auth_source',
+          name: 'user',
+          password: 'password',
+          mechanism: 'auth_mech',
+        }.each do |attr, field|
+          value = user.send(attr)
+          unless value.nil? || attr == :auth_mech_properties && value == {}
+            attrs[field] = value
+          end
+        end
+        attrs
+      end
+
       private
 
       def expected_auth_mech

data/spec/runners/change_streams/outcome.rb

@@ -1,3 +1,6 @@
+# frozen_string_literal: true
+# encoding: utf-8
+
 # Copyright (C) 2014-2020 MongoDB Inc.
 #
 # Licensed under the Apache License, Version 2.0 (the "License");

data/spec/runners/change_streams/spec.rb

@@ -1,3 +1,6 @@
+# frozen_string_literal: true
+# encoding: utf-8
+
 # Copyright (C) 2014-2020 MongoDB Inc.
 #
 # Licensed under the Apache License, Version 2.0 (the "License");

data/spec/runners/change_streams/test.rb

@@ -1,3 +1,6 @@
+# frozen_string_literal: true
+# encoding: utf-8
+
 # Copyright (C) 2014-2020 MongoDB Inc.
 #
 # Licensed under the Apache License, Version 2.0 (the "License");
@@ -70,7 +73,7 @@ module Mongo
         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

data/spec/runners/cmap.rb

@@ -1,3 +1,6 @@
+# frozen_string_literal: true
+# encoding: utf-8
+
 require 'runners/cmap/verifier'
 
 module Mongo

data/spec/runners/cmap/verifier.rb

@@ -1,3 +1,6 @@
+# frozen_string_literal: true
+# encoding: utf-8
+
 # Copyright (C) 2019-2020 MongoDB Inc.
 #
 # Licensed under the Apache License, Version 2.0 (the "License");

data/spec/runners/command_monitoring.rb

@@ -1,3 +1,6 @@
+# frozen_string_literal: true
+# encoding: utf-8
+
 # Copyright (C) 2014-2020 MongoDB Inc.
 #
 # Licensed under the Apache License, Version 2.0 (the "License");

data/spec/runners/connection_string.rb

@@ -1,3 +1,6 @@
+# frozen_string_literal: true
+# encoding: utf-8
+
 # Copyright (C) 2014-2020 MongoDB Inc.
 #
 # Licensed under the Apache License, Version 2.0 (the "License");
@@ -84,20 +87,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 +148,7 @@ module Mongo
       end
 
       def options
-        @options ||= Options.new(@spec['options']) if @spec['options']
+        @spec['options']
       end
 
       def client
@@ -239,115 +228,27 @@ 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
+        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
-
-          expected == actual
+        end
+        # Fix appName case.
+        if expected.key?('appname') && !expected.key?('appName')
+          expected['appName'] = expected.delete('appname')
         end
       end
     end
@@ -406,8 +307,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