mongo 2.15.0 → 2.18.1

data/spec/mongo/server/connection_spec.rb

@@ -9,6 +9,10 @@ describe Mongo::Server::Connection do
 
   clean_slate_for_all
 
+  let(:generation_manager) do
+    Mongo::Server::ConnectionPool::GenerationManager.new(server: server)
+  end
+
   let!(:address) do
     default_address
   end
@@ -41,7 +45,10 @@ describe Mongo::Server::Connection do
   let(:server_options) { SpecConfig.instance.test_options.merge(monitoring_io: false) }
   let(:server) do
     register_server(
-      Mongo::Server.new(address, cluster, monitoring, listeners, server_options)
+      Mongo::Server.new(address, cluster, monitoring, listeners, server_options.merge(
+        # Normally the load_balancer option is set by the cluster
+        load_balancer: ClusterConfig.instance.topology == :load_balanced,
+      ))
     )
   end
 
@@ -59,6 +66,7 @@ describe Mongo::Server::Connection do
   let(:pool) do
     double('pool').tap do |pool|
       allow(pool).to receive(:close)
+      allow(pool).to receive(:generation_manager).and_return(generation_manager)
     end
   end
 
@@ -81,7 +89,7 @@ describe Mongo::Server::Connection do
     context 'when no socket exists' do
 
       let(:connection) do
-        described_class.new(server, server.options)
+        described_class.new(server, server.options.merge(connection_pool: pool))
       end
 
       let(:result) do
@@ -226,12 +234,15 @@ describe Mongo::Server::Connection do
 
       context 'when #handshake! dependency raises a network exception' do
         let(:exception) do
-          Mongo::Error::SocketError.new
+          Mongo::Error::SocketError.new.tap do |exc|
+            allow(exc).to receive(:service_id).and_return('fake')
+          end
         end
 
         let(:error) do
           # The exception is mutated when notes are added to it
-          expect_any_instance_of(Mongo::Socket).to receive(:write).and_raise(exception.dup)
+          expect_any_instance_of(Mongo::Socket).to receive(:write).and_raise(exception)
+          allow(connection).to receive(:service_id).and_return('fake')
           begin
             connection.connect!
           rescue Exception => e
@@ -310,7 +321,7 @@ describe Mongo::Server::Connection do
     context 'when a socket exists' do
 
       let(:connection) do
-        described_class.new(server, server.options)
+        described_class.new(server, server.options.merge(connection_pool: pool))
       end
 
       let(:socket) do
@@ -369,10 +380,12 @@ describe Mongo::Server::Connection do
           described_class.new(
             server,
             SpecConfig.instance.test_options.merge(
-              :user => 'notauser',
-              :password => 'password',
-              :database => SpecConfig.instance.test_db,
-              :heartbeat_frequency => 30)
+              user: 'notauser',
+              password: 'password',
+              database: SpecConfig.instance.test_db,
+              heartbeat_frequency: 30,
+              connection_pool: pool,
+            )
           )
         end
 
@@ -448,8 +461,16 @@ describe Mongo::Server::Connection do
           )
         end
 
+        let(:exception) do
+          Mongo::Error::SocketError.new.tap do |exc|
+            if server.load_balancer?
+              allow(exc).to receive(:service_id).and_return('fake')
+            end
+          end
+        end
+
         let(:error) do
-          expect_any_instance_of(auth_mechanism).to receive(:login).and_raise(Mongo::Error::SocketError)
+          expect_any_instance_of(auth_mechanism).to receive(:login).and_raise(exception)
           begin
             connection.send(:connect!)
           rescue => ex
@@ -473,9 +494,11 @@ describe Mongo::Server::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 )
+              user: SpecConfig.instance.test_user.name,
+              password: SpecConfig.instance.test_user.password,
+              database: SpecConfig.instance.test_user.database,
+              connection_pool: pool,
+            )
           )
         end
 
@@ -563,7 +586,7 @@ describe Mongo::Server::Connection do
     context 'when a socket is not connected' do
 
       let(:connection) do
-        described_class.new(server, server.options)
+        described_class.new(server, server.options.merge(connection_pool: pool))
       end
 
       it 'does not raise an error' do
@@ -574,7 +597,7 @@ describe Mongo::Server::Connection do
     context 'when a socket is connected' do
 
       let(:connection) do
-        described_class.new(server, server.options)
+        described_class.new(server, server.options.merge(connection_pool: pool))
       end
 
       before do
@@ -589,6 +612,7 @@ describe Mongo::Server::Connection do
   end
 
   describe '#dispatch' do
+    require_no_required_api_version
 
     let(:server) { monitored_server }
 
@@ -598,7 +622,8 @@ describe Mongo::Server::Connection do
       described_class.new(
         server,
         SpecConfig.instance.test_options.merge(
-          :database => SpecConfig.instance.test_user.database,
+          database: SpecConfig.instance.test_user.database,
+          connection_pool: pool,
         ).merge(Mongo::Utils.shallow_symbolize_keys(Mongo::Client.canonicalize_ruby_options(
           SpecConfig.instance.credentials_or_external_user(
             user: SpecConfig.instance.test_user.name,
@@ -610,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
@@ -665,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
@@ -709,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
@@ -721,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
 
@@ -817,8 +758,10 @@ describe Mongo::Server::Connection do
           # of the test, i.e. to avoid racing with the monitor thread
           # which may put the server back into non-unknown state before
           # we can verify that the server was marked unknown, kill off
-          # the monitor thread
-          server.monitor.instance_variable_get('@thread').kill
+          # the monitor thread.
+          unless ClusterConfig.instance.topology == :load_balanced
+            server.monitor.instance_variable_get('@thread').kill
+          end
         end
       end
 
@@ -835,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
 
@@ -844,27 +787,46 @@ describe Mongo::Server::Connection do
           expect(connection).to be_error
         end
 
-        it 'disconnects connection pool' do
-          expect(server.pool).to receive(:disconnect!)
-          result
+        context 'in load-balanced topology' do
+          require_topology :load_balanced
+
+          it 'disconnects connection pool for service id' do
+            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
+              )
+              result
+            end
+          end
+
+          it 'does not mark server unknown' do
+            expect(server).not_to be_unknown
+            result
+            expect(server).not_to be_unknown
+          end
         end
 
-        it 'marks server unknown' do
-          expect(server).not_to be_unknown
-          result
-          expect(server).to be_unknown
+        context 'in non-lb topologies' do
+          require_topology :single, :replica_set, :sharded
+
+          it 'disconnects connection pool' do
+            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
         end
 
         it 'does not request server scan' do
           expect(server.scan_semaphore).not_to receive(:signal)
           result
         end
-
-        it 'marks server unknown' do
-          expect(server).not_to be_unknown
-          result
-          expect(server).to be_unknown
-        end
       end
 
       context 'when a socket timeout occurs' do
@@ -875,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
 
@@ -943,25 +905,21 @@ describe Mongo::Server::Connection do
       context 'when the socket_timeout is negative' do
 
         let(:connection) do
-          described_class.new(server, server.options).tap do |connection|
+          described_class.new(server, server.options.merge(connection_pool: pool)).tap do |connection|
             connection.connect!
           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
@@ -971,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
@@ -1002,7 +936,7 @@ describe Mongo::Server::Connection do
     context 'when host and port are provided' do
 
       let(:connection) do
-        described_class.new(server, server.options)
+        described_class.new(server, server.options.merge(connection_pool: pool))
       end
 
       it 'sets the address' do
@@ -1017,7 +951,7 @@ describe Mongo::Server::Connection do
         it 'use incrementing ids' do
           expect(connection.id).to eq(1)
 
-          second_connection = described_class.new(server, server.options)
+          second_connection = described_class.new(server, server.options.merge(connection_pool: pool))
           expect(second_connection.id).to eq(2)
         end
       end
@@ -1025,7 +959,11 @@ describe Mongo::Server::Connection do
       context 'two pools for different servers' do
         let(:server2) do
           register_server(
-            Mongo::Server.new(address, cluster, monitoring, listeners, server_options)
+            Mongo::Server.new(address, cluster, monitoring, listeners,
+              server_options.merge(
+                load_balancer: ClusterConfig.instance.topology == :load_balanced,
+              )
+            )
           )
         end
 
@@ -1119,10 +1057,11 @@ describe Mongo::Server::Connection do
       let(:connection) do
         described_class.new(
           server,
-          :user => SpecConfig.instance.test_user.name,
-          :password => SpecConfig.instance.test_user.password,
-          :database => SpecConfig.instance.test_db,
-          :auth_mech => :mongodb_cr,
+          user: SpecConfig.instance.test_user.name,
+          password: SpecConfig.instance.test_user.password,
+          database: SpecConfig.instance.test_db,
+          auth_mech: :mongodb_cr,
+          connection_pool: pool,
         )
       end
 
@@ -1155,7 +1094,7 @@ describe Mongo::Server::Connection do
     end
 
     let(:connection) do
-      described_class.new(server, server.options)
+      described_class.new(server, server.options.merge(connection_pool: pool))
     end
 
     context 'when a connect_timeout is in the options' do
@@ -1244,7 +1183,7 @@ describe Mongo::Server::Connection do
   describe '#app_metadata' do
     context 'when all options are identical to server' do
       let(:connection) do
-        described_class.new(server, server.options)
+        described_class.new(server, server.options.merge(connection_pool: pool))
       end
 
       it 'is the same object as server app_metadata' do
@@ -1255,7 +1194,7 @@ describe Mongo::Server::Connection do
 
     context 'when auth options are identical to server' do
       let(:connection) do
-        described_class.new(server, server.options.merge(socket_timeout: 2))
+        described_class.new(server, server.options.merge(socket_timeout: 2, connection_pool: pool))
       end
 
       it 'is the same object as server app_metadata' do
@@ -1268,7 +1207,7 @@ describe Mongo::Server::Connection do
       require_no_external_user
 
       let(:connection) do
-        described_class.new(server, server.options.merge(user: 'foo'))
+        described_class.new(server, server.options.merge(user: 'foo', connection_pool: pool))
       end
 
       it 'is different object from server app_metadata' do
@@ -1282,4 +1221,51 @@ describe Mongo::Server::Connection do
       end
     end
   end
+
+  describe '#generation' do
+
+    context 'non-lb' do
+      require_topology :single, :replica_set, :sharded
+
+      it 'is set' do
+        server.with_connection do |conn|
+          conn.service_id.should be nil
+          conn.generation.should be_a(Integer)
+        end
+      end
+
+      context 'clean slate' do
+        clean_slate
+
+        it 'starts from 1' do
+          server.with_connection do |conn|
+            conn.service_id.should be nil
+            conn.generation.should == 1
+          end
+        end
+      end
+    end
+
+    context 'lb' do
+      require_topology :load_balanced
+
+      it 'is set' do
+        server.with_connection do |conn|
+          conn.service_id.should_not be nil
+          conn.generation.should be_a(Integer)
+        end
+      end
+
+      context 'clean slate' do
+        clean_slate
+
+        it 'starts from 1' do
+          server.with_connection do |conn|
+            conn.service_id.should_not be nil
+            conn.generation.should == 1
+          end
+        end
+      end
+    end
+  end
 end

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