mongo 2.13.3 → 2.14.0.rc1

data/spec/mongo/uri_option_parsing_spec.rb

@@ -199,37 +199,37 @@ describe Mongo::URI do
 
   context 'authMechanismProperties' do
 
-    let(:string) { 'mongodb://example.com/?authmechanismproperties=SERVICE_REALM:foo,CANONICALIZE_HOST_NAME:TRUE' }
+    let(:string) { 'mongodb://example.com/?authmechanismproperties=SERVICE_realm:foo,CANONICALIZE_HOST_name:TRUE' }
 
     it_behaves_like 'parses successfully'
 
     it 'parses correctly' do
       expect(uri.uri_options[:auth_mech_properties]).to eq(BSON::Document.new(
-        service_realm: 'foo',
-        canonicalize_host_name: true,
+        SERVICE_realm: 'foo',
+        CANONICALIZE_HOST_name: true,
       ))
     end
 
     context 'canonicalize host name is false' do
 
-      let(:string) { 'mongodb://example.com/?authmechanismproperties=SERVICE_REALM:foo,CANONICALIZE_HOST_NAME:false' }
+      let(:string) { 'mongodb://example.com/?authmechanismproperties=SERVICE_realm:foo,CANONICALIZE_HOST_name:false' }
 
       it 'parses correctly' do
         expect(uri.uri_options[:auth_mech_properties]).to eq(BSON::Document.new(
-          service_realm: 'foo',
-          canonicalize_host_name: false,
+          SERVICE_realm: 'foo',
+          CANONICALIZE_HOST_name: false,
         ))
       end
     end
 
     context 'canonicalize host name is true in mixed case' do
 
-      let(:string) { 'mongodb://example.com/?authmechanismproperties=SERVICE_REALM:foo,CANONICALIZE_HOST_NAME:TrUe' }
+      let(:string) { 'mongodb://example.com/?authmechanismproperties=SERVICE_realm:foo,CANONICALIZE_HOST_name:TrUe' }
 
       it 'parses correctly' do
         expect(uri.uri_options[:auth_mech_properties]).to eq(BSON::Document.new(
-          service_realm: 'foo',
-          canonicalize_host_name: true,
+          SERVICE_realm: 'foo',
+          CANONICALIZE_HOST_name: true,
         ))
       end
     end
@@ -350,8 +350,8 @@ describe Mongo::URI do
 
       it_behaves_like 'parses successfully'
 
-      it 'is converted to nil' do
-        expect(uri.uri_options[:read]).to eq(BSON::Document.new(max_staleness: nil))
+      it 'is omitted' do
+        uri.uri_options.should_not have_key(:read)
       end
     end
   end

data/spec/mongo/uri_spec.rb

@@ -727,9 +727,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 +854,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 +1013,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,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/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/transactions/operation.rb

@@ -191,19 +191,8 @@ module Mongo
 
       def assert_event_count(client, context)
         events = _select_events(context)
-        if arguments['event'] == 'ServerMarkedUnknownEvent'
-          # We publish SDAM events from both regular and push monitors.
-          # This means sometimes there are two ServerMarkedUnknownEvent
-          # events published for the same server transition.
-          # Allow actual event count to be at least the expected event count
-          # in case there are multiple transitions in a single test.
-          unless events.length >= arguments['count']
-            raise "Expected #{arguments['count']} #{arguments['event']} events, but have #{events.length}"
-          end
-        else
-          unless events.length == arguments['count']
-            raise "Expected #{arguments['count']} #{arguments['event']} events, but have #{events.length}"
-          end
+        unless events.length == arguments['count']
+          raise "Exppected #{arguments['count']} #{arguments['event']} events, but have #{events.length}"
         end
       end
 

data/spec/spec_tests/cmap_spec.rb

@@ -22,9 +22,13 @@ describe 'Cmap' do
   end
 
   let(:options) do
-    SpecConfig.instance.ssl_options.merge(SpecConfig.instance.compressor_options)
-      .merge(SpecConfig.instance.retry_writes_options).merge(SpecConfig.instance.auth_options)
-      .merge(monitoring_io: false)
+    Mongo::Utils.shallow_symbolize_keys(Mongo::Client.canonicalize_ruby_options(
+      SpecConfig.instance.all_test_options,
+    )).update(monitoring_io: false).tap do |options|
+      # We have a wait queue timeout set in the test suite options, but having
+      # this option set interferes with assertions in the cmap spec tests.
+      options.delete(:wait_queue_timeout)
+    end
   end
 
   CMAP_TESTS.each do |file|

data/spec/spec_tests/data/change_streams/change-streams-errors.yml

@@ -12,7 +12,6 @@ tests:
     changeStreamPipeline: []
     changeStreamOptions: {}
     operations: []
-    # https://jira.mongodb.org/browse/SPEC-1462
     expectations: ~
     result:
       error:

data/spec/spec_tests/data/change_streams/change-streams.yml

@@ -58,7 +58,6 @@ tests:
         arguments:
           document:
             x: 1
-    # https://jira.mongodb.org/browse/SPEC-1462
     expectations: ~
     result:
       success:

data/spec/spec_tests/data/cmap/pool-checkout-connection.yml

@@ -6,10 +6,14 @@ operations:
 events:
   - type: ConnectionCheckOutStarted
     address: 42
+  - type: ConnectionCreated
+    connectionId: 1
+    address: 42
+  - type: ConnectionReady
+    connectionId: 1
+    address: 42
   - type: ConnectionCheckedOut
     connectionId: 1
     address: 42
 ignore:
   - ConnectionPoolCreated
-  - ConnectionCreated
-  - ConnectionReady

data/spec/spec_tests/data/cmap/pool-create-min-size.yml

@@ -7,6 +7,9 @@ operations:
   - name: waitForEvent
     event: ConnectionCreated
     count: 3
+  - name: waitForEvent
+    event: ConnectionReady
+    count: 3
   - name: checkOut
 events:
   - type: ConnectionPoolCreated

data/spec/spec_tests/data/connection_string/valid-warnings.yml

@@ -49,3 +49,27 @@ tests:
         auth: ~
         options:
             wtimeoutms: 10
+    -
+        description: "Empty integer option values are ignored"
+        uri: "mongodb://localhost/?maxIdleTimeMS="
+        valid: true
+        warning: true
+        hosts:
+            -
+                type: "hostname"
+                host: "localhost"
+                port: ~
+        auth: ~
+        options: ~
+    -
+        description: "Empty boolean option value are ignored"
+        uri: "mongodb://localhost/?journal="
+        valid: true
+        warning: true
+        hosts:
+            -
+                type: "hostname"
+                host: "localhost"
+                port: ~
+        auth: ~
+        options: ~

data/spec/spec_tests/data/sdam_monitoring/discovered_standalone.yml

@@ -1,7 +1,5 @@
-# This is a Ruby driver-specific test because other drivers
-# do not allow discovering a standalone topology.
 description: "Monitoring a discovered standalone connection"
-uri: "mongodb://a:27017"
+uri: "mongodb://a:27017/?directConnection=false"
 phases:
   -
     responses:

data/spec/spec_tests/data/sdam_monitoring/standalone.yml

@@ -1,5 +1,5 @@
-description: "Monitoring a forced standalone connection"
-uri: "mongodb://a:27017/?connect=direct"
+description: "Monitoring a direct connection"
+uri: "mongodb://a:27017/?directConnection=true"
 phases:
   -
     responses:

data/spec/spec_tests/data/sdam_monitoring/standalone_repeated.yml

@@ -1,5 +1,5 @@
-description: "Monitoring a forced standalone connection with repeated ismaster response"
-uri: "mongodb://a:27017/?connect=direct"
+description: "Monitoring a direct connection with repeated ismaster response"
+uri: "mongodb://a:27017/?directConnection=true"
 phases:
   # phase 1
   - responses: []

data/spec/spec_tests/data/sdam_monitoring/standalone_suppress_equal_description_changes.yml

@@ -1,5 +1,5 @@
-description: "Monitoring a forced standalone connection - suppress update events for equal server descriptions"
-uri: "mongodb://a:27017/?connect=direct"
+description: "Monitoring a direct connection - suppress update events for equal server descriptions"
+uri: "mongodb://a:27017/?directConnection=true"
 phases:
   -
     responses:

data/spec/spec_tests/data/sdam_monitoring/standalone_to_rs_with_me_mismatch.yml

@@ -1,5 +1,5 @@
-description: "Standalone connection to a replica set node with a me mismatch"
-uri: "mongodb://a/?connect=direct"
+description: "Direct connection to a replica set node with a me mismatch"
+uri: "mongodb://a/?directConnection=true"
 phases: 
   -
     responses: []