mongo 2.10.5 → 2.15.1

data/spec/mongo/server/connection_spec.rb

@@ -1,12 +1,13 @@
+# frozen_string_literal: true
+# encoding: utf-8
+
 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
@@ -31,9 +32,7 @@ describe Mongo::Server::Connection, retry: 3 do
       allow(cl).to receive(:options).and_return({})
       allow(cl).to receive(:cluster_time).and_return(nil)
       allow(cl).to receive(:update_cluster_time)
-      pool = double('pool')
-      allow(pool).to receive(:disconnect!)
-      allow(cl).to receive(:pool).and_return(pool)
+      allow(cl).to receive(:run_sdam_flow)
     end
   end
 
@@ -41,31 +40,31 @@ describe Mongo::Server::Connection, retry: 3 do
 
   let(:server_options) { SpecConfig.instance.test_options.merge(monitoring_io: false) }
   let(:server) do
-    Mongo::Server.new(address, cluster, monitoring, listeners, server_options)
+    register_server(
+      Mongo::Server.new(address, cluster, monitoring, listeners, server_options)
+    )
   end
 
   let(:monitored_server) do
-    Mongo::Server.new(address, cluster, monitoring, listeners,
-      SpecConfig.instance.test_options
-    ).tap do |server|
-      server.scan!
-      expect(server).not_to be_unknown
-    end
+    register_server(
+      Mongo::Server.new(address, cluster, monitoring, listeners,
+        SpecConfig.instance.test_options.merge(monitoring_io: false)
+      ).tap do |server|
+        allow(server).to receive(:description).and_return(ClusterConfig.instance.primary_description)
+        expect(server).not_to be_unknown
+      end
+    )
   end
 
   let(:pool) do
-    double('pool')
+    double('pool').tap do |pool|
+      allow(pool).to receive(:close)
+    end
   end
 
   describe '#connect!' do
 
     shared_examples_for 'keeps server type and topology' do
-      before do
-        # we want the server to not start in unknown state,
-        # hence scan it and transition to some other state here
-        server.scan!
-      end
-
       it 'does not mark server unknown' do
         expect(server).not_to receive(:unknown!)
         error
@@ -73,12 +72,6 @@ describe Mongo::Server::Connection, retry: 3 do
     end
 
     shared_examples_for 'marks server unknown' do
-      before do
-        # we want the server to not start in unknown state,
-        # hence scan it and transition to some other state here
-        server.scan!
-      end
-
       it 'marks server unknown' do
         expect(server).to receive(:unknown!)
         error
@@ -123,34 +116,78 @@ 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
+        require_warning_clean
 
         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
+        require_warning_clean
+
+        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
@@ -162,7 +199,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
@@ -172,8 +210,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
@@ -182,7 +230,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
@@ -192,17 +241,23 @@ 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
         require_auth
 
         let(:server_options) do
-          SpecConfig.instance.test_options.merge(monitoring_io: false).
-            merge(SpecConfig.instance.auth_options)
+          Mongo::Client.canonicalize_ruby_options(
+            SpecConfig.instance.all_test_options,
+          ).update(monitoring_io: false)
         end
 
         let(:exception) do
@@ -210,7 +265,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!
@@ -221,6 +279,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
@@ -231,7 +293,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
@@ -281,7 +343,7 @@ describe Mongo::Server::Connection, retry: 3 do
 
     shared_examples_for 'disconnects connection pool' do
       it 'disconnects non-monitoring sockets' do
-        expect(server).to receive(:pool).and_return(pool)
+        expect(server).to receive(:pool).at_least(:once).and_return(pool)
         expect(pool).to receive(:disconnect!).and_return(true)
         error
       end
@@ -290,13 +352,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_external_user
 
       let(:server) { monitored_server }
 
@@ -426,6 +489,73 @@ describe Mongo::Server::Connection, retry: 3 do
       end
     end
 
+    context 'connecting to arbiter' do
+      require_topology :replica_set
+
+      before(:all) do
+        unless ENV['HAVE_ARBITER']
+          skip 'Test requires an arbiter in the deployment'
+        end
+      end
+
+      let(:arbiter_server) do
+        authorized_client.cluster.servers_list.each do |server|
+          server.scan!
+        end
+        server = authorized_client.cluster.servers_list.detect do |server|
+          server.arbiter?
+        end.tap do |server|
+          raise 'No arbiter in the deployment' unless server
+        end
+      end
+
+      shared_examples_for 'does not authenticate' do
+        let(:client) do
+          new_local_client([address],
+            SpecConfig.instance.test_options.merge(
+              :user => 'bogus',
+              :password => 'bogus',
+              :database => 'bogus'
+            ).merge(connect: :direct),
+          )
+        end
+
+        let(:connection) do
+          described_class.new(
+            server,
+          )
+        end
+
+        let(:ping) do
+          client.database.command(ping: 1)
+        end
+
+        it 'does not authenticate' do
+          ClientRegistry.instance.close_all_clients
+
+          expect_any_instance_of(Mongo::Server::Connection).not_to receive(:authenticate!)
+
+          expect(ping.documents.first['ok']).to eq(1) rescue nil
+        end
+      end
+
+      context 'without me mismatch' do
+        let(:address) do
+          arbiter_server.address.to_s
+        end
+
+        it_behaves_like 'does not authenticate'
+      end
+
+      context 'with me mismatch' do
+        let(:address) do
+          "#{ClusterConfig.instance.alternate_address.host}:#{arbiter_server.address.port}"
+        end
+
+        it_behaves_like 'does not authenticate'
+      end
+    end
+
   end
 
   describe '#disconnect!' do
@@ -462,14 +592,22 @@ describe Mongo::Server::Connection, retry: 3 do
 
     let(:server) { monitored_server }
 
+    let(:context) { Mongo::Operation::Context.new }
+
     let!(:connection) do
       described_class.new(
         server,
         SpecConfig.instance.test_options.merge(
-          :user => SpecConfig.instance.test_user.name,
-          :password => SpecConfig.instance.test_user.password,
-          :database => SpecConfig.instance.test_user.database )
-      )
+          :database => SpecConfig.instance.test_user.database,
+        ).merge(Mongo::Utils.shallow_symbolize_keys(Mongo::Client.canonicalize_ruby_options(
+          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
@@ -487,12 +625,12 @@ describe Mongo::Server::Connection, retry: 3 do
     context 'when providing a single message' do
 
       let(:reply) do
-        connection.dispatch([ query ])
+        connection.dispatch([ query ], context)
       end
 
       before do
         authorized_collection.delete_many
-        connection.dispatch([ insert ])
+        authorized_collection.insert_one(name: 'testing')
       end
 
       it 'it dispatches the message to the socket' do
@@ -511,7 +649,7 @@ describe Mongo::Server::Connection, retry: 3 do
       end
 
       let(:reply) do
-        connection.dispatch([ insert, command ])
+        connection.dispatch([ insert, command ], context)
       end
 
       before do
@@ -548,51 +686,40 @@ describe Mongo::Server::Connection, retry: 3 do
       end
 
       before do
-        connection.dispatch([ insert ])
+        connection.dispatch([ insert ], context)
         # Fake a query for which we did not read the response. See RUBY-1117
         allow(query_bob).to receive(:replyable?) { false }
-        connection.dispatch([ query_bob ])
+        connection.dispatch([ query_bob ], context)
       end
 
       it 'raises an UnexpectedResponse error' do
         expect {
-          connection.dispatch([ query_alice ])
+          connection.dispatch([ query_alice ], context)
         }.to raise_error(Mongo::Error::UnexpectedResponse,
           /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 ], context)
+        }.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 ], context)
+        }.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 ], context)
+        }.to raise_error(Mongo::Error::ConnectionPerished)
       end
     end
 
     context 'when a request is interrupted (Thread.kill)' do
+      require_no_required_api_version
 
       let(:documents) do
         [{ 'name' => 'bob' }, { 'name' => 'alice' }]
@@ -612,18 +739,19 @@ describe Mongo::Server::Connection, retry: 3 do
 
       before do
         authorized_collection.delete_many
-        connection.dispatch([ insert ])
+        connection.dispatch([ insert ], context)
       end
 
       it 'closes the socket and does not use it for subsequent requests' do
         t = Thread.new {
           # Kill the thread just before the reply is read
           allow(Mongo::Protocol::Reply).to receive(:deserialize_header) { t.kill && !t.alive? }
-          connection.dispatch([ query_bob ])
+          connection.dispatch([ query_bob ], context)
         }
         t.join
         allow(Mongo::Protocol::Message).to receive(:deserialize_header).and_call_original
-        expect(connection.dispatch([ query_alice ]).documents.first['name']).to eq('alice')
+        resp = connection.dispatch([ query_alice ], context)
+        expect(resp.documents.first['name']).to eq('alice')
       end
     end
 
@@ -640,7 +768,7 @@ describe Mongo::Server::Connection, retry: 3 do
         end
 
         let(:reply) do
-          connection.dispatch([ insert ])
+          connection.dispatch([ insert ], context)
         end
 
         it 'checks the size against the max message size' do
@@ -651,9 +779,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
+        require_no_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
@@ -661,11 +795,14 @@ describe Mongo::Server::Connection, retry: 3 do
         end
 
         let(:reply) do
-          connection.dispatch([ command ])
+          connection.dispatch([ command ], context)
         end
 
         it 'checks the size against the max bson size' do
-          expect_any_instance_of(Mongo::Server).to receive(:max_bson_object_size).at_least(:once).and_return(100)
+          # 100 works for non-x509 auth.
+          # 10 is needed for x509 auth due to smaller payloads, apparently.
+          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)
@@ -698,23 +835,28 @@ describe Mongo::Server::Connection, retry: 3 do
 
         let(:result) do
           expect do
-            connection.dispatch([ insert ])
+            connection.dispatch([ insert ], context)
           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
-          # Allow multiple calls due to RUBY-1894 backport
-          expect(server.pool).to receive(:disconnect!).at_least(:once)
+          expect(server.pool).to receive(:disconnect!)
           result
         end
 
+        it 'marks server unknown' do
+          expect(server).not_to be_unknown
+          result
+          expect(server).to be_unknown
+        end
+
         it 'does not request server scan' do
-          expect(server.monitor.scan_semaphore).not_to receive(:signal)
+          expect(server.scan_semaphore).not_to receive(:signal)
           result
         end
 
@@ -733,13 +875,13 @@ describe Mongo::Server::Connection, retry: 3 do
 
         let(:result) do
           expect do
-            connection.dispatch([ insert ])
+            connection.dispatch([ insert ], context)
           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
@@ -777,6 +919,7 @@ describe Mongo::Server::Connection, retry: 3 do
       end
 
       before do
+        authorized_collection.insert_one(test: 1)
         client.cluster.next_primary
       end
 
@@ -790,6 +933,8 @@ describe Mongo::Server::Connection, retry: 3 do
           end_time = Time.now
           expect(ex).to be_a(Mongo::Error::SocketTimeoutError)
           expect(ex.message).to match(/Took more than 1.5 seconds to receive data/)
+        else
+          fail 'Expected a timeout'
         end
         # allow 1.5 seconds +- 0.5 seconds
         expect(end_time - start).to be_within(1).of(2)
@@ -798,7 +943,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
@@ -807,7 +954,7 @@ describe Mongo::Server::Connection, retry: 3 do
 
         before do
           expect(message).to receive(:replyable?) { false }
-          connection.send(:deliver, message)
+          connection.send(:deliver, message, context)
 
           connection.send(:socket).instance_variable_set(:@timeout, -(Time.now.to_i))
         end
@@ -825,6 +972,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
@@ -843,9 +991,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
@@ -875,7 +1024,9 @@ describe Mongo::Server::Connection, retry: 3 do
 
       context 'two pools for different servers' do
         let(:server2) do
-          Mongo::Server.new(address, cluster, monitoring, listeners, server_options)
+          register_server(
+            Mongo::Server.new(address, cluster, monitoring, listeners, server_options)
+          )
         end
 
         it 'ids do not share namespace' do
@@ -892,8 +1043,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
 
@@ -936,7 +1093,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
 
@@ -951,12 +1108,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_external_user
 
       let(:connection) do
         described_class.new(
@@ -964,7 +1122,7 @@ describe Mongo::Server::Connection, retry: 3 do
           :user => SpecConfig.instance.test_user.name,
           :password => SpecConfig.instance.test_user.password,
           :database => SpecConfig.instance.test_db,
-          :auth_mech => :mongodb_cr
+          :auth_mech => :mongodb_cr,
         )
       end
 
@@ -1000,10 +1158,6 @@ describe Mongo::Server::Connection, retry: 3 do
       described_class.new(server, server.options)
     end
 
-    after do
-      client.close(true)
-    end
-
     context 'when a connect_timeout is in the options' do
 
       context 'when a socket_timeout is in the options' do
@@ -1017,7 +1171,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
@@ -1036,7 +1190,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
@@ -1057,8 +1211,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
@@ -1076,8 +1230,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
@@ -1111,6 +1265,8 @@ describe Mongo::Server::Connection, retry: 3 do
     end
 
     context 'when auth options differ from server' do
+      require_no_external_user
+
       let(:connection) do
         described_class.new(server, server.options.merge(user: 'foo'))
       end