mongo 2.13.0.beta1 → 2.14.0

data/spec/mongo/session_spec.rb

@@ -307,4 +307,39 @@ describe Mongo::Session do
       end
     end
   end
+
+  describe '#start_session' do
+    context 'when block doesn\'t raise an error' do 
+      it 'closes the session after the block' do 
+        block_session = nil
+        authorized_client.start_session do |session| 
+          expect(session.ended?).to be false
+          block_session = session 
+        end
+        expect(block_session.ended?).to be true
+      end
+    end
+
+    context 'when block raises an error' do
+      it 'closes the session after the block' do
+        block_session = nil
+        expect do 
+          authorized_client.start_session do |session|
+            block_session = session
+            raise 'This is an error!'
+          end
+        end.to raise_error(StandardError, 'This is an error!')
+        expect(block_session.ended?).to be true
+      end
+    end
+
+    context 'when block returns value' do
+      it 'is returned by the function' do
+        res = authorized_client.start_session do |session| 
+          4
+        end
+        expect(res).to be 4
+      end
+    end
+  end
 end

data/spec/mongo/socket/ssl_spec.rb

@@ -246,7 +246,7 @@ describe Mongo::Socket::SSL, retry: 3 do
         it 'raises an error' do
           lambda do
             socket
-          end.should raise_error(Mongo::Error::SocketError, /SSL handshake failed due to a hostname mismatch/)
+          end.should raise_error(Mongo::Error::SocketError, /TLS handshake failed due to a hostname mismatch/)
         end
       end
 
@@ -338,7 +338,7 @@ describe Mongo::Socket::SSL, retry: 3 do
       end
 
       context 'mri' do
-        only_mri
+        require_mri
 
         context 'when a bad certificate is provided' do
 
@@ -625,7 +625,7 @@ describe Mongo::Socket::SSL, retry: 3 do
         context 'bundled with intermediate cert' do
 
           # https://github.com/jruby/jruby-openssl/issues/181
-          only_mri
+          require_mri
 
           let(:ssl_options) do
             SpecConfig.instance.test_options.merge(
@@ -670,7 +670,7 @@ describe Mongo::Socket::SSL, retry: 3 do
         context 'bundled with intermediate cert' do
 
           # https://github.com/jruby/jruby-openssl/issues/181
-          only_mri
+          require_mri
 
           let(:ssl_options) do
             SpecConfig.instance.test_options.merge(

data/spec/mongo/socket_spec.rb

@@ -48,7 +48,7 @@ describe Mongo::Socket do
         socket.send(:map_exceptions) do
           raise OpenSSL::SSL::SSLError.new('Test error')
         end
-      end.to raise_error(Mongo::Error::SocketError, 'OpenSSL::SSL::SSLError: Test error (for fake-address) (MongoDB may not be configured with SSL support)')
+      end.to raise_error(Mongo::Error::SocketError, 'OpenSSL::SSL::SSLError: Test error (for fake-address) (MongoDB may not be configured with TLS support)')
     end
   end
 

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

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