mongo 2.10.5 → 2.11.0.rc0

data/spec/mongo/server/app_metadata_spec.rb

@@ -22,10 +22,6 @@ describe Mongo::Server::AppMetadata do
         client.cluster
       end
 
-      after do
-        client.close(true)
-      end
-
       it 'sets the app name' do
         expect(app_metadata.send(:full_client_document)[:application][:name]).to eq('app_metadata_test')
       end
@@ -40,10 +36,6 @@ describe Mongo::Server::AppMetadata do
           client.cluster
         end
 
-        after do
-          client.close(true)
-        end
-
         it 'raises an error' do
           expect {
             app_metadata.send(:validate!)

data/spec/mongo/server/connection_auth_spec.rb

@@ -25,6 +25,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)
+      allow(cl).to receive(:run_sdam_flow)
       pool = double('pool')
       allow(pool).to receive(:disconnect!)
       allow(cl).to receive(:pool).and_return(pool)
@@ -34,8 +35,10 @@ describe Mongo::Server::Connection, retry: 3 do
   declare_topology_double
 
   let(:server) do
-    Mongo::Server.new(address, cluster, monitoring, listeners,
-      SpecConfig.instance.test_options.merge(monitoring_io: false))
+    register_server(
+      Mongo::Server.new(address, cluster, monitoring, listeners,
+        SpecConfig.instance.test_options.merge(monitoring_io: false))
+    )
   end
 
   before(:all) do

data/spec/mongo/server/connection_pool/populator_spec.rb

@@ -0,0 +1,101 @@
+require 'spec_helper'
+
+describe Mongo::Server::Populator do
+  let(:options) { {} }
+
+  let(:client) do
+    authorized_client.with(options)
+  end
+
+  let(:server) do
+    client.cluster.next_primary
+  end
+
+  let(:pool) do
+    server.pool
+  end
+
+  let(:populator) do
+    register_background_thread_object(
+      described_class.new(pool, pool.options)
+    )
+  end
+
+  before do
+    # We create our own populator to test; disable pool's background populator
+    # and clear the pool, so ours can run
+    pool.stop_populator
+    pool.clear
+  end
+
+  describe '#log_warn' do
+    it 'works' do
+      expect do
+        populator.log_warn('test warning')
+      end.not_to raise_error
+    end
+  end
+
+
+  describe '#run!' do
+    context 'when the min_pool_size is zero' do
+      let(:options) { {min_pool_size: 0} }
+
+      it 'calls populate on pool once' do
+        expect(pool).to receive(:populate).once.and_call_original
+        populator.run!
+        sleep 1
+        expect(populator.running?).to be true
+      end
+    end
+
+    context 'when the min_pool_size is greater than zero' do
+      let(:options) { {min_pool_size: 2, max_pool_size: 3} }
+
+      it 'calls populate on the pool multiple times' do
+        expect(pool).to receive(:populate).at_least(:once).and_call_original
+        populator.run!
+        sleep 1
+        expect(populator.running?).to be true
+      end
+
+      it 'populates the pool up to min_size' do
+        populator.run!
+        sleep 1
+        expect(pool.size).to eq 2
+        expect(populator.running?).to be true
+      end
+    end
+
+    context 'when populate raises a non socket related error' do
+      it 'does not terminate the thread' do
+        expect(pool).to receive(:populate).once.and_raise(Mongo::Auth::InvalidMechanism.new(""))
+        populator.run!
+        sleep 0.5
+        expect(populator.running?).to be true
+      end
+    end
+
+    context 'when populate raises a socket related error' do
+      it 'does not terminate the thread' do
+        expect(pool).to receive(:populate).once.and_raise(Mongo::Error::SocketError)
+        populator.run!
+        sleep 0.5
+        expect(populator.running?).to be true
+      end
+    end
+  end
+
+  describe '#stop' do
+    it 'stops calling populate on pool and terminates the thread' do
+      populator.run!
+
+      # let populator do work and wait on semaphore
+      sleep 0.5
+
+      expect(pool).not_to receive(:populate)
+      populator.stop!
+      expect(populator.running?).to be false
+    end
+  end
+end

data/spec/mongo/server/connection_pool_spec.rb

@@ -2,10 +2,12 @@ require 'spec_helper'
 
 describe Mongo::Server::ConnectionPool do
 
-  let(:options) { {max_pool_size: 2} }
+  let(:options) { {} }
 
   let(:server_options) do
-    SpecConfig.instance.test_options.merge(options)
+    SpecConfig.instance.ssl_options.merge(SpecConfig.instance.compressor_options)
+      .merge(SpecConfig.instance.retry_writes_options).merge(SpecConfig.instance.auth_options)
+      .merge(options)
   end
 
   let(:address) do
@@ -28,28 +30,39 @@ describe Mongo::Server::ConnectionPool do
       allow(cl).to receive(:app_metadata).and_return(app_metadata)
       allow(cl).to receive(:options).and_return({})
       allow(cl).to receive(:update_cluster_time)
+      allow(cl).to receive(:cluster_time).and_return(nil)
+      allow(cl).to receive(:run_sdam_flow)
     end
   end
 
   let(:server) do
-    Mongo::Server.new(address, cluster, monitoring, listeners, server_options)
+    register_server(
+      Mongo::Server.new(address, cluster, monitoring, listeners,
+        {monitoring_io: false}.update(server_options)
+      ).tap do |server|
+        allow(server).to receive(:description).and_return(ClusterConfig.instance.primary_description)
+      end
+    )
   end
 
   let(:pool) do
-    described_class.new(server)
+    register_pool(described_class.new(server, server_options))
   end
 
   describe '#initialize' do
 
     context 'when a min size is provided' do
-
-      let(:pool) do
-        described_class.new(server, :min_pool_size => 2)
+      let (:options) do
+        { min_pool_size: 2 }
       end
 
-      it 'creates the pool with no connections' do
-        expect(pool.size).to eq(0)
-        expect(pool.available_count).to eq(0)
+      it 'creates the pool with min size connections' do
+        # Allow background thread to populate pool
+        pool
+        sleep 1
+
+        expect(pool.size).to eq(2)
+        expect(pool.available_count).to eq(2)
       end
 
       it 'does not use the same objects in the pool' do
@@ -58,9 +71,8 @@ describe Mongo::Server::ConnectionPool do
     end
 
     context 'when min size exceeds default max size' do
-
-      let(:pool) do
-        described_class.new(server, :min_pool_size => 10)
+      let (:options) do
+        { min_pool_size: 10 }
       end
 
       it 'sets max size to equal provided min size' do
@@ -70,10 +82,6 @@ describe Mongo::Server::ConnectionPool do
 
     context 'when no min size is provided' do
 
-      let(:pool) do
-        described_class.new(server)
-      end
-
       it 'creates the pool with no connections' do
         expect(pool.size).to eq(0)
         expect(pool.available_count).to eq(0)
@@ -81,9 +89,8 @@ describe Mongo::Server::ConnectionPool do
     end
 
     context 'sizes given as min_size and max_size' do
-
-      let(:pool) do
-        described_class.new(server, min_size: 3, max_size: 7)
+      let (:options) do
+        { min_size: 3, max_size: 7 }
       end
 
       it 'sets sizes correctly' do
@@ -93,9 +100,8 @@ describe Mongo::Server::ConnectionPool do
     end
 
     context 'sizes given as min_pool_size and max_pool_size' do
-
-      let(:pool) do
-        described_class.new(server, min_pool_size: 3, max_pool_size: 7)
+      let (:options) do
+        { min_pool_size: 3, max_pool_size: 7 }
       end
 
       it 'sets sizes correctly' do
@@ -105,9 +111,8 @@ describe Mongo::Server::ConnectionPool do
     end
 
     context 'timeout given as wait_timeout' do
-
-      let(:pool) do
-        described_class.new(server, wait_timeout: 4)
+      let (:options) do
+        { wait_timeout: 4 }
       end
 
       it 'sets wait timeout correctly' do
@@ -116,9 +121,8 @@ describe Mongo::Server::ConnectionPool do
     end
 
     context 'timeout given as wait_queue_timeout' do
-
-      let(:pool) do
-        described_class.new(server, wait_queue_timeout: 4)
+      let (:options) do
+        { wait_queue_timeout: 4 }
       end
 
       it 'sets wait timeout correctly' do
@@ -128,11 +132,9 @@ describe Mongo::Server::ConnectionPool do
   end
 
   describe '#max_size' do
-
     context 'when a max pool size option is provided' do
-
-      let(:pool) do
-        described_class.new(server, :max_pool_size => 3)
+      let (:options) do
+        { max_pool_size: 3 }
       end
 
       it 'returns the max size' do
@@ -141,7 +143,6 @@ describe Mongo::Server::ConnectionPool do
     end
 
     context 'when no pool size option is provided' do
-
       it 'returns the default size' do
         expect(pool.max_size).to eq(5)
       end
@@ -159,11 +160,9 @@ describe Mongo::Server::ConnectionPool do
   end
 
   describe '#wait_timeout' do
-
     context 'when the wait timeout option is provided' do
-
-      let(:pool) do
-        described_class.new(server, :wait_queue_timeout => 3)
+      let (:options) do
+        { wait_queue_timeout: 3 }
       end
 
       it 'returns the wait timeout' do
@@ -172,9 +171,8 @@ describe Mongo::Server::ConnectionPool do
     end
 
     context 'when the wait timeout option is not provided' do
-
       it 'returns the default wait timeout' do
-        expect(pool.wait_timeout).to eq(1)
+        expect(pool.wait_timeout).to eq(10)
       end
     end
   end
@@ -280,17 +278,17 @@ describe Mongo::Server::ConnectionPool do
   end
 
   describe '#check_in' do
-
     let!(:pool) do
       server.pool
     end
 
     after do
-      expect(server).to receive(:pool).and_return(pool)
       server.disconnect!
     end
 
-    let(:options) { {max_pool_size: 2} }
+    let(:options) do
+      { max_pool_size: 2 }
+    end
 
     let(:connection) do
       pool.check_out
@@ -348,7 +346,7 @@ describe Mongo::Server::ConnectionPool do
       end
 
       before do
-        expect(connection.generation < pool.generation).to be true
+        expect(connection.generation).to be < pool.generation
       end
 
       it_behaves_like 'does not add connection to pool'
@@ -370,8 +368,6 @@ describe Mongo::Server::ConnectionPool do
     end
 
     context 'when pool is closed' do
-      let(:connection) { pool.check_out }
-
       before do
         connection
         pool.close
@@ -385,10 +381,32 @@ describe Mongo::Server::ConnectionPool do
         expect(pool.instance_variable_get('@available_connections').length).to eq(0)
       end
     end
+
+    context 'when connection is checked in twice' do
+      it 'raises an ArgumentError and does not change pool state' do
+        pool.check_in(connection)
+        expect do
+          pool.check_in(connection)
+        end.to raise_error(ArgumentError, /Trying to check in a connection which is not currently checked out by this pool.*/)
+        expect(pool.size).to eq(1)
+        expect(pool.check_out).to eq(connection)
+      end
+    end
+
+    context 'when connection is checked in to a different pool' do
+      it 'raises an ArgumentError and does not change the state of either pool' do
+        pool_other = register_pool(described_class.new(server))
+
+        expect do
+          pool_other.check_in(connection)
+        end.to raise_error(ArgumentError, /Trying to check in a connection which was not checked out by this pool.*/)
+        expect(pool.size).to eq(1)
+        expect(pool_other.size).to eq(0)
+      end
+    end
   end
 
   describe '#check_out' do
-
     let!(:pool) do
       server.pool
     end
@@ -421,7 +439,7 @@ describe Mongo::Server::ConnectionPool do
 
     context 'when there is an available connection which is stale' do
       let(:options) do
-        {max_pool_size: 2, max_idle_time: 0.1}
+        { max_pool_size: 2, max_idle_time: 0.1 }
       end
 
       let(:connection) do
@@ -436,10 +454,6 @@ describe Mongo::Server::ConnectionPool do
         pool.check_in(connection)
       end
 
-      after do
-        pool.close(force: true)
-      end
-
       it 'closes stale connection and creates a new one' do
         expect(connection).to receive(:disconnect!)
         expect(Mongo::Server::Connection).to receive(:new).and_call_original
@@ -450,7 +464,7 @@ describe Mongo::Server::ConnectionPool do
     context 'when there are no available connections' do
 
       let(:options) do
-        {max_pool_size: 1}
+        { max_pool_size: 1, min_pool_size: 0 }
       end
 
       context 'when the max size is not reached' do
@@ -503,12 +517,43 @@ describe Mongo::Server::ConnectionPool do
         end.to raise_error(Mongo::Error::PoolClosedError)
       end
     end
+
+    context 'when connection set up throws an error during check out' do
+      let(:client) do
+        authorized_client
+      end
+
+       let(:pool) do
+        client.cluster.next_primary.pool
+      end
+
+       it 'raises an error and emits ConnectionCheckOutFailedEvent' do
+        pool
+
+        subscriber = EventSubscriber.new
+        client.subscribe(Mongo::Monitoring::CONNECTION_POOL, subscriber)
+
+        subscriber.clear_events!
+        expect(Mongo::Auth).to receive(:get).at_least(:once).and_raise(Mongo::Error)
+        expect { pool.check_out }.to raise_error(Mongo::Error)
+        expect(pool.size).to eq(0)
+
+         checkout_failed_events = subscriber.published_events.select do |event|
+          event.is_a?(Mongo::Monitoring::Event::Cmap::ConnectionCheckOutFailed)
+        end
+        expect(checkout_failed_events.size).to eq(1)
+        expect(checkout_failed_events.first.reason).to be(:connection_error)
+      end
+    end
   end
 
   describe '#disconnect!' do
-
     def create_pool(min_pool_size)
-      described_class.new(server, max_pool_size: 3, min_pool_size: min_pool_size).tap do |pool|
+      opts = SpecConfig.instance.test_options.merge(max_pool_size: 3, min_pool_size: min_pool_size)
+      described_class.new(server, opts).tap do |pool|
+        # kill background thread to test disconnect behavior
+        pool.stop_populator
+        expect(pool.instance_variable_get('@populator').running?).to be false
         # make pool be of size 2 so that it has enqueued connections
         # when told to disconnect
         c1 = pool.check_out
@@ -546,7 +591,7 @@ describe Mongo::Server::ConnectionPool do
 
     context 'min size is 0' do
       let(:pool) do
-        create_pool(0)
+        register_pool(create_pool(0))
       end
 
       it_behaves_like 'disconnects and removes all connections in the pool and bumps generation'
@@ -554,7 +599,7 @@ describe Mongo::Server::ConnectionPool do
 
     context 'min size is not 0' do
       let(:pool) do
-        create_pool(1)
+        register_pool(create_pool(1))
       end
 
       it_behaves_like 'disconnects and removes all connections in the pool and bumps generation'
@@ -597,15 +642,17 @@ describe Mongo::Server::ConnectionPool do
   end
 
   describe '#inspect' do
-    let(:options) { {min_pool_size: 3, max_pool_size: 7, wait_timeout: 9, wait_queue_timeout: 9} }
+    let(:options) do
+      { min_pool_size: 3, max_pool_size: 7, wait_timeout: 9, wait_queue_timeout: 9 }
+    end
 
     let!(:pool) do
       server.pool
     end
 
     after do
-      expect(server).to receive(:pool).and_return(pool)
       server.disconnect!
+      pool.close # this will no longer be needed after server disconnect kills bg thread
     end
 
     it 'includes the object id' do
@@ -625,7 +672,7 @@ describe Mongo::Server::ConnectionPool do
     end
 
     it 'includes the current size' do
-      expect(pool.inspect).to include('current_size=0')
+      expect(pool.inspect).to include('current_size=')
     end
 
 =begin obsolete
@@ -654,7 +701,6 @@ describe Mongo::Server::ConnectionPool do
   end
 
   describe '#with_connection' do
-
     let!(:pool) do
       server.pool
     end
@@ -662,10 +708,11 @@ describe Mongo::Server::ConnectionPool do
     context 'when a connection cannot be checked out' do
 
       it 'does not add the connection to the pool' do
-        pending 'Re-enable when connections are connected prior to being returned from check_out method'
-
+        # fails because with_connection raises the SocketError which is not caught anywhere
         allow(pool).to receive(:check_out).and_raise(Mongo::Error::SocketError)
-        pool.with_connection { |c| c }
+        expect do
+          pool.with_connection { |c| c }
+        end.to raise_error(Mongo::Error::SocketError)
 
         expect(pool.size).to eq(0)
       end
@@ -685,13 +732,12 @@ describe Mongo::Server::ConnectionPool do
   end
 
   context 'when the connection does not finish authenticating before the thread is killed' do
-
     let!(:pool) do
       server.pool
     end
 
-    let(:server_options) do
-      { user: SpecConfig.instance.root_user.name, password: SpecConfig.instance.root_user.password }.merge(SpecConfig.instance.test_options).merge(max_pool_size: 1)
+    let(:options) do
+      { min_pool_size:0, max_pool_size: 1 }
     end
 
     before do
@@ -700,32 +746,23 @@ describe Mongo::Server::ConnectionPool do
     end
 
     it 'creates a new connection' do
-      invoked = nil
-
       t = Thread.new do
-        # Kill the thread when it's authenticating
-        expect(Mongo::Auth).to receive(:get) do
-          if Thread.current != t
-            raise 'Auth invoked on unexpected thread'
+        expect {
+          pool.with_connection do |c|
+            expect(c).to receive(:connect!).and_raise(Mongo::Error)
+            c.send(:ensure_connected) { |socket| socket}
           end
-          invoked = true
-          t.kill
-          raise 'Should not get here'
-        end
-        pool.with_connection do |c|
-          c.send(:ensure_connected) { |socket| socket }
-        end
+        }.to raise_error(Mongo::Error)
+        expect(pool.size).to be(0)
       end
       t.join
 
-      #expect(Mongo::Auth).to receive(:get).and_call_original
       expect(pool.check_out).to be_a(Mongo::Server::Connection)
-      expect(invoked).to be true
+      expect(pool.size).to be(1)
     end
   end
 
   describe '#close_idle_sockets' do
-
     let!(:pool) do
       server.pool
     end
@@ -733,7 +770,7 @@ describe Mongo::Server::ConnectionPool do
     context 'when there is a max_idle_time specified' do
 
       let(:options) do
-        {max_pool_size: 2, max_idle_time: 0.5}
+        { max_pool_size: 2, max_idle_time: 0.5 }
       end
 
       after do
@@ -762,7 +799,7 @@ describe Mongo::Server::ConnectionPool do
         context 'when min size is 0' do
 
           let(:options) do
-            {max_pool_size: 2, min_pool_size: 0, max_idle_time: 0.5}
+            { max_pool_size: 2, min_pool_size: 0, max_idle_time: 0.5 }
           end
 
           before do
@@ -782,9 +819,15 @@ describe Mongo::Server::ConnectionPool do
         end
 
         context 'when min size is > 0' do
+          before do
+            # Kill background thread to test close_idle_socket behavior
+            pool.stop_populator
+            expect(pool.instance_variable_get('@populator').running?).to be false
+          end
+
           context 'when more than the number of min_size are checked out' do
             let(:options) do
-              {max_pool_size: 5, min_pool_size: 3, max_idle_time: 0.5}
+              { max_pool_size: 5, min_pool_size: 3, max_idle_time: 0.5 }
             end
 
             it 'closes and removes connections with idle sockets and does not connect new ones' do
@@ -813,7 +856,7 @@ describe Mongo::Server::ConnectionPool do
           context 'when between 0 and min_size number of connections are checked out' do
 
             let(:options) do
-              {max_pool_size: 5, min_pool_size: 3, max_idle_time: 0.5}
+              { max_pool_size: 5, min_pool_size: 3, max_idle_time: 0.5 }
             end
 
             it 'closes and removes connections with idle sockets and does not connect new ones' do
@@ -855,8 +898,8 @@ describe Mongo::Server::ConnectionPool do
     end
 
     context 'when available connections include idle and non-idle ones' do
-      let(:pool) do
-        described_class.new(server, max_pool_size: 2, max_idle_time: 0.5)
+      let (:options) do
+        { max_pool_size: 2, max_idle_time: 0.5 }
       end
 
       let(:connection) do
@@ -866,25 +909,30 @@ describe Mongo::Server::ConnectionPool do
       end
 
       it 'disconnects all expired and only expired connections' do
-        c1 = pool.check_out
-        expect(c1).to receive(:disconnect!)
-        c2 = pool.check_out
-        expect(c2).not_to receive(:disconnect!)
+        # Since per-test cleanup will close the pool and disconnect
+        # the connection, we need to explicitly define the scope for the
+        # assertions
+        RSpec::Mocks.with_temporary_scope do
+          c1 = pool.check_out
+          expect(c1).to receive(:disconnect!)
+          c2 = pool.check_out
+          expect(c2).not_to receive(:disconnect!)
 
-        pool.check_in(c1)
-        Timecop.travel(Time.now + 1)
-        pool.check_in(c2)
+          pool.check_in(c1)
+          Timecop.travel(Time.now + 1)
+          pool.check_in(c2)
 
-        expect(pool.size).to eq(2)
-        expect(pool.available_count).to eq(2)
+          expect(pool.size).to eq(2)
+          expect(pool.available_count).to eq(2)
 
-        expect(c1).not_to receive(:connect!)
-        expect(c2).not_to receive(:connect!)
+          expect(c1).not_to receive(:connect!)
+          expect(c2).not_to receive(:connect!)
 
-        pool.close_idle_sockets
+          pool.close_idle_sockets
 
-        expect(pool.size).to eq(1)
-        expect(pool.available_count).to eq(1)
+          expect(pool.size).to eq(1)
+          expect(pool.available_count).to eq(1)
+        end
       end
     end
 
@@ -897,13 +945,114 @@ describe Mongo::Server::ConnectionPool do
         conn
       end
 
+      it 'does not close any sockets' do
+        # Since per-test cleanup will close the pool and disconnect
+        # the connection, we need to explicitly define the scope for the
+        # assertions
+        RSpec::Mocks.with_temporary_scope do
+          expect(connection).not_to receive(:disconnect!)
+          pool.close_idle_sockets
+          expect(connection.connected?).to be(true)
+        end
+      end
+    end
+  end
+
+  describe '#populate' do
+    before do
+      # Disable the populator and clear the pool to isolate populate behavior
+      pool.stop_populator
+      pool.clear
+    end
+
+    let(:options) { {min_pool_size: 2, max_pool_size: 3} }
+
+    context 'when pool size is at least min_pool_size' do
       before do
-        expect(connection).not_to receive(:disconnect!)
-        pool.close_idle_sockets
+        first_connection = pool.check_out
+        second_connection = pool.check_out
+        expect(pool.size).to eq 2
+        expect(pool.available_count).to eq 0
       end
 
-      it 'does not close any sockets' do
-        expect(connection.connected?).to be(true)
+      it 'does not create a connection and returns false' do
+        expect(pool.populate).to be false
+        expect(pool.size).to eq 2
+        expect(pool.available_count).to eq 0
+      end
+    end
+
+    context 'when pool size is less than min_pool_size' do
+      before do
+        first_connection = pool.check_out
+        expect(pool.size).to eq 1
+        expect(pool.available_count).to eq 0
+      end
+
+      it 'creates one connection, connects it, and returns true' do
+        expect(pool.populate).to be true
+        expect(pool.size).to eq 2
+        expect(pool.available_count).to eq 1
+      end
+    end
+
+    context 'when pool is closed' do
+      before do
+        pool.close
+      end
+
+      it 'does not create a connection and returns false' do
+        expect(pool.populate).to be false
+
+        # Can't just check pool size; size errors when pool is closed
+        expect(pool.instance_variable_get('@available_connections').length).to eq(0)
+        expect(pool.instance_variable_get('@checked_out_connections').length).to eq(0)
+        expect(pool.instance_variable_get('@pending_connections').length).to eq(0)
+      end
+    end
+
+    context 'when connect fails with socket related error once' do
+      before do
+        i = 0
+        expect(pool).to receive(:connect_connection).exactly(:twice).and_wrap_original{ |m, *args|
+          i += 1
+          if i == 1
+            raise Mongo::Error::SocketError
+          else
+            m.call(*args)
+          end
+        }
+        expect(pool.size).to eq 0
+      end
+
+      it 'retries then succeeds in creating a connection' do
+        expect(pool.populate).to be true
+        expect(pool.size).to eq 1
+        expect(pool.available_count).to eq 1
+      end
+    end
+
+    context 'when connect fails with socket related error twice' do
+      before do
+        expect(pool).to receive(:connect_connection).exactly(:twice).and_raise(Mongo::Error::SocketError)
+        expect(pool.size).to eq 0
+      end
+
+      it 'retries, raises the second error, and fails to create a connection' do
+        expect{ pool.populate }.to raise_error(Mongo::Error::SocketError)
+        expect(pool.size).to eq 0
+      end
+    end
+
+    context 'when connect fails with non socket related error' do
+      before do
+        expect(pool).to receive(:connect_connection).once.and_raise(Mongo::Auth::InvalidMechanism.new(""))
+        expect(pool.size).to eq 0
+      end
+
+      it 'does not retry, raises the error, and fails to create a connection' do
+        expect{ pool.populate }.to raise_error(Mongo::Auth::InvalidMechanism)
+        expect(pool.size).to eq 0
       end
     end
   end