mongo 2.10.5 → 2.15.1

data/spec/mongo/uri_option_parsing_spec.rb

@@ -1,3 +1,6 @@
+# frozen_string_literal: true
+# encoding: utf-8
+
 require 'lite_spec_helper'
 
 describe Mongo::URI do
@@ -199,37 +202,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
@@ -242,14 +245,6 @@ describe Mongo::URI do
 
     it_behaves_like 'a string option'
 
-    context '$external' do
-      let(:string) { "mongodb://example.com/?#{uri_option}=$external" }
-
-      it 'is converted to ;external' do
-        expect(uri.uri_options[ruby_option]).to eq(:external)
-      end
-    end
-
     context 'empty' do
       let(:string) { "mongodb://example.com/?#{uri_option}=" }
 
@@ -358,8 +353,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

@@ -1,3 +1,6 @@
+# frozen_string_literal: true
+# encoding: utf-8
+
 require 'lite_spec_helper'
 
 describe Mongo::URI do
@@ -6,6 +9,40 @@ describe Mongo::URI do
 
     let(:uri) { described_class.get(string) }
 
+    describe 'invalid uris' do
+
+      context 'string is not uri' do
+
+        let(:string) { 'tyler' }
+
+        it 'raises an error' do
+          expect { uri }.to raise_error(Mongo::Error::InvalidURI)
+        end
+      end
+
+      context 'nil' do
+
+        let(:string) { nil }
+
+        it 'raises an error' do
+          expect do
+            uri
+          end.to raise_error(Mongo::Error::InvalidURI, /URI must be a string, not nil/)
+        end
+      end
+
+      context 'empty string' do
+
+        let(:string) { '' }
+
+        it 'raises an error' do
+          expect do
+            uri
+          end.to raise_error(Mongo::Error::InvalidURI, /Cannot parse an empty URI/)
+        end
+      end
+    end
+
     context 'when the scheme is mongodb://' do
 
       let(:string) do
@@ -55,12 +92,25 @@ describe Mongo::URI do
       end
     end
 
+    context 'nil' do
+
+      let(:string) { nil }
+
+      it 'raises an error' do
+        expect do
+          uri
+        end.to raise_error(Mongo::Error::InvalidURI, /URI must be a string, not nil/)
+      end
+    end
+
     context 'empty string' do
 
       let(:string) { '' }
 
       it 'raises an error' do
-        expect { uri }.to raise_error(Mongo::Error::InvalidURI)
+        expect do
+          uri
+        end.to raise_error(Mongo::Error::InvalidURI, /Cannot parse an empty URI/)
       end
     end
 
@@ -228,10 +278,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
 
@@ -680,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
@@ -703,7 +753,11 @@ describe Mongo::URI do
     end
 
     context 'auth mechanism provided' do
-      let(:options) { "authMechanism=#{mechanism}" }
+      let(:string)      { "#{scheme}#{credentials}@#{servers}/?#{options}" }
+      let(:user)        { 'tyler' }
+      let(:password)    { 's3kr4t' }
+      let(:credentials) { "#{user}:#{password}" }
+      let(:options)     { "authMechanism=#{mechanism}" }
 
       context 'plain' do
         let(:mechanism) { 'PLAIN' }
@@ -722,6 +776,16 @@ describe Mongo::URI do
           client = new_local_client_nmio(string.downcase)
           expect(client.options[:auth_mech]).to eq(expected)
         end
+
+        context 'when mechanism_properties are provided' do
+          let(:options) { "authMechanism=#{mechanism}&authMechanismProperties=CANONICALIZE_HOST_NAME:true" }
+
+          it 'does not allow a client to be created' do
+            expect {
+              new_local_client_nmio(string)
+            }.to raise_error(Mongo::Auth::InvalidConfiguration, /mechanism_properties are not supported/)
+          end
+        end
       end
 
       context 'mongodb-cr' do
@@ -741,18 +805,30 @@ describe Mongo::URI do
           client = new_local_client_nmio(string.downcase)
           expect(client.options[:auth_mech]).to eq(expected)
         end
+
+        context 'when mechanism_properties are provided' do
+          let(:options) { "authMechanism=#{mechanism}&authMechanismProperties=CANONICALIZE_HOST_NAME:true" }
+
+          it 'does not allow a client to be created' do
+            expect {
+              new_local_client_nmio(string)
+            }.to raise_error(Mongo::Auth::InvalidConfiguration, /mechanism_properties are not supported/)
+          end
+        end
       end
 
       context 'gssapi' do
+        require_mongo_kerberos
+
         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
 
@@ -760,6 +836,40 @@ describe Mongo::URI do
           client = new_local_client_nmio(string.downcase)
           expect(client.options[:auth_mech]).to eq(expected)
         end
+
+        context 'when auth source is invalid' do
+          let(:options) { "authMechanism=#{mechanism}&authSource=foo" }
+
+          it 'does not allow a client to be created' do
+            expect {
+              client
+            }.to raise_error(Mongo::Auth::InvalidConfiguration, /invalid auth source/)
+          end
+        end
+
+        context 'when mechanism_properties are provided' 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
+            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
 
       context 'scram-sha-1' do
@@ -779,11 +889,22 @@ describe Mongo::URI do
           client = new_local_client_nmio(string.downcase)
           expect(client.options[:auth_mech]).to eq(expected)
         end
+
+        context 'when mechanism_properties are provided' do
+          let(:options) { "authMechanism=#{mechanism}&authMechanismProperties=CANONICALIZE_HOST_NAME:true" }
+
+          it 'does not allow a client to be created' do
+            expect {
+              new_local_client_nmio(string)
+            }.to raise_error(Mongo::Auth::InvalidConfiguration, /mechanism_properties are not supported/)
+          end
+        end
       end
 
       context 'mongodb-x509' do
         let(:mechanism) { 'MONGODB-X509' }
-        let(:expected) { :mongodb_x509 }
+        let(:expected)  { :mongodb_x509 }
+        let(:credentials)  { user }
 
         it 'sets the auth mechanism to :mongodb_x509' do
           expect(uri.uri_options[:auth_mech]).to eq(expected)
@@ -799,7 +920,18 @@ describe Mongo::URI do
           expect(client.options[:auth_mech]).to eq(expected)
         end
 
+        context 'when auth source is invalid' do
+          let(:options) { "authMechanism=#{mechanism}&authSource=foo" }
+
+          it 'does not allow a client to be created' do
+            expect {
+              new_local_client_nmio(string)
+            }.to raise_error(Mongo::Auth::InvalidConfiguration, /invalid auth source/)
+          end
+        end
+
         context 'when a username is not provided' do
+          let(:string) { "#{scheme}#{servers}/?#{options}" }
 
           it 'recognizes the mechanism with no username' do
             client = new_local_client_nmio(string.downcase)
@@ -807,6 +939,61 @@ describe Mongo::URI do
             expect(client.options[:user]).to be_nil
           end
         end
+
+        context 'when a password is provided' do
+          let(:credentials) { "#{user}:#{password}"}
+          let(:password) { 's3kr4t' }
+
+          it 'does not allow a client to be created' do
+            expect do
+              new_local_client_nmio(string)
+            end.to raise_error(Mongo::Auth::InvalidConfiguration, /Password is not supported/)
+          end
+        end
+
+        context 'when mechanism_properties are provided' do
+          let(:options) { "authMechanism=#{mechanism}&authMechanismProperties=CANONICALIZE_HOST_NAME:true" }
+
+          it 'does not allow a client to be created' do
+            expect {
+              new_local_client_nmio(string)
+            }.to raise_error(Mongo::Auth::InvalidConfiguration, /mechanism_properties are not supported/)
+          end
+        end
+      end
+    end
+
+    context 'auth mechanism is not provided' do
+      let(:string) { "#{scheme}#{credentials}@#{servers}/" }
+
+      context 'with no credentials' do
+        let(:string) { "#{scheme}#{servers}/" }
+
+        it 'sets user and password as nil' do
+          expect(uri.credentials[:user]).to be_nil
+          expect(uri.credentials[:password]).to be_nil
+        end
+
+        it 'sets the options on a client created with the uri' do
+          client = new_local_client_nmio(string)
+          expect(client.options[:user]).to be_nil
+          expect(client.options[:password]).to be_nil
+        end
+      end
+
+      context 'with empty credentials' do
+        let(:credentials) { '' }
+
+        it 'sets user as an empty string and password as nil' do
+          expect(uri.credentials[:user]).to eq('')
+          expect(uri.credentials[:password]).to be_nil
+        end
+
+        it 'does not allow a client to be created with default auth mechanism' do
+          expect do
+            new_local_client_nmio(string)
+          end.to raise_error(Mongo::Auth::InvalidConfiguration, /Empty username is not supported/)
+        end
       end
     end
 
@@ -825,103 +1012,115 @@ describe Mongo::URI do
           expect(client.options[:auth_source]).to eq(source)
         end
       end
+    end
 
-      context '$external' do
-        let(:source) { '$external' }
-        let(:expected) { :external }
+    context 'auth mechanism properties provided' do
 
-        it 'sets the auth source to :external' do
-          expect(uri.uri_options[:auth_source]).to eq(expected)
+      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 'sets the options on a client created with the uri' do
+        it 'downcases auth mechanism properties keys in client options' do
           client = new_local_client_nmio(string)
-          expect(client.options[:auth_source]).to eq(expected)
+          expect(client.options[:auth_mech_properties]).to eq(expected_client_options)
         end
       end
-    end
-
-    context 'auth mechanism properties provided' do
 
       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,4 +1,7 @@
-require 'spec_helper'
+# frozen_string_literal: true
+# encoding: utf-8
+
+require 'lite_spec_helper'
 
 describe Mongo::WriteConcern do
 
@@ -194,6 +197,18 @@ describe Mongo::WriteConcern do
           expect(wc).to be_a(Mongo::WriteConcern::Unacknowledged)
           expect(wc.options[:w]).to eq(0)
         end
+
+        context 'and j is true' do
+          let(:options) do
+            { 'w' => 0, j: true }
+          end
+
+          it 'raises an exception' do
+            expect do
+              wc
+            end.to raise_error(Mongo::Error::InvalidWriteConcern, /:j cannot be true when :w is 0/)
+          end
+        end
       end
     end