mongo 2.17.1 → 2.18.1

data/spec/mongo/server/connection_pool_spec.rb

@@ -83,11 +83,21 @@ describe Mongo::Server::ConnectionPool do
 
     context 'when min size exceeds default max size' do
       let (:options) do
-        { min_pool_size: 10 }
+        { min_pool_size: 50 }
       end
 
       it 'sets max size to equal provided min size' do
-        expect(pool.max_size).to eq(10)
+        expect(pool.max_size).to eq(50)
+      end
+    end
+
+    context 'when min size is provided and max size is zero (unlimited)' do
+      let (:options) do
+        { min_size: 10, max_size: 0 }
+      end
+
+      it 'sets max size to zero (unlimited)' do
+        expect(pool.max_size).to eq(0)
       end
     end
 
@@ -155,7 +165,7 @@ describe Mongo::Server::ConnectionPool do
 
     context 'when no pool size option is provided' do
       it 'returns the default size' do
-        expect(pool.max_size).to eq(5)
+        expect(pool.max_size).to eq(20)
       end
     end
 
@@ -165,7 +175,7 @@ describe Mongo::Server::ConnectionPool do
       end
 
       it 'returns max size' do
-        expect(pool.max_size).to eq(5)
+        expect(pool.max_size).to eq(20)
       end
     end
   end
@@ -316,16 +326,22 @@ describe Mongo::Server::ConnectionPool do
       end
     end
 
-    context 'connection of the same generation as pool' do
-      # These tests are also applicable to load balancers, but
-      # require different setup and assertions because load balancers
-      # do not have a single global generation.
-      require_topology :single, :replica_set, :sharded
-
-      before do
-        expect(pool.generation).to eq(connection.generation)
+    shared_examples 'does not add connection to pool' do
+      it 'disconnects connection and does not add connection to pool' do
+        # connection was checked out
+        expect(pool.available_count).to eq(0)
+        expect(pool.size).to eq(1)
+        expect(connection).to receive(:disconnect!)
+        pool.check_in(connection)
+        # connection is not added to the pool, and no replacement
+        # connection has been created at this point
+        expect(pool.available_count).to eq(0)
+        expect(pool.size).to eq(0)
+        expect(pool.check_out).not_to eq(connection)
       end
+    end
 
+    shared_examples 'adds connection to the pool' do
       it 'adds the connection to the pool' do
         # connection is checked out
         expect(pool.available_count).to eq(0)
@@ -338,19 +354,17 @@ describe Mongo::Server::ConnectionPool do
       end
     end
 
-    shared_examples 'does not add connection to pool' do
-      it 'disconnects connection and does not add connection to pool' do
-        # connection was checked out
-        expect(pool.available_count).to eq(0)
-        expect(pool.size).to eq(1)
-        expect(connection).to receive(:disconnect!)
-        pool.check_in(connection)
-        # connection is not added to the pool, and no replacement
-        # connection has been created at this point
-        expect(pool.available_count).to eq(0)
-        expect(pool.size).to eq(0)
-        expect(pool.check_out).not_to eq(connection)
+    context 'connection of the same generation as pool' do
+      # These tests are also applicable to load balancers, but
+      # require different setup and assertions because load balancers
+      # do not have a single global generation.
+      require_topology :single, :replica_set, :sharded
+
+      before do
+        expect(pool.generation).to eq(connection.generation)
       end
+
+      it_behaves_like 'adds connection to the pool'
     end
 
     context 'connection of earlier generation than pool' do
@@ -359,18 +373,37 @@ describe Mongo::Server::ConnectionPool do
       # do not have a single global generation.
       require_topology :single, :replica_set, :sharded
 
-      let(:connection) do
-        pool.check_out.tap do |connection|
-          expect(connection).to receive(:generation).at_least(:once).and_return(0)
-          expect(connection).not_to receive(:record_checkin!)
+      context 'when connection is not pinned' do
+        let(:connection) do
+          pool.check_out.tap do |connection|
+            expect(connection).to receive(:generation).at_least(:once).and_return(0)
+            expect(connection).not_to receive(:record_checkin!)
+          end
         end
+
+        before do
+          expect(connection.generation).to be < pool.generation
+        end
+
+        it_behaves_like 'does not add connection to pool'
       end
 
-      before do
-        expect(connection.generation).to be < pool.generation
+      context 'when connection is pinned' do
+        let(:connection) do
+          pool.check_out.tap do |connection|
+            allow(connection).to receive(:pinned?).and_return(true)
+            expect(connection).to receive(:generation).at_least(:once).and_return(0)
+            expect(connection).to receive(:record_checkin!)
+          end
+        end
+
+        before do
+          expect(connection.generation).to be < pool.generation
+        end
+
+        it_behaves_like 'adds connection to the pool'
       end
 
-      it_behaves_like 'does not add connection to pool'
     end
 
     context 'connection of later generation than pool' do
@@ -437,6 +470,18 @@ describe Mongo::Server::ConnectionPool do
       server.pool
     end
 
+    context 'when max_size is zero (unlimited)' do
+      let(:options) do
+        { max_size: 0 }
+      end
+
+      it 'checks out a connection' do
+        expect do
+          pool.check_out
+        end.not_to raise_error
+      end
+    end
+
     context 'when a connection is checked out on a different thread' do
 
       let!(:connection) do
@@ -473,23 +518,45 @@ describe Mongo::Server::ConnectionPool do
         { max_pool_size: 2, max_idle_time: 0.1 }
       end
 
-      let(:connection) do
-        pool.check_out.tap do |connection|
-          allow(connection).to receive(:generation).and_return(pool.generation)
-          allow(connection).to receive(:record_checkin!).and_return(connection)
-          expect(connection).to receive(:last_checkin).at_least(:once).and_return(Time.now - 10)
+      context 'when connection is not pinned' do
+        let(:connection) do
+          pool.check_out.tap do |connection|
+            allow(connection).to receive(:generation).and_return(pool.generation)
+            allow(connection).to receive(:record_checkin!).and_return(connection)
+            expect(connection).to receive(:last_checkin).at_least(:once).and_return(Time.now - 10)
+          end
         end
-      end
 
-      before do
-        pool.check_in(connection)
+        before do
+          pool.check_in(connection)
+        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
+          pool.check_out
+        end
       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
-        pool.check_out
+      context 'when connection is pinned' do
+        let(:connection) do
+          pool.check_out.tap do |connection|
+            allow(connection).to receive(:generation).and_return(pool.generation)
+            allow(connection).to receive(:record_checkin!).and_return(connection)
+            expect(connection).to receive(:pinned?).and_return(true)
+          end
+        end
+
+        before do
+          pool.check_in(connection)
+        end
+
+        it 'does not close stale connection' do
+          expect(connection).not_to receive(:disconnect!)
+          pool.check_out
+        end
       end
+
     end
 
     context 'when there are no available connections' do
@@ -520,24 +587,24 @@ describe Mongo::Server::ConnectionPool do
           end
         end
 
-        context 'with service_id' do
+        context 'with connection_global_id' do
           require_topology :load_balanced
 
-          let(:service_id) do
+          let(:connection_global_id) do
             pool.with_connection do |connection|
-              connection.service_id.should_not be nil
-              connection.service_id
+              connection.global_id.should_not be nil
+              connection.global_id
             end
           end
 
           it 'raises a timeout error' do
             expect(Mongo::Server::Connection).to receive(:new).once.and_call_original
-            service_id
+            connection_global_id
 
-            pool.check_out(service_id: service_id)
+            pool.check_out(connection_global_id: connection_global_id)
 
             expect {
-              pool.check_out(service_id: service_id)
+              pool.check_out(connection_global_id: connection_global_id)
             }.to raise_error(Mongo::Error::ConnectionCheckOutTimeout)
 
             expect(pool.size).to eq(1)
@@ -545,13 +612,13 @@ describe Mongo::Server::ConnectionPool do
 
           it 'waits for the timeout' do
             expect(Mongo::Server::Connection).to receive(:new).once.and_call_original
-            service_id
+            connection_global_id
 
-            pool.check_out(service_id: service_id)
+            pool.check_out(connection_global_id: connection_global_id)
 
             start_time = Mongo::Utils.monotonic_time
             expect {
-              pool.check_out(service_id: service_id)
+              pool.check_out(connection_global_id: connection_global_id)
             }.to raise_error(Mongo::Error::ConnectionCheckOutTimeout)
             elapsed_time = Mongo::Utils.monotonic_time - start_time
 

data/spec/mongo/server/connection_spec.rb

@@ -612,6 +612,7 @@ describe Mongo::Server::Connection do
   end
 
   describe '#dispatch' do
+    require_no_required_api_version
 
     let(:server) { monitored_server }
 
@@ -634,50 +635,31 @@ describe Mongo::Server::Connection do
       end
     end
 
-    let(:documents) do
-      [{ 'name' => 'testing' }]
-    end
-
-    let(:insert) do
-      Mongo::Protocol::Insert.new(SpecConfig.instance.test_db, TEST_COLL, documents)
-    end
-
-    let(:query) do
-      Mongo::Protocol::Query.new(SpecConfig.instance.test_db, TEST_COLL, { 'name' => 'testing' })
+    (0..2).each do |i|
+      let("msg#{i}".to_sym) do
+        Mongo::Protocol::Msg.new(
+          [],
+          {},
+          {ping: 1, :$db => SpecConfig.instance.test_db}
+        )
+      end
     end
 
     context 'when providing a single message' do
 
       let(:reply) do
-        connection.dispatch([ query ], context)
-      end
-
-      before do
-        authorized_collection.delete_many
-        authorized_collection.insert_one(name: 'testing')
+        connection.dispatch([ msg0 ], context)
       end
 
       it 'it dispatches the message to the socket' do
-        expect(reply.documents.first['name']).to eq('testing')
+        expect(reply.payload['reply']['ok']).to eq(1.0)
       end
     end
 
     context 'when providing multiple messages' do
 
-      let(:selector) do
-        { :getlasterror => 1 }
-      end
-
-      let(:command) do
-        Mongo::Protocol::Query.new(SpecConfig.instance.test_db, '$cmd', selector, :limit => -1)
-      end
-
       let(:reply) do
-        connection.dispatch([ insert, command ], context)
-      end
-
-      before do
-        authorized_collection.delete_many
+        connection.dispatch([ msg0, msg1 ], context)
       end
 
       it 'raises ArgumentError' do
@@ -689,43 +671,23 @@ describe Mongo::Server::Connection do
 
     context 'when the response_to does not match the request_id' do
 
-      let(:documents) do
-        [{ 'name' => 'bob' }, { 'name' => 'alice' }]
-      end
-
-      let(:insert) do
-        Mongo::Protocol::Insert.new(SpecConfig.instance.test_db, TEST_COLL, documents)
-      end
-
-      let(:query_bob) do
-        Mongo::Protocol::Query.new(SpecConfig.instance.test_db, TEST_COLL, { name: 'bob' })
-      end
-
-      let(:query_alice) do
-        Mongo::Protocol::Query.new(SpecConfig.instance.test_db, TEST_COLL, { name: 'alice' })
-      end
-
       before do
-        authorized_collection.delete_many
-      end
-
-      before do
-        connection.dispatch([ insert ], context)
+        connection.dispatch([ msg0 ], 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 ], context)
+        allow(msg1).to receive(:replyable?) { false }
+        connection.dispatch([ msg1 ], context)
       end
 
       it 'raises an UnexpectedResponse error' do
         expect {
-          connection.dispatch([ query_alice ], context)
+          connection.dispatch([ msg0 ], context)
         }.to raise_error(Mongo::Error::UnexpectedResponse,
           /Got response for request ID \d+ but expected response for request ID \d+/)
       end
 
       it 'marks connection perished' do
         expect {
-          connection.dispatch([ query_alice ], context)
+          connection.dispatch([ msg0 ], context)
         }.to raise_error(Mongo::Error::UnexpectedResponse)
 
         connection.should be_error
@@ -733,11 +695,11 @@ describe Mongo::Server::Connection do
 
       it 'makes the connection no longer usable' do
         expect {
-          connection.dispatch([ query_alice ], context)
+          connection.dispatch([ msg0 ], context)
         }.to raise_error(Mongo::Error::UnexpectedResponse)
 
         expect {
-          connection.dispatch([ query_alice ], context)
+          connection.dispatch([ msg0 ], context)
         }.to raise_error(Mongo::Error::ConnectionPerished)
       end
     end
@@ -745,92 +707,47 @@ describe Mongo::Server::Connection do
     context 'when a request is interrupted (Thread.kill)' do
       require_no_required_api_version
 
-      let(:documents) do
-        [{ 'name' => 'bob' }, { 'name' => 'alice' }]
-      end
-
-      let(:insert) do
-        Mongo::Protocol::Insert.new(SpecConfig.instance.test_db, TEST_COLL, documents)
-      end
-
-      let(:query_bob) do
-        Mongo::Protocol::Query.new(SpecConfig.instance.test_db, TEST_COLL, { name: 'bob' })
-      end
-
-      let(:query_alice) do
-        Mongo::Protocol::Query.new(SpecConfig.instance.test_db, TEST_COLL, { name: 'alice' })
-      end
-
       before do
         authorized_collection.delete_many
-        connection.dispatch([ insert ], context)
+        connection.dispatch([ msg0 ], 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 ], context)
+          connection.dispatch([ msg1 ], context)
         }
         t.join
         allow(Mongo::Protocol::Message).to receive(:deserialize_header).and_call_original
-        resp = connection.dispatch([ query_alice ], context)
-        expect(resp.documents.first['name']).to eq('alice')
+        resp = connection.dispatch([ msg2 ], context)
+        expect(resp.payload['reply']['ok']).to eq(1.0)
       end
     end
 
     context 'when the message exceeds the max size' do
+      require_no_linting
 
-      context 'when the message is an insert' do
-
-        before do
-          allow(connection).to receive(:max_message_size).and_return(200)
-        end
-
-        let(:documents) do
-          [{ 'name' => 'testing' } ] * 10
-        end
-
-        let(:reply) do
-          connection.dispatch([ insert ], context)
-        end
-
-        it 'checks the size against the max message size' do
-          expect {
-            reply
-          }.to raise_exception(Mongo::Error::MaxMessageSize)
-        end
+      let(:command) do
+        Mongo::Protocol::Msg.new(
+          [],
+          {},
+          {ping: 1, padding: 'x'*16384, :$db => SpecConfig.instance.test_db}
+        )
       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
-          # 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
-          Mongo::Protocol::Query.new(SpecConfig.instance.test_db, '$cmd', selector, :limit => -1)
-        end
-
-        let(:reply) do
-          connection.dispatch([ command ], context)
-        end
+      let(:reply) do
+        connection.dispatch([ command ], context)
+      end
 
-        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::Description).to receive(
-            :max_bson_object_size).at_least(:once).and_return(10)
-          expect do
-            reply
-          end.to raise_exception(Mongo::Error::MaxBSONSize)
-        end
+      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::Description).to receive(
+          :max_bson_object_size).at_least(:once).and_return(10)
+        expect do
+          reply
+        end.to raise_exception(Mongo::Error::MaxBSONSize)
       end
     end
 
@@ -861,7 +778,7 @@ describe Mongo::Server::Connection do
 
         let(:result) do
           expect do
-            connection.dispatch([ insert ], context)
+            connection.dispatch([ msg0 ], context)
           end.to raise_error(Mongo::Error::SocketError)
         end
 
@@ -874,10 +791,12 @@ describe Mongo::Server::Connection do
           require_topology :load_balanced
 
           it 'disconnects connection pool for service id' do
-            connection.service_id.should_not be nil
+            connection.global_id.should_not be nil
 
             RSpec::Mocks.with_temporary_scope do
-              expect(server.pool).to receive(:disconnect!).with(service_id: connection.service_id)
+              expect(server.pool).to receive(:disconnect!).with(
+                service_id: connection.service_id
+              )
               result
             end
           end
@@ -918,7 +837,7 @@ describe Mongo::Server::Connection do
 
         let(:result) do
           expect do
-            connection.dispatch([ insert ], context)
+            connection.dispatch([ msg0 ], context)
           end.to raise_error(Mongo::Error::SocketTimeoutError)
         end
 
@@ -991,20 +910,16 @@ describe Mongo::Server::Connection do
           end
         end
 
-        let(:message) do
-          insert
-        end
-
         before do
-          expect(message).to receive(:replyable?) { false }
-          connection.send(:deliver, message, context)
+          expect(msg0).to receive(:replyable?) { false }
+          connection.send(:deliver, msg0, context)
 
           connection.send(:socket).instance_variable_set(:@timeout, -(Time.now.to_i))
         end
 
         let(:reply) do
           Mongo::Protocol::Message.deserialize(connection.send(:socket),
-            16*1024*1024, message.request_id)
+            16*1024*1024, msg0.request_id)
         end
 
         it 'raises a timeout error' do
@@ -1014,30 +929,6 @@ describe Mongo::Server::Connection do
         end
       end
     end
-
-=begin this is now handled by connection pool
-    context 'when the process is forked' do
-
-      let(:insert) do
-        Mongo::Protocol::Insert.new(SpecConfig.instance.test_db, TEST_COLL, documents)
-      end
-
-      before do
-        authorized_collection.delete_many
-        expect(Process).to receive(:pid).at_least(:once).and_return(1)
-      end
-
-      it 'disconnects the connection' do
-        expect(connection).to receive(:disconnect!).and_call_original
-        connection.dispatch([ insert ])
-      end
-
-      it 'sets a new pid' do
-        connection.dispatch([ insert ])
-        expect(connection.send(:pid)).to eq(1)
-      end
-    end
-=end
   end
 
   describe '#initialize' do

data/spec/mongo/server/description/features_spec.rb

@@ -247,4 +247,28 @@ describe Mongo::Server::Description::Features do
       end
     end
   end
+
+  describe '#get_more_comment_enabled?' do
+    context 'when the wire range includes 9' do
+
+      let(:wire_versions) do
+        0..9
+      end
+
+      it 'returns true' do
+        expect(features).to be_get_more_comment_enabled
+      end
+    end
+
+    context 'when the wire range does not include 9' do
+
+      let(:wire_versions) do
+        0..8
+      end
+
+      it 'returns false' do
+        expect(features).to_not be_get_more_comment_enabled
+      end
+    end
+  end
 end

data/spec/mongo/server/push_monitor_spec.rb

@@ -77,7 +77,7 @@ describe Mongo::Server::PushMonitor do
         end.should_not raise_error
       end
 
-      it 'throttles checks' do
+      it 'stops the monitoring' do
         push_monitor
 
         start = Mongo::Utils.monotonic_time
@@ -87,13 +87,7 @@ describe Mongo::Server::PushMonitor do
           push_monitor.do_work
         end.should_not raise_error
 
-        expect(Socket).to receive(:getaddrinfo).and_raise(SocketError.new('Test exception'))
-        lambda do
-          push_monitor.do_work
-        end.should_not raise_error
-
-        elapsed = Mongo::Utils.monotonic_time - start
-        elapsed.should > 0.5
+        push_monitor.running?.should be false
       end
     end
   end