mongo 2.11.2 → 2.13.0.beta1

data/spec/mongo/server/app_metadata_spec.rb

@@ -1,4 +1,5 @@
 require 'spec_helper'
+require_relative './app_metadata_shared'
 
 describe Mongo::Server::AppMetadata do
 
@@ -125,14 +126,20 @@ describe Mongo::Server::AppMetadata do
   end
 
   describe '#document' do
+    let(:document) do
+      app_metadata.send(:document)
+    end
+
     context 'when user is given and auth_mech is not given' do
       let(:app_metadata) do
         described_class.new(user: 'foo')
       end
 
       it 'includes saslSupportedMechs' do
-        expect(app_metadata.send(:document)[:saslSupportedMechs]).to eq('admin.foo')
+        expect(document[:saslSupportedMechs]).to eq('admin.foo')
       end
     end
+
+    it_behaves_like 'app metadata document'
   end
 end

data/spec/mongo/server/connection_auth_spec.rb

@@ -46,7 +46,7 @@ describe Mongo::Server::Connection, retry: 3 do
   end
 
   describe '#auth_mechanism' do
-    require_no_x509_auth
+    require_no_external_user
 
     let(:connection) do
       described_class.new(server, server.options)
@@ -82,13 +82,20 @@ describe Mongo::Server::Connection, retry: 3 do
       end
 
       it 'uses scram256' do
-        connection.connect!
-        expect(connection.send(:default_mechanism)).to eq(:scram256)
+        connection
+        RSpec::Mocks.with_temporary_scope do
+          pending_conn = nil
+          Mongo::Server::PendingConnection.should receive(:new).and_wrap_original do |m, *args|
+            pending_conn = m.call(*args)
+          end
+          connection.connect!
+          expect(pending_conn.send(:default_mechanism)).to eq(:scram256)
+        end
       end
     end
 
     context 'when the ismaster response indicates the auth mechanism is :scram' do
-      require_no_x509_auth
+      require_no_external_user
 
       let(:features) do
         Mongo::Server::Description::Features.new(0..7)
@@ -96,10 +103,16 @@ describe Mongo::Server::Connection, retry: 3 do
 
       it 'uses scram' do
         connection
-        # the second Features instantiation is for SDAM event publication
-        expect(Mongo::Server::Description::Features).to receive(:new).twice.and_return(features)
-        connection.connect!
-        expect(connection.send(:default_mechanism)).to eq(:scram)
+        RSpec::Mocks.with_temporary_scope do
+          expect(Mongo::Server::Description::Features).to receive(:new).and_return(features)
+
+          pending_conn = nil
+          Mongo::Server::PendingConnection.should receive(:new).and_wrap_original do |m, *args|
+            pending_conn = m.call(*args)
+          end
+          connection.connect!
+          expect(pending_conn.send(:default_mechanism)).to eq(:scram)
+        end
       end
     end
 
@@ -110,10 +123,16 @@ describe Mongo::Server::Connection, retry: 3 do
 
       it 'uses mongodb_cr' do
         connection
-        # the second Features instantiation is for SDAM event publication
-        expect(Mongo::Server::Description::Features).to receive(:new).twice.and_return(features)
-        connection.connect!
-        expect(connection.send(:default_mechanism)).to eq(:mongodb_cr)
+        RSpec::Mocks.with_temporary_scope do
+          expect(Mongo::Server::Description::Features).to receive(:new).and_return(features)
+
+          pending_conn = nil
+          Mongo::Server::PendingConnection.should receive(:new).and_wrap_original do |m, *args|
+            pending_conn = m.call(*args)
+          end
+          connection.connect!
+          expect(pending_conn.send(:default_mechanism)).to eq(:mongodb_cr)
+        end
       end
     end
   end

data/spec/mongo/server/connection_pool_spec.rb

@@ -487,7 +487,7 @@ describe Mongo::Server::ConnectionPool do
           expect {
             pool.check_out
             pool.check_out
-          }.to raise_error(Timeout::Error)
+          }.to raise_error(::Timeout::Error)
           expect(pool.size).to eq(1)
         end
       end
@@ -735,37 +735,6 @@ describe Mongo::Server::ConnectionPool do
     end
   end
 
-  context 'when the connection does not finish authenticating before the thread is killed' do
-    let!(:pool) do
-      server.pool
-    end
-
-    let(:options) do
-      { min_pool_size:0, max_pool_size: 1 }
-    end
-
-    before do
-      pool
-      ClientRegistry.instance.close_all_clients
-    end
-
-    it 'creates a new connection' do
-      t = Thread.new do
-        expect {
-          pool.with_connection do |c|
-            expect(c).to receive(:connect!).and_raise(Mongo::Error)
-            c.send(:ensure_connected) { |socket| socket}
-          end
-        }.to raise_error(Mongo::Error)
-        expect(pool.size).to be(0)
-      end
-      t.join
-
-      expect(pool.check_out).to be_a(Mongo::Server::Connection)
-      expect(pool.size).to be(1)
-    end
-  end
-
   describe '#close_idle_sockets' do
     let!(:pool) do
       server.pool

data/spec/mongo/server/connection_spec.rb

@@ -1,12 +1,10 @@
 require 'spec_helper'
 
 # fails intermittently in evergreen
-describe Mongo::Server::Connection, retry: 3 do
+describe Mongo::Server::Connection do
   class ConnectionSpecTestException < Exception; end
 
-  before(:all) do
-    ClientRegistry.instance.close_all_clients
-  end
+  clean_slate_for_all
 
   let!(:address) do
     default_address
@@ -115,34 +113,74 @@ describe Mongo::Server::Connection, retry: 3 do
           expect(connection.send(:socket)).to be nil
         end
 
-        it 'attempts to reconnect after failure when asked' do
-          # for some reason referencing error here instead of
-          # copy pasting it like this doesn't work
-          expect(connection).to receive(:authenticate!).and_raise(exception)
-          expect do
-            connection.connect!
-          end.to raise_error(exception)
+        context 'when connection fails' do
+          let(:description) do
+            double('description').tap do |description|
+              allow(description).to receive(:arbiter?).and_return(false)
+            end
+          end
 
-          expect(connection).to receive(:authenticate!).and_raise(ConnectionSpecTestException)
-          expect do
-            connection.connect!
-          end.to raise_error(ConnectionSpecTestException)
+          let(:first_pending_connection) do
+            double('pending connection 1').tap do |conn|
+              conn.should receive(:handshake_and_authenticate!).and_raise(exception)
+            end
+          end
+
+          let(:second_pending_connection) do
+            double('pending connection 2').tap do |conn|
+              conn.should receive(:handshake_and_authenticate!).and_raise(ConnectionSpecTestException)
+            end
+          end
+
+          it 'attempts to reconnect if asked to connect again' do
+            RSpec::Mocks.with_temporary_scope do
+              Mongo::Server::PendingConnection.should receive(:new).ordered.and_return(first_pending_connection)
+              Mongo::Server::PendingConnection.should receive(:new).ordered.and_return(second_pending_connection)
+
+              expect do
+                connection.connect!
+              end.to raise_error(exception)
+
+              expect do
+                connection.connect!
+              end.to raise_error(ConnectionSpecTestException)
+            end
+          end
         end
       end
 
-      shared_examples_for 'logs a warning' do
-        let(:expected_message) do
-          "MONGODB | Failed to handshake with #{address}: #{error.class}: #{error}"
+      shared_examples_for 'failing connection with server diagnostics' do
+        it_behaves_like 'failing connection'
+
+        it 'adds server diagnostics' do
+          error.message.should =~ /on #{connection.address}/
         end
+      end
 
+      shared_examples_for 'logs a warning' do
         it 'logs a warning' do
           messages = []
-          # Straightforward expectations are not working here for some reason
           expect(Mongo::Logger.logger).to receive(:warn) do |msg|
             messages << msg
           end
+
+          expect(error).not_to be nil
+
+          messages.any? { |msg| msg.include?(expected_message) }.should be true
+        end
+
+      end
+
+      shared_examples_for 'adds server diagnostics' do
+        it 'adds server diagnostics' do
+          messages = []
+          expect(Mongo::Logger.logger).to receive(:warn) do |msg|
+            messages << msg
+          end
+
           expect(error).not_to be nil
-          expect(messages).to include(expected_message)
+
+          messages.any? { |msg| msg =~ /on #{connection.address}/ }.should be true
         end
 
       end
@@ -154,7 +192,8 @@ describe Mongo::Server::Connection, retry: 3 do
         end
 
         let(:error) do
-          expect_any_instance_of(Mongo::Socket).to receive(:write).and_raise(exception)
+          # The exception is mutated when notes are added to it
+          expect_any_instance_of(Mongo::Socket).to receive(:write).and_raise(exception.dup)
           begin
             connection.connect!
           rescue Exception => e
@@ -164,8 +203,18 @@ describe Mongo::Server::Connection, retry: 3 do
           end
         end
 
+        let(:expected_message) do
+          "MONGODB | Failed to handshake with #{address}: #{error.class}: #{error}"
+        end
+
+        # The server diagnostics only apply to network exceptions.
+        # If non-network exceptions can be legitimately raised during
+        # handshake, and it makes sense to indicate which server the
+        # corresponding request was sent to, we should apply server
+        # diagnostics to non-network errors also.
         it_behaves_like 'failing connection'
         it_behaves_like 'keeps server type and topology'
+        it_behaves_like 'logs a warning'
       end
 
       context 'when #handshake! dependency raises a network exception' do
@@ -174,7 +223,8 @@ describe Mongo::Server::Connection, retry: 3 do
         end
 
         let(:error) do
-          expect_any_instance_of(Mongo::Socket).to receive(:write).and_raise(exception)
+          # The exception is mutated when notes are added to it
+          expect_any_instance_of(Mongo::Socket).to receive(:write).and_raise(exception.dup)
           begin
             connection.connect!
           rescue Exception => e
@@ -184,9 +234,14 @@ describe Mongo::Server::Connection, retry: 3 do
           end
         end
 
-        it_behaves_like 'failing connection'
+        let(:expected_message) do
+          "MONGODB | Failed to handshake with #{address}: #{error.class}: #{error}"
+        end
+
+        it_behaves_like 'failing connection with server diagnostics'
         it_behaves_like 'marks server unknown'
         it_behaves_like 'logs a warning'
+        it_behaves_like 'adds server diagnostics'
       end
 
       context 'when #authenticate! raises an exception' do
@@ -202,7 +257,10 @@ describe Mongo::Server::Connection, retry: 3 do
         end
 
         let(:error) do
-          expect(Mongo::Auth).to receive(:get).and_raise(exception)
+          # Speculative auth - would be reported as handshake failure
+          expect(Mongo::Auth).to receive(:get).ordered.and_call_original
+          # The actual authentication call
+          expect(Mongo::Auth).to receive(:get).ordered.and_raise(exception)
           expect(connection.send(:socket)).to be nil
           begin
             connection.connect!
@@ -213,6 +271,10 @@ describe Mongo::Server::Connection, retry: 3 do
           end
         end
 
+        let(:expected_message) do
+          "MONGODB | Failed to authenticate to #{address}: #{error.class}: #{error}"
+        end
+
         it_behaves_like 'failing connection'
         it_behaves_like 'logs a warning'
       end
@@ -223,7 +285,7 @@ describe Mongo::Server::Connection, retry: 3 do
         end
 
         let(:error) do
-          expect(connection).to receive(:authenticate!).and_raise(exception)
+          expect_any_instance_of(Mongo::Server::PendingConnection).to receive(:authenticate!).and_raise(exception)
           begin
             connection.connect!
           rescue Exception => e
@@ -282,14 +344,14 @@ describe Mongo::Server::Connection, retry: 3 do
 
     let(:auth_mechanism) do
       if ClusterConfig.instance.server_version >= '3'
-        Mongo::Auth::SCRAM
+        Mongo::Auth::Scram
       else
         Mongo::Auth::CR
       end
     end
 
     context 'when user credentials exist' do
-      require_no_x509_auth
+      require_no_external_user
 
       let(:server) { monitored_server }
 
@@ -527,11 +589,13 @@ describe Mongo::Server::Connection, retry: 3 do
         server,
         SpecConfig.instance.test_options.merge(
           :database => SpecConfig.instance.test_user.database,
-        ).merge(SpecConfig.instance.credentials_or_x509(
+        ).merge(SpecConfig.instance.credentials_or_external_user(
           user: SpecConfig.instance.test_user.name,
           password: SpecConfig.instance.test_user.password,
         ))
-      )
+      ).tap do |connection|
+        connection.connect!
+      end
     end
 
     let(:documents) do
@@ -623,34 +687,22 @@ describe Mongo::Server::Connection, retry: 3 do
           /Got response for request ID \d+ but expected response for request ID \d+/)
       end
 
-      context 'linting' do
-        require_linting
-
-        it 'marks the connection no longer usable' do
-          expect {
-            connection.dispatch([ query_alice ])
-          }.to raise_error(Mongo::Error::UnexpectedResponse)
+      it 'marks connection perished' do
+        expect {
+          connection.dispatch([ query_alice ])
+        }.to raise_error(Mongo::Error::UnexpectedResponse)
 
-          expect do
-            connection.dispatch([ query_alice ]).documents
-          end.to raise_error(Mongo::Error::LintError, /Reconnecting closed connections is no longer supported.*/)
-        end
+        connection.should be_error
       end
 
-      context 'not linting' do
-        skip_if_linting
-
-        it 'does not affect subsequent requests but warns' do
-          expect(Mongo::Logger.logger).to receive(:warn).once.and_call_original
-
-          expect {
-            connection.dispatch([ query_alice ])
-          }.to raise_error(Mongo::Error::UnexpectedResponse)
+      it 'makes the connection no longer usable' do
+        expect {
+          connection.dispatch([ query_alice ])
+        }.to raise_error(Mongo::Error::UnexpectedResponse)
 
-          docs = connection.dispatch([ query_alice ]).documents
-          expect(docs).to_not be_empty
-          expect(docs.first['name']).to eq('alice')
-        end
+        expect {
+          connection.dispatch([ query_alice ])
+        }.to raise_error(Mongo::Error::ConnectionPerished)
       end
     end
 
@@ -713,9 +765,15 @@ describe Mongo::Server::Connection, retry: 3 do
       end
 
       context 'when the message is a command' do
+        # Server description is frozen when linting is enabled, which is
+        # incompatible with expectations set on it in this test
+        skip_if_linting
 
         let(:selector) do
-          { :getlasterror => '1' }
+          # The driver allows up to 16KiB for command overhead on top of
+          # the max bson object size reported by the server.
+          # Add that much padding.
+          { :getlasterror => '1', 'padding' => 'x'*16384 }
         end
 
         let(:command) do
@@ -729,7 +787,8 @@ describe Mongo::Server::Connection, retry: 3 do
         it 'checks the size against the max bson size' do
           # 100 works for non-x509 auth.
           # 10 is needed for x509 auth due to smaller payloads, apparently.
-          expect_any_instance_of(Mongo::Server).to receive(:max_bson_object_size).at_least(:once).and_return(10)
+          expect_any_instance_of(Mongo::Server::Description).to receive(
+            :max_bson_object_size).at_least(:once).and_return(10)
           expect do
             reply
           end.to raise_exception(Mongo::Error::MaxBSONSize)
@@ -766,9 +825,9 @@ describe Mongo::Server::Connection, retry: 3 do
           end.to raise_error(Mongo::Error::SocketError)
         end
 
-        it 'disconnects and raises the exception' do
+        it 'marks connection perished' do
           result
-          expect(connection).to_not be_connected
+          expect(connection).to be_error
         end
 
         it 'disconnects connection pool' do
@@ -800,9 +859,9 @@ describe Mongo::Server::Connection, retry: 3 do
           end.to raise_error(Mongo::Error::SocketTimeoutError)
         end
 
-        it 'disconnects the used connection' do
+        it 'marks connection perished' do
           result
-          expect(connection).to_not be_connected
+          expect(connection).to be_error
         end
 
 =begin These assertions require a working cluster with working SDAM flow, which the tests do not configure
@@ -861,7 +920,9 @@ describe Mongo::Server::Connection, retry: 3 do
       context 'when the socket_timeout is negative' do
 
         let(:connection) do
-          described_class.new(server, server.options)
+          described_class.new(server, server.options).tap do |connection|
+            connection.connect!
+          end
         end
 
         let(:message) do
@@ -870,7 +931,7 @@ describe Mongo::Server::Connection, retry: 3 do
 
         before do
           expect(message).to receive(:replyable?) { false }
-          connection.send(:deliver, message)
+          connection.send(:deliver, message, nil)
 
           connection.send(:socket).instance_variable_set(:@timeout, -(Time.now.to_i))
         end
@@ -888,6 +949,7 @@ describe Mongo::Server::Connection, retry: 3 do
       end
     end
 
+=begin this is now handled by connection pool
     context 'when the process is forked' do
 
       let(:insert) do
@@ -906,9 +968,10 @@ describe Mongo::Server::Connection, retry: 3 do
 
       it 'sets a new pid' do
         connection.dispatch([ insert ])
-        expect(connection.pid).to eq(1)
+        expect(connection.send(:pid)).to eq(1)
       end
     end
+=end
   end
 
   describe '#initialize' do
@@ -957,8 +1020,14 @@ describe Mongo::Server::Connection, retry: 3 do
         expect(connection.send(:socket)).to be_nil
       end
 
-      it 'does not set the timeout to the default' do
-        expect(connection.timeout).to be_nil
+      context 'when timeout is not set in client options' do
+        let(:server_options) do
+          SpecConfig.instance.test_options.merge(monitoring_io: false, socket_timeout: nil)
+        end
+
+        it 'does not set the timeout to the default' do
+          expect(connection.timeout).to be_nil
+        end
       end
     end
 
@@ -1001,7 +1070,7 @@ describe Mongo::Server::Connection, retry: 3 do
         end
 
         it 'does not set the ssl options' do
-          expect(connection.send(:ssl_options)).to be_empty
+          expect(connection.send(:ssl_options)).to eq(ssl: false)
         end
       end
 
@@ -1016,13 +1085,13 @@ describe Mongo::Server::Connection, retry: 3 do
         end
 
         it 'does not set the ssl options' do
-          expect(connection.send(:ssl_options)).to be_empty
+          expect(connection.send(:ssl_options)).to eq(ssl: false)
         end
       end
     end
 
     context 'when authentication options are provided' do
-      require_no_x509_auth
+      require_no_external_user
 
       let(:connection) do
         described_class.new(
@@ -1079,7 +1148,7 @@ describe Mongo::Server::Connection, retry: 3 do
         end
 
         it 'uses the connect_timeout for the address' do
-          expect(connection.address.send(:connect_timeout)).to eq(3)
+          expect(connection.address.options[:connect_timeout]).to eq(3)
         end
 
         it 'uses the socket_timeout as the socket_timeout' do
@@ -1098,7 +1167,7 @@ describe Mongo::Server::Connection, retry: 3 do
         end
 
         it 'uses the connect_timeout for the address' do
-          expect(connection.address.send(:connect_timeout)).to eq(3)
+          expect(connection.address.options[:connect_timeout]).to eq(3)
         end
 
         it 'does not use a socket_timeout' do
@@ -1119,8 +1188,8 @@ describe Mongo::Server::Connection, retry: 3 do
           connection.connect!
         end
 
-        it 'uses the default connect_timeout for the address' do
-          expect(connection.address.send(:connect_timeout)).to eq(10)
+        it 'does not specify connect_timeout for the address' do
+          expect(connection.address.options[:connect_timeout]).to be nil
         end
 
         it 'uses the socket_timeout' do
@@ -1138,8 +1207,8 @@ describe Mongo::Server::Connection, retry: 3 do
           connection.connect!
         end
 
-        it 'uses the default connect_timeout for the address' do
-          expect(connection.address.send(:connect_timeout)).to eq(10)
+        it 'does not specify connect_timeout for the address' do
+          expect(connection.address.options[:connect_timeout]).to be nil
         end
 
         it 'does not use a socket_timeout' do
@@ -1173,7 +1242,7 @@ describe Mongo::Server::Connection, retry: 3 do
     end
 
     context 'when auth options differ from server' do
-      require_no_x509_auth
+      require_no_external_user
 
       let(:connection) do
         described_class.new(server, server.options.merge(user: 'foo'))