mongo 2.12.4 → 2.14.0.rc1

data/spec/mongo/uri/srv_protocol_spec.rb

@@ -567,8 +567,8 @@ describe Mongo::URI::SRVProtocol do
               'readPreference=secondary&maxStalenessSeconds=89'
             end
 
-            it 'does not raise an exception until the read preference is used' do
-              expect(client.read_preference).to eq(BSON::Document.new(mode: :secondary, max_staleness: 89))
+            it 'does not raise an exception and is omitted' do
+              expect(client.read_preference).to eq(BSON::Document.new(mode: :secondary))
             end
           end
         end
@@ -715,83 +715,114 @@ describe Mongo::URI::SRVProtocol do
         end
       end
 
+      # This context exactly duplicates the same one in uri_spec.rb
       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
-            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
-            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
-            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
-            expect(client.options[:auth_mech_properties]).to eq(expected)
-          end
+          include_examples 'sets options in the expected manner'
         end
       end
 

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

@@ -275,10 +275,10 @@ describe Mongo::URI do
 
     context 'equal sign in option value' do
 
-      let(:string) { 'mongodb://example.com/?w=a=b' }
+      let(:string) { 'mongodb://example.com/?authmechanismproperties=foo:a=b&appname=test' }
 
-      it 'raises an error' do
-        expect { uri }.to raise_error(Mongo::Error::InvalidURI, %r,Value for option w contains the key/value delimiter \(=\): a=b,)
+      it 'is allowed' do
+        expect(uri.uri_options[:auth_mech_properties]).to eq('foo' => 'a=b')
       end
     end
 
@@ -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
@@ -819,13 +819,13 @@ describe Mongo::URI do
 
         let(:mechanism) { 'GSSAPI' }
         let(:expected) { :gssapi }
+        let(:client) { new_local_client_nmio(string) }
 
         it 'sets the auth mechanism to :gssapi' do
           expect(uri.uri_options[:auth_mech]).to eq(expected)
         end
 
         it 'sets the options on a client created with the uri' do
-          client = new_local_client_nmio(string)
           expect(client.options[:auth_mech]).to eq(expected)
         end
 
@@ -839,7 +839,7 @@ describe Mongo::URI do
 
           it 'does not allow a client to be created' do
             expect {
-              new_local_client_nmio(string)
+              client
             }.to raise_error(Mongo::Auth::InvalidConfiguration, /invalid auth source/)
           end
         end
@@ -848,9 +848,24 @@ describe Mongo::URI do
           let(:options) { "authMechanism=#{mechanism}&authMechanismProperties=SERVICE_NAME:other,CANONICALIZE_HOST_NAME:true" }
 
           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({ 'canonicalize_host_name' => true, 'service_name' => 'other' })
           end
+
+          context 'when a mapping value is missing' do
+            let(:options) { "authMechanism=#{mechanism}&authMechanismProperties=SERVICE_NAME:,CANONICALIZE_HOST_NAME:" }
+
+            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 'only sets the present value' do
+              expect(client.options[:auth_mech_properties]).to eq({ 'service_name' => 'foo' })
+            end
+          end
         end
       end
 
@@ -998,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