mongo 2.6.4 → 2.7.0.rc0

data/spec/mongo/server/connection_pool_spec.rb

@@ -3,7 +3,7 @@ require 'spec_helper'
 describe Mongo::Server::ConnectionPool do
 
   let(:options) do
-    TEST_OPTIONS.merge(max_pool_size: 2)
+    SpecConfig.instance.test_options.merge(max_pool_size: 2)
   end
 
   let(:address) do
@@ -18,14 +18,13 @@ describe Mongo::Server::ConnectionPool do
     Mongo::Event::Listeners.new
   end
 
-  let(:topology) do
-    double('topology')
-  end
+  declare_topology_double
 
   let(:cluster) do
     double('cluster').tap do |cl|
       allow(cl).to receive(:topology).and_return(topology)
       allow(cl).to receive(:app_metadata).and_return(app_metadata)
+      allow(cl).to receive(:options).and_return({})
     end
   end
 
@@ -222,13 +221,13 @@ describe Mongo::Server::ConnectionPool do
     end
 
     let(:options) do
-      { user: ROOT_USER.name, password: ROOT_USER.password }.merge(TEST_OPTIONS).merge(max_pool_size: 1)
+      { user: SpecConfig.instance.root_user.name, password: SpecConfig.instance.root_user.password }.merge(SpecConfig.instance.test_options).merge(max_pool_size: 1)
     end
 
     before do
      t = Thread.new {
         # Kill the thread when it's authenticating
-        allow(Mongo::Auth).to receive(:get) { t.kill and t.stop? }
+        allow(Mongo::Auth).to receive(:get) { t.kill && !t.alive? }
         pool.with_connection { |c| c.send(:ensure_connected) { |socket| socket } }
       }
       t.join
@@ -256,7 +255,7 @@ describe Mongo::Server::ConnectionPool do
     context 'when there is a max_idle_time specified' do
 
       let(:options) do
-        TEST_OPTIONS.merge(max_pool_size: 2, max_idle_time: 0.5)
+        SpecConfig.instance.test_options.merge(max_pool_size: 2, max_idle_time: 0.5)
       end
 
       context 'when the connections have not been checked out' do
@@ -279,7 +278,7 @@ describe Mongo::Server::ConnectionPool do
         context 'when min size is 0' do
 
           let(:options) do
-            TEST_OPTIONS.merge(max_pool_size: 2, min_pool_size: 0, max_idle_time: 0.5)
+            SpecConfig.instance.test_options.merge(max_pool_size: 2, min_pool_size: 0, max_idle_time: 0.5)
           end
 
           before do
@@ -302,7 +301,7 @@ describe Mongo::Server::ConnectionPool do
           context 'when more than the number of min_size are checked out' do
 
             let(:options) do
-              TEST_OPTIONS.merge(max_pool_size: 5, min_pool_size: 3, max_idle_time: 0.5)
+              SpecConfig.instance.test_options.merge(max_pool_size: 5, min_pool_size: 3, max_idle_time: 0.5)
             end
 
             before do
@@ -330,7 +329,7 @@ describe Mongo::Server::ConnectionPool do
           context 'when between 0 and min_size number of connections are checked out' do
 
             let(:options) do
-              TEST_OPTIONS.merge(max_pool_size: 5, min_pool_size: 3, max_idle_time: 0.5)
+              SpecConfig.instance.test_options.merge(max_pool_size: 5, min_pool_size: 3, max_idle_time: 0.5)
             end
 
             before do
@@ -369,7 +368,7 @@ describe Mongo::Server::ConnectionPool do
           context 'when a stale connection is unsuccessfully reconnected' do
 
             let(:options) do
-              TEST_OPTIONS.merge(max_pool_size: 5, min_pool_size: 3, max_idle_time: 0.5)
+              SpecConfig.instance.test_options.merge(max_pool_size: 5, min_pool_size: 3, max_idle_time: 0.5)
             end
 
             before do
@@ -408,7 +407,7 @@ describe Mongo::Server::ConnectionPool do
           context 'when exactly the min_size number of connections is checked out' do
 
             let(:options) do
-              TEST_OPTIONS.merge(max_pool_size: 5, min_pool_size: 3, max_idle_time: 0.5)
+              SpecConfig.instance.test_options.merge(max_pool_size: 5, min_pool_size: 3, max_idle_time: 0.5)
             end
 
             before do

data/spec/mongo/server/connection_spec.rb

@@ -1,6 +1,16 @@
 require 'spec_helper'
 
-describe Mongo::Server::Connection do
+# fails intermittently in evergreen
+describe Mongo::Server::Connection, retry: 3 do
+  class ConnectionSpecTestException < Exception; end
+
+  before(:all) do
+    ClientRegistry.instance.close_all_clients
+  end
+
+  after(:all) do
+    ClientRegistry.instance.close_all_clients
+  end
 
   let(:address) do
     default_address
@@ -15,45 +25,77 @@ describe Mongo::Server::Connection do
   end
 
   let(:app_metadata) do
-    Mongo::Cluster::AppMetadata.new(authorized_client.cluster)
+    Mongo::Server::AppMetadata.new(authorized_client.cluster.options)
   end
 
   let(:cluster) do
     double('cluster').tap do |cl|
       allow(cl).to receive(:topology).and_return(topology)
       allow(cl).to receive(:app_metadata).and_return(app_metadata)
+      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)
     end
   end
 
-  let(:topology) do
-    double('topology')
-  end
+  declare_topology_double
 
   let(:server) do
-    Mongo::Server.new(address, cluster, monitoring, listeners, TEST_OPTIONS)
+    Mongo::Server.new(address, cluster, monitoring, listeners,
+      SpecConfig.instance.test_options.merge(monitoring_io: false),
+    )
   end
 
-  let(:pool) do
-    double('pool')
+  let(:monitored_server) do
+    Mongo::Server.new(address, cluster, monitoring, listeners,
+      SpecConfig.instance.test_options
+    ).tap do |server|
+      server.scan!
+    end
   end
 
-  after do
-    allow(cluster).to receive(:pool).with(server).and_return(pool)
-    allow(pool).to receive(:disconnect!).and_return(true)
-    server.disconnect!
+  let(:pool) do
+    double('pool')
   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
+      end
+    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
+      end
+    end
+
     context 'when no socket exists' do
 
       let(:connection) do
         described_class.new(server, server.options)
       end
 
-      let!(:result) do
+      let(:result) do
         connection.connect!
       end
 
@@ -66,12 +108,118 @@ describe Mongo::Server::Connection do
       end
 
       it 'creates a socket' do
+        result
         expect(socket).to_not be_nil
       end
 
       it 'connects the socket' do
+        result
         expect(socket).to be_alive
       end
+
+      shared_examples_for 'failing connection' do
+        it 'raises an exception' do
+          expect(error).to be_a(Exception)
+        end
+
+        it 'clears socket' do
+          error
+          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)
+
+          expect(connection).to receive(:authenticate!).and_raise(ConnectionSpecTestException)
+          expect do
+            connection.connect!
+          end.to raise_error(ConnectionSpecTestException)
+        end
+      end
+
+      context 'when #handshake! dependency raises a non-network exception' do
+
+        let(:exception) do
+          Mongo::Error::OperationFailure.new
+        end
+
+        let(:error) do
+          expect_any_instance_of(Mongo::Socket).to receive(:write).and_raise(exception)
+          begin
+            connection.connect!
+          rescue Exception => e
+            e
+          else
+            nil
+          end
+        end
+
+        it_behaves_like 'failing connection'
+        it_behaves_like 'keeps server type and topology'
+      end
+
+      context 'when #handshake! dependency raises a network exception' do
+        let(:exception) do
+          Mongo::Error::SocketError.new
+        end
+
+        let(:error) do
+          expect_any_instance_of(Mongo::Socket).to receive(:write).and_raise(exception)
+          begin
+            connection.connect!
+          rescue Exception => e
+            e
+          else
+            nil
+          end
+        end
+
+        it_behaves_like 'failing connection'
+        it_behaves_like 'marks server unknown'
+      end
+
+      context 'when #authenticate! raises an exception' do
+        let(:exception) do
+          Mongo::Error::OperationFailure.new
+        end
+
+        let(:error) do
+          expect(connection).to receive(:authenticate!).and_raise(exception)
+          begin
+            connection.connect!
+          rescue Exception => e
+            e
+          else
+            nil
+          end
+        end
+
+        it_behaves_like 'failing connection'
+      end
+
+      context 'when a non-Mongo exception is raised' do
+        let(:exception) do
+          SystemExit.new
+        end
+
+        let(:error) do
+          expect(connection).to receive(:authenticate!).and_raise(exception)
+          begin
+            connection.connect!
+          rescue Exception => e
+            e
+          else
+            nil
+          end
+        end
+
+        it_behaves_like 'failing connection'
+      end
     end
 
     context 'when a socket exists' do
@@ -80,50 +228,155 @@ describe Mongo::Server::Connection do
         described_class.new(server, server.options)
       end
 
-      before do
-        connection.connect!
-        connection.connect!
-      end
-
       let(:socket) do
         connection.send(:socket)
       end
 
       it 'keeps the socket alive' do
+        expect(connection.connect!).to be true
+        expect(connection.connect!).to be true
         expect(socket).to be_alive
       end
+
+      it 'retains socket object' do
+        expect(connection.connect!).to be true
+        socket_id = connection.send(:socket).object_id
+        expect(connection.connect!).to be true
+        new_socket_id = connection.send(:socket).object_id
+        expect(new_socket_id).to eq(socket_id)
+      end
+    end
+
+    shared_examples_for 'does not disconnect connection pool' do
+      it 'does not disconnect non-monitoring sockets' do
+        allow(cluster).to receive(:pool).with(server).and_return(pool)
+        expect(pool).not_to receive(:disconnect!)
+        error
+      end
+    end
+
+    shared_examples_for 'disconnects connection pool' do
+      it 'disconnects non-monitoring sockets' do
+        expect(cluster).to receive(:pool).with(server).and_return(pool)
+        expect(pool).to receive(:disconnect!).and_return(true)
+        error
+      end
+    end
+
+    let(:auth_mechanism) do
+      if ClusterConfig.instance.server_version >= '3'
+        Mongo::Auth::SCRAM
+      else
+        Mongo::Auth::CR
+      end
     end
 
     context 'when user credentials exist' do
 
+      let(:server) { monitored_server }
+
       context 'when the user is not authorized' do
 
         let(:connection) do
           described_class.new(
             server,
-            TEST_OPTIONS.merge(
+            SpecConfig.instance.test_options.merge(
               :user => 'notauser',
               :password => 'password',
-              :database => TEST_DB,
+              :database => SpecConfig.instance.test_db,
               :heartbeat_frequency => 30)
           )
         end
 
-        let!(:error) do
-          e = begin; connection.send(:ensure_connected); rescue => ex; ex; end
+        let(:error) do
+          begin
+            connection.send(:connect!)
+          rescue => ex
+            ex
+          else
+            nil
+          end
         end
 
-        it 'raises an error' do
-          expect(error).to be_a(Mongo::Auth::Unauthorized)
+        context 'not checking pool disconnection' do
+          before do
+            allow(cluster).to receive(:pool).with(server).and_return(pool)
+            allow(pool).to receive(:disconnect!).and_return(true)
+          end
+
+          it 'raises an error' do
+            expect(error).to be_a(Mongo::Auth::Unauthorized)
+          end
+
+          it_behaves_like 'disconnects connection pool'
+          it_behaves_like 'keeps server type and topology'
         end
 
-        it 'disconnects the socket' do
-          expect(connection.send(:socket)).to be(nil)
+        # need a separate context here, otherwise disconnect expectation
+        # is ignored due to allowing disconnects in the other context
+        context 'checking pool disconnection' do
+          it_behaves_like 'disconnects connection pool'
+        end
+      end
+
+      context 'socket timeout during auth' do
+        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 )
+          )
+        end
+
+        let(:error) do
+          expect_any_instance_of(auth_mechanism).to receive(:login).and_raise(Mongo::Error::SocketTimeoutError)
+          begin
+            connection.send(:connect!)
+          rescue => ex
+            ex
+          else
+            nil
+          end
+        end
+
+        it 'propagates the error' do
+          expect(error).to be_a(Mongo::Error::SocketTimeoutError)
+        end
+
+        it_behaves_like 'does not disconnect connection pool'
+        it_behaves_like 'keeps server type and topology'
+      end
+
+      context 'non-timeout socket exception during auth' do
+        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 )
+          )
         end
 
-        it 'marks the server as unknown' do
-          expect(server).to be_unknown
+        let(:error) do
+          expect_any_instance_of(auth_mechanism).to receive(:login).and_raise(Mongo::Error::SocketError)
+          begin
+            connection.send(:connect!)
+          rescue => ex
+            ex
+          else
+            nil
+          end
+        end
+
+        it 'propagates the error' do
+          expect(error).to be_a(Mongo::Error::SocketError)
         end
+
+        it_behaves_like 'disconnects connection pool'
+        it_behaves_like 'marks server unknown'
       end
 
       describe 'when the user is authorized' do
@@ -131,10 +384,10 @@ describe Mongo::Server::Connection do
         let(:connection) do
           described_class.new(
             server,
-            TEST_OPTIONS.merge(
-              :user => TEST_USER.name,
-              :password => TEST_USER.password,
-              :database => TEST_USER.database )
+            SpecConfig.instance.test_options.merge(
+              :user => SpecConfig.instance.test_user.name,
+              :password => SpecConfig.instance.test_user.password,
+              :database => SpecConfig.instance.test_user.database )
           )
         end
 
@@ -147,6 +400,7 @@ describe Mongo::Server::Connection do
         end
       end
     end
+
   end
 
   describe '#disconnect!' do
@@ -181,13 +435,15 @@ describe Mongo::Server::Connection do
 
   describe '#dispatch' do
 
+    let(:server) { monitored_server }
+
     let!(:connection) do
       described_class.new(
         server,
-        TEST_OPTIONS.merge(
-          :user => TEST_USER.name,
-          :password => TEST_USER.password,
-          :database => TEST_USER.database )
+        SpecConfig.instance.test_options.merge(
+          :user => SpecConfig.instance.test_user.name,
+          :password => SpecConfig.instance.test_user.password,
+          :database => SpecConfig.instance.test_user.database )
       )
     end
 
@@ -196,24 +452,25 @@ describe Mongo::Server::Connection do
     end
 
     let(:insert) do
-      Mongo::Protocol::Insert.new(TEST_DB, TEST_COLL, documents)
+      Mongo::Protocol::Insert.new(SpecConfig.instance.test_db, TEST_COLL, documents)
     end
 
     let(:query) do
-      Mongo::Protocol::Query.new(TEST_DB, TEST_COLL, { 'name' => 'testing' })
+      Mongo::Protocol::Query.new(SpecConfig.instance.test_db, TEST_COLL, { 'name' => 'testing' })
     end
 
     context 'when providing a single message' do
 
       let(:reply) do
-        connection.dispatch([ insert, query ])
+        connection.dispatch([ query ])
       end
 
-      after do
+      before do
         authorized_collection.delete_many
+        connection.dispatch([ insert ])
       end
 
-      it 'it dispatchs the message to the socket' do
+      it 'it dispatches the message to the socket' do
         expect(reply.documents.first['name']).to eq('testing')
       end
     end
@@ -225,19 +482,21 @@ describe Mongo::Server::Connection do
       end
 
       let(:command) do
-        Mongo::Protocol::Query.new(TEST_DB, '$cmd', selector, :limit => -1)
+        Mongo::Protocol::Query.new(SpecConfig.instance.test_db, '$cmd', selector, :limit => -1)
       end
 
       let(:reply) do
         connection.dispatch([ insert, command ])
       end
 
-      after do
+      before do
         authorized_collection.delete_many
       end
 
-      it 'it dispatchs the message to the socket' do
-        expect(reply.documents.first['ok']).to eq(1.0)
+      it 'raises ArgumentError' do
+        expect do
+          reply
+        end.to raise_error(ArgumentError, 'Can only dispatch one message at a time')
       end
     end
 
@@ -248,25 +507,26 @@ describe Mongo::Server::Connection do
       end
 
       let(:insert) do
-        Mongo::Protocol::Insert.new(TEST_DB, TEST_COLL, documents)
+        Mongo::Protocol::Insert.new(SpecConfig.instance.test_db, TEST_COLL, documents)
       end
 
       let(:query_bob) do
-        Mongo::Protocol::Query.new(TEST_DB, TEST_COLL, { name: 'bob' })
+        Mongo::Protocol::Query.new(SpecConfig.instance.test_db, TEST_COLL, { name: 'bob' })
       end
 
       let(:query_alice) do
-        Mongo::Protocol::Query.new(TEST_DB, TEST_COLL, { name: 'alice' })
+        Mongo::Protocol::Query.new(SpecConfig.instance.test_db, TEST_COLL, { name: 'alice' })
       end
 
-      after do
+      before do
         authorized_collection.delete_many
       end
 
       before do
+        connection.dispatch([ insert ])
         # Fake a query for which we did not read the response. See RUBY-1117
         allow(query_bob).to receive(:replyable?) { false }
-        connection.dispatch([ insert, query_bob ])
+        connection.dispatch([ query_bob ])
       end
 
       it 'raises an UnexpectedResponse error' do
@@ -281,7 +541,9 @@ describe Mongo::Server::Connection do
           connection.dispatch([ query_alice ])
         }.to raise_error(Mongo::Error::UnexpectedResponse)
 
-        expect(connection.dispatch([ query_alice ]).documents.first['name']).to eq('alice')
+        docs = connection.dispatch([ query_alice ]).documents
+        expect(docs).to_not be_empty
+        expect(docs.first['name']).to eq('alice')
       end
     end
 
@@ -292,29 +554,26 @@ describe Mongo::Server::Connection do
       end
 
       let(:insert) do
-        Mongo::Protocol::Insert.new(TEST_DB, TEST_COLL, documents)
+        Mongo::Protocol::Insert.new(SpecConfig.instance.test_db, TEST_COLL, documents)
       end
 
       let(:query_bob) do
-        Mongo::Protocol::Query.new(TEST_DB, TEST_COLL, { name: 'bob' })
+        Mongo::Protocol::Query.new(SpecConfig.instance.test_db, TEST_COLL, { name: 'bob' })
       end
 
       let(:query_alice) do
-        Mongo::Protocol::Query.new(TEST_DB, TEST_COLL, { name: 'alice' })
+        Mongo::Protocol::Query.new(SpecConfig.instance.test_db, TEST_COLL, { name: 'alice' })
       end
 
       before do
-        connection.dispatch([ insert ])
-      end
-
-      after do
         authorized_collection.delete_many
+        connection.dispatch([ insert ])
       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 and t.stop? }
+          allow(Mongo::Protocol::Reply).to receive(:deserialize_header) { t.kill && !t.alive? }
           connection.dispatch([ query_bob ])
         }
         t.join
@@ -357,7 +616,7 @@ describe Mongo::Server::Connection do
         end
 
         let(:command) do
-          Mongo::Protocol::Query.new(TEST_DB, '$cmd', selector, :limit => -1)
+          Mongo::Protocol::Query.new(SpecConfig.instance.test_db, '$cmd', selector, :limit => -1)
         end
 
         let(:reply) do
@@ -406,13 +665,8 @@ describe Mongo::Server::Connection do
       end
 
       before do
-        authorized_collection.insert_one(a: 1)
-      end
-
-      after do
-        sleep(0.5)
         authorized_collection.delete_many
-        client.close
+        authorized_collection.insert_one(a: 1)
       end
 
       it 'raises a timeout when it expires' do
@@ -436,17 +690,20 @@ describe Mongo::Server::Connection do
           described_class.new(server, server.options)
         end
 
-        let(:messages) do
-          [ insert ]
+        let(:message) do
+          insert
         end
 
         before do
-          connection.send(:write, messages)
+          expect(message).to receive(:replyable?) { false }
+          connection.send(:deliver, message)
+
           connection.send(:socket).instance_variable_set(:@timeout, -(Time.now.to_i))
         end
 
         let(:reply) do
-          connection.send(:read, messages.last.request_id)
+          Mongo::Protocol::Message.deserialize(connection.send(:socket),
+            16*1024*1024, message.request_id)
         end
 
         it 'raises a timeout error' do
@@ -460,15 +717,12 @@ describe Mongo::Server::Connection do
     context 'when the process is forked' do
 
       let(:insert) do
-        Mongo::Protocol::Insert.new(TEST_DB, TEST_COLL, documents)
+        Mongo::Protocol::Insert.new(SpecConfig.instance.test_db, TEST_COLL, documents)
       end
 
       before do
-        expect(Process).to receive(:pid).at_least(:once).and_return(1)
-      end
-
-      after do
         authorized_collection.delete_many
+        expect(Process).to receive(:pid).at_least(:once).and_return(1)
       end
 
       it 'disconnects the connection' do
@@ -568,18 +822,18 @@ describe Mongo::Server::Connection do
       let(:connection) do
         described_class.new(
           server,
-          :user => TEST_USER.name,
-          :password => TEST_USER.password,
-          :database => TEST_DB,
+          :user => SpecConfig.instance.test_user.name,
+          :password => SpecConfig.instance.test_user.password,
+          :database => SpecConfig.instance.test_db,
           :auth_mech => :mongodb_cr
         )
       end
 
       let(:user) do
         Mongo::Auth::User.new(
-          database: TEST_DB,
-          user: TEST_USER.name,
-          password: TEST_USER.password
+          database: SpecConfig.instance.test_db,
+          user: SpecConfig.instance.test_user.name,
+          password: SpecConfig.instance.test_user.password
         )
       end
 
@@ -589,73 +843,6 @@ describe Mongo::Server::Connection do
     end
   end
 
-  describe '#auth_mechanism' do
-
-    let(:connection) do
-      described_class.new(server, server.options)
-    end
-
-    let(:reply) do
-      double('reply').tap do |r|
-        allow(r).to receive(:documents).and_return([ ismaster ])
-      end
-    end
-
-    before do
-      connection.connect!
-    end
-
-    context 'when the ismaster response indicates the auth mechanism is :scram' do
-
-      let(:features) do
-        Mongo::Server::Description::Features.new(0..7)
-      end
-
-      context 'when the server auth mechanism is scram', if: scram_sha_1_enabled? && !scram_sha_256_enabled? do
-
-        it 'uses scram' do
-          allow(Mongo::Server::Description::Features).to receive(:new).and_return(features)
-          connection.send(:handshake!)
-          expect(connection.send(:default_mechanism)).to eq(:scram)
-        end
-      end
-
-      context 'when the server auth mechanism is the default (mongodb_cr)', unless: scram_sha_1_enabled?  do
-
-        it 'uses scram' do
-          allow(Mongo::Server::Description::Features).to receive(:new).and_return(features)
-          connection.send(:handshake!)
-          expect(connection.send(:default_mechanism)).to eq(:scram)
-        end
-      end
-    end
-
-    context 'when the ismaster response indicates the auth mechanism is :mongodb_cr' do
-
-      let(:features) do
-        Mongo::Server::Description::Features.new(0..2)
-      end
-
-      context 'when the server auth mechanism is scram', if: scram_sha_1_enabled? && !scram_sha_256_enabled? do
-
-        it 'uses scram' do
-          allow(Mongo::Server::Description::Features).to receive(:new).and_return(features)
-          connection.send(:handshake!)
-          expect(connection.send(:default_mechanism)).to eq(:scram)
-        end
-      end
-
-      context 'when the server auth mechanism is the default (mongodb_cr)', unless: scram_sha_1_enabled?  do
-
-        it 'uses mongodb_cr' do
-          allow(Mongo::Server::Description::Features).to receive(:new).and_return(features)
-          connection.send(:handshake!)
-          expect(connection.send(:default_mechanism)).to eq(:mongodb_cr)
-        end
-      end
-    end
-  end
-
   context 'when different timeout options are set' do
 
     let(:client) do
@@ -683,7 +870,7 @@ describe Mongo::Server::Connection do
       context 'when a socket_timeout is in the options' do
 
         let(:options) do
-          TEST_OPTIONS.merge(connect_timeout: 3, socket_timeout: 5)
+          SpecConfig.instance.test_options.merge(connect_timeout: 3, socket_timeout: 5)
         end
 
         before do
@@ -702,7 +889,7 @@ describe Mongo::Server::Connection do
       context 'when a socket_timeout is not in the options' do
 
         let(:options) do
-          TEST_OPTIONS.merge(connect_timeout: 3, socket_timeout: nil)
+          SpecConfig.instance.test_options.merge(connect_timeout: 3, socket_timeout: nil)
         end
 
         before do
@@ -724,7 +911,7 @@ describe Mongo::Server::Connection do
       context 'when a socket_timeout is in the options' do
 
         let(:options) do
-          TEST_OPTIONS.merge(connect_timeout: nil, socket_timeout: 5)
+          SpecConfig.instance.test_options.merge(connect_timeout: nil, socket_timeout: 5)
         end
 
         before do
@@ -743,7 +930,7 @@ describe Mongo::Server::Connection do
       context 'when a socket_timeout is not in the options' do
 
         let(:options) do
-          TEST_OPTIONS.merge(connect_timeout: nil, socket_timeout: nil)
+          SpecConfig.instance.test_options.merge(connect_timeout: nil, socket_timeout: nil)
         end
 
         before do