mongo 2.15.0 → 2.16.1

data/spec/mongo/server/connection_common_spec.rb

@@ -1,24 +1,75 @@
 # frozen_string_literal: true
 # encoding: utf-8
 
-require 'spec_helper'
+require 'lite_spec_helper'
 
 describe Mongo::Server::ConnectionCommon do
   let(:subject) { described_class.new }
 
+  let(:metadata) do
+    Mongo::Server::AppMetadata.new({})
+  end
+
   describe '#handshake_document' do
-    it 'returns hello document with API version' do
-      meta = Mongo::Server::AppMetadata.new({
-        server_api: { version: '1'  }
-      })
-      document = subject.handshake_document(meta)
-      expect(document['hello']).to eq(1)
+    let(:document) do
+      subject.handshake_document(metadata)
+    end
+
+    context 'with api version' do
+      let(:metadata) do
+        Mongo::Server::AppMetadata.new({
+          server_api: { version: '1'  }
+        })
+      end
+
+      it 'returns hello document with API version' do
+        expect(document['hello']).to eq(1)
+      end
+    end
+
+    context 'without api version' do
+      it 'returns legacy hello document without API version' do
+        expect(document['isMaster']).to eq(1)
+      end
+    end
+
+    context 'when connecting to load balancer' do
+
+      let(:document) do
+        subject.handshake_document(metadata, load_balancer: true)
+      end
+
+      it 'includes loadBalanced: true' do
+        document['loadBalanced'].should be true
+      end
+    end
+  end
+
+  describe '#handshake_command' do
+    let(:document) do
+      subject.handshake_document(metadata)
+    end
+
+    context 'with api version' do
+      let(:metadata) do
+        Mongo::Server::AppMetadata.new({
+          server_api: { version: '1'  }
+        })
+      end
+
+      it 'returns OP_MSG command' do
+        expect(
+          subject.handshake_command(document)
+        ).to be_a(Mongo::Protocol::Msg)
+      end
     end
 
-    it 'returns legacy hello document without API version' do
-      meta = Mongo::Server::AppMetadata.new({})
-      document = subject.handshake_document(meta)
-      expect(document['isMaster']).to eq(1)
+    context 'without api version' do
+      it 'returns OP_QUERY command' do
+        expect(
+          subject.handshake_command(document)
+        ).to be_a(Mongo::Protocol::Query)
+      end
     end
   end
 end

data/spec/mongo/server/connection_pool_spec.rb

@@ -317,6 +317,11 @@ describe Mongo::Server::ConnectionPool do
     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)
       end
@@ -349,6 +354,11 @@ describe Mongo::Server::ConnectionPool do
     end
 
     context 'connection of earlier generation than 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
+
       let(:connection) do
         pool.check_out.tap do |connection|
           expect(connection).to receive(:generation).at_least(:once).and_return(0)
@@ -364,6 +374,11 @@ describe Mongo::Server::ConnectionPool do
     end
 
     context 'connection of later generation than 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
+
       let(:connection) do
         pool.check_out.tap do |connection|
           expect(connection).to receive(:generation).at_least(:once).and_return(7)
@@ -449,6 +464,11 @@ describe Mongo::Server::ConnectionPool do
     end
 
     context 'when there is an available connection which is stale' 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
+
       let(:options) do
         { max_pool_size: 2, max_idle_time: 0.1 }
       end
@@ -489,13 +509,54 @@ describe Mongo::Server::ConnectionPool do
 
       context 'when the max size is reached' do
 
-        it 'raises a timeout error' do
-          expect(Mongo::Server::Connection).to receive(:new).once.and_call_original
-          expect {
-            pool.check_out
+        context 'without service_id' do
+          it 'raises a timeout error' do
+            expect(Mongo::Server::Connection).to receive(:new).once.and_call_original
             pool.check_out
-          }.to raise_error(::Timeout::Error)
-          expect(pool.size).to eq(1)
+            expect {
+              pool.check_out
+            }.to raise_error(::Timeout::Error)
+            expect(pool.size).to eq(1)
+          end
+        end
+
+        context 'with service_id' do
+          require_topology :load_balanced
+
+          let(:service_id) do
+            pool.with_connection do |connection|
+              connection.service_id.should_not be nil
+              connection.service_id
+            end
+          end
+
+          it 'raises a timeout error' do
+            expect(Mongo::Server::Connection).to receive(:new).once.and_call_original
+            service_id
+
+            pool.check_out(service_id: service_id)
+
+            expect {
+              pool.check_out(service_id: service_id)
+            }.to raise_error(Mongo::Error::ConnectionCheckOutTimeout)
+
+            expect(pool.size).to eq(1)
+          end
+
+          it 'waits for the timeout' do
+            expect(Mongo::Server::Connection).to receive(:new).once.and_call_original
+            service_id
+
+            pool.check_out(service_id: service_id)
+
+            start_time = Mongo::Utils.monotonic_time
+            expect {
+              pool.check_out(service_id: service_id)
+            }.to raise_error(Mongo::Error::ConnectionCheckOutTimeout)
+            elapsed_time = Mongo::Utils.monotonic_time - start_time
+
+            elapsed_time.should > 1
+          end
         end
       end
     end
@@ -541,7 +602,7 @@ describe Mongo::Server::ConnectionPool do
        it 'raises an error and emits ConnectionCheckOutFailedEvent' do
         pool
 
-        subscriber = EventSubscriber.new
+        subscriber = Mrss::EventSubscriber.new
         client.subscribe(Mongo::Monitoring::CONNECTION_POOL, subscriber)
 
         subscriber.clear_events!
@@ -579,6 +640,11 @@ describe Mongo::Server::ConnectionPool do
     end
 
     shared_examples_for 'disconnects and removes all connections in the pool and bumps generation' 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
+
       it 'disconnects and removes and bumps' do
         old_connections = []
         pool.instance_variable_get('@available_connections').each do |connection|

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
@@ -598,7 +621,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,
@@ -817,8 +841,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
 
@@ -844,27 +870,44 @@ 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.service_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
@@ -943,7 +986,7 @@ 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
@@ -1002,7 +1045,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 +1060,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 +1068,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 +1166,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 +1203,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 +1292,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 +1303,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 +1316,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 +1330,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_spec.rb

@@ -331,7 +331,7 @@ describe Mongo::Server::Description do
       describe '#average_round_trip_time' do
 
         let(:description) do
-          described_class.new(address, { 'secondary' => false }, 4.5)
+          described_class.new(address, { 'secondary' => false }, average_round_trip_time: 4.5)
         end
 
         it 'defaults to nil' do

data/spec/mongo/server/monitor/connection_spec.rb

@@ -136,6 +136,28 @@ describe Mongo::Server::Monitor::Connection do
     end
   end
 
+  describe '#connect!' do
+
+    let(:options) do
+      SpecConfig.instance.test_options.merge(
+        app_metadata: monitor_app_metadata,
+      )
+    end
+
+    context 'when address resolution fails' do
+      let(:connection) { described_class.new(server.address, options) }
+
+      it 'propagates the exception' do
+        connection
+
+        expect(Socket).to receive(:getaddrinfo).and_raise(SocketError.new('Test exception'))
+        lambda do
+          connection.connect!
+        end.should raise_error(SocketError, 'Test exception')
+      end
+    end
+  end
+
   describe '#check_document' do
     context 'with API version' do
       let(:meta) do

data/spec/mongo/server/monitor_spec.rb

@@ -186,16 +186,17 @@ describe Mongo::Server::Monitor do
     context 'when running after a stop' do
       it 'starts the thread' do
         ClientRegistry.instance.close_all_clients
+        sleep 1
         thread
-        sleep 0.5
+        sleep 1
 
         RSpec::Mocks.with_temporary_scope do
           expect(monitor.connection).to receive(:disconnect!).and_call_original
           monitor.stop!
-          sleep 0.5
+          sleep 1
           expect(thread.alive?).to be false
           new_thread = monitor.run!
-          sleep 0.5
+          sleep 1
           expect(new_thread.alive?).to be(true)
         end
       end