mongo 2.10.5 → 2.11.0.rc0

data/spec/mongo/server/connection_spec.rb

@@ -31,9 +31,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)
-      pool = double('pool')
-      allow(pool).to receive(:disconnect!)
-      allow(cl).to receive(:pool).and_return(pool)
+      allow(cl).to receive(:run_sdam_flow)
     end
   end
 
@@ -41,31 +39,31 @@ describe Mongo::Server::Connection, retry: 3 do
 
   let(:server_options) { SpecConfig.instance.test_options.merge(monitoring_io: false) }
   let(:server) do
-    Mongo::Server.new(address, cluster, monitoring, listeners, server_options)
+    register_server(
+      Mongo::Server.new(address, cluster, monitoring, listeners, server_options)
+    )
   end
 
   let(:monitored_server) do
-    Mongo::Server.new(address, cluster, monitoring, listeners,
-      SpecConfig.instance.test_options
-    ).tap do |server|
-      server.scan!
-      expect(server).not_to be_unknown
-    end
+    register_server(
+      Mongo::Server.new(address, cluster, monitoring, listeners,
+        SpecConfig.instance.test_options.merge(monitoring_io: false)
+      ).tap do |server|
+        allow(server).to receive(:description).and_return(ClusterConfig.instance.primary_description)
+        expect(server).not_to be_unknown
+      end
+    )
   end
 
   let(:pool) do
-    double('pool')
+    double('pool').tap do |pool|
+      allow(pool).to receive(:close)
+    end
   end
 
   describe '#connect!' do
 
     shared_examples_for 'keeps server type and topology' do
-      before do
-        # we want the server to not start in unknown state,
-        # hence scan it and transition to some other state here
-        server.scan!
-      end
-
       it 'does not mark server unknown' do
         expect(server).not_to receive(:unknown!)
         error
@@ -73,12 +71,6 @@ describe Mongo::Server::Connection, retry: 3 do
     end
 
     shared_examples_for 'marks server unknown' do
-      before do
-        # we want the server to not start in unknown state,
-        # hence scan it and transition to some other state here
-        server.scan!
-      end
-
       it 'marks server unknown' do
         expect(server).to receive(:unknown!)
         error
@@ -281,7 +273,7 @@ describe Mongo::Server::Connection, retry: 3 do
 
     shared_examples_for 'disconnects connection pool' do
       it 'disconnects non-monitoring sockets' do
-        expect(server).to receive(:pool).and_return(pool)
+        expect(server).to receive(:pool).at_least(:once).and_return(pool)
         expect(pool).to receive(:disconnect!).and_return(true)
         error
       end
@@ -571,7 +563,7 @@ describe Mongo::Server::Connection, retry: 3 do
 
           expect do
             connection.dispatch([ query_alice ]).documents
-          end.to raise_error(Mongo::Error::LintError, 'Reconnecting closed connections is no longer supported')
+          end.to raise_error(Mongo::Error::LintError, /Reconnecting closed connections is no longer supported.*/)
         end
       end
 
@@ -708,13 +700,12 @@ describe Mongo::Server::Connection, retry: 3 do
         end
 
         it 'disconnects connection pool' do
-          # Allow multiple calls due to RUBY-1894 backport
-          expect(server.pool).to receive(:disconnect!).at_least(:once)
+          expect(server.pool).to receive(:disconnect!)
           result
         end
 
         it 'does not request server scan' do
-          expect(server.monitor.scan_semaphore).not_to receive(:signal)
+          expect(server.scan_semaphore).not_to receive(:signal)
           result
         end
 
@@ -875,7 +866,9 @@ describe Mongo::Server::Connection, retry: 3 do
 
       context 'two pools for different servers' do
         let(:server2) do
-          Mongo::Server.new(address, cluster, monitoring, listeners, server_options)
+          register_server(
+            Mongo::Server.new(address, cluster, monitoring, listeners, server_options)
+          )
         end
 
         it 'ids do not share namespace' do
@@ -1000,10 +993,6 @@ describe Mongo::Server::Connection, retry: 3 do
       described_class.new(server, server.options)
     end
 
-    after do
-      client.close(true)
-    end
-
     context 'when a connect_timeout is in the options' do
 
       context 'when a socket_timeout is in the options' do

data/spec/mongo/server/description_spec.rb

@@ -56,7 +56,7 @@ describe Mongo::Server::Description do
         expect(Time).to receive(:now).at_least(:once).and_return(obj)
         expect(obj.frozen?).to be false
 
-        description = described_class.new(address)
+        description = described_class.new(address, replica)
         expect(description.last_update_time).to eq(obj)
         expect(obj.frozen?).to be false
       end
@@ -433,6 +433,23 @@ describe Mongo::Server::Description do
       it 'returns :sharded' do
         expect(description.server_type).to eq(:sharded)
       end
+
+      context 'when client and server addresses are different' do
+        let(:config) do
+          { 'msg' => 'isdbgrid', 'ismaster' => true,
+            'minWireVersion' => 2, 'maxWireVersion' => 3, 'ok' => 1,
+            'me' => '127.0.0.1',
+          }
+        end
+
+        let(:address) do
+          Mongo::Address.new('localhost')
+        end
+
+        it 'returns :sharded' do
+          expect(description.server_type).to eq(:sharded)
+        end
+      end
     end
 
     context 'when the server is a primary' do
@@ -516,7 +533,8 @@ describe Mongo::Server::Description do
     end
 
     let(:server) do
-      Mongo::Server.new(address, cluster, monitoring, listeners)
+      Mongo::Server.new(address, cluster, monitoring, listeners,
+        monitoring_io: false)
     end
 
     let(:description) do
@@ -537,7 +555,8 @@ describe Mongo::Server::Description do
       end
 
       let(:server) do
-        Mongo::Server.new(other_address, cluster, monitoring, listeners)
+        Mongo::Server.new(other_address, cluster, monitoring, listeners,
+          monitoring_io: false)
       end
 
       it 'returns false' do
@@ -603,7 +622,8 @@ describe Mongo::Server::Description do
     end
 
     let(:server) do
-      Mongo::Server.new(server_address, cluster, monitoring, listeners)
+      Mongo::Server.new(server_address, cluster, monitoring, listeners,
+        monitoring_io: false)
     end
 
     context 'when the server is included in the description hosts list' do
@@ -774,4 +794,22 @@ describe Mongo::Server::Description do
       end
     end
   end
+
+  describe '#last_update_time' do
+    context 'stub description' do
+      let(:description) { described_class.new(address) }
+
+      it 'is present' do
+        expect(description.last_update_time).to be_a(Time)
+      end
+    end
+
+    context 'filled out description' do
+      let(:description) { described_class.new(address, replica) }
+
+      it 'is present' do
+        expect(description.last_update_time).to be_a(Time)
+      end
+    end
+  end
 end

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

@@ -4,7 +4,7 @@ describe Mongo::Server::Monitor::Connection do
   clean_slate
 
   let(:address) do
-    Mongo::Address.new(ClusterConfig.instance.primary_address, options)
+    Mongo::Address.new(ClusterConfig.instance.primary_address_str, options)
   end
 
   declare_topology_double
@@ -14,17 +14,28 @@ describe Mongo::Server::Monitor::Connection do
       allow(cl).to receive(:topology).and_return(topology)
       allow(cl).to receive(:app_metadata).and_return(Mongo::Server::Monitor::AppMetadata.new({}))
       allow(cl).to receive(:options).and_return({})
+      allow(cl).to receive(:heartbeat_interval).and_return(1000)
+      allow(cl).to receive(:run_sdam_flow)
     end
   end
 
   let(:server) do
     Mongo::Server.new(address,
-                      cluster,
-                      Mongo::Monitoring.new,
-                      Mongo::Event::Listeners.new, options)
+      cluster,
+      Mongo::Monitoring.new,
+      Mongo::Event::Listeners.new, {monitoring_io: false}.update(options))
   end
 
-  let(:monitor) { server.monitor }
+  let(:monitor) do
+    register_background_thread_object(
+      Mongo::Server::Monitor.new(server, server.event_listeners, server.monitoring,
+        {
+          app_metadata: Mongo::Server::Monitor::AppMetadata.new(options),
+        }.update(options))
+    ).tap do |monitor|
+      monitor.run!
+    end
+  end
 
   let(:connection) do
     # NB this connection is set up in the background thread,
@@ -32,10 +43,10 @@ describe Mongo::Server::Monitor::Connection do
     # we must wait here for the connection to be established.
     # Do not call connect! on this connection as then the main thread
     # will be racing the monitoring thread to connect.
-    server.monitor.connection.tap do |connection|
+    monitor.connection.tap do |connection|
       expect(connection).not_to be nil
 
-      deadline = Time.now + 1
+      deadline = Time.now + 5
       while Time.now < deadline
         if connection.send(:socket)
           break
@@ -168,9 +179,8 @@ describe Mongo::Server::Monitor::Connection do
     context 'network error' do
       before do
         address
-        server.monitor.instance_variable_get('@thread').kill
-        server.monitor.connection.disconnect!
-        expect_any_instance_of(Mongo::Socket).to receive(:write).and_raise(Mongo::Error::SocketError, 'test error')
+        monitor.instance_variable_get('@thread').kill
+        monitor.connection.disconnect!
       end
 
       let(:options) { SpecConfig.instance.test_options }
@@ -178,9 +188,10 @@ describe Mongo::Server::Monitor::Connection do
       let(:expected_message) { "MONGODB | Failed to handshake with #{address}: Mongo::Error::SocketError: test error" }
 
       it 'logs a warning' do
+        expect_any_instance_of(Mongo::Socket).to receive(:write).and_raise(Mongo::Error::SocketError, 'test error')
         expect(Mongo::Logger.logger).to receive(:warn).with(expected_message).and_call_original
         expect do
-          server.monitor.connection.connect!
+          monitor.connection.connect!
         end.to raise_error(Mongo::Error::SocketError, 'test error')
       end
     end

data/spec/mongo/server/monitor_spec.rb

@@ -13,15 +13,33 @@ describe Mongo::Server::Monitor do
     Mongo::Event::Listeners.new
   end
 
+  let(:monitor_options) do
+    {}
+  end
+
+  let(:cluster) do
+    double('cluster').tap do |cluster|
+      allow(cluster).to receive(:run_sdam_flow)
+      allow(cluster).to receive(:heartbeat_interval).and_return(1000)
+    end
+  end
+
+  let(:server) do
+    Mongo::Server.new(address, cluster, Mongo::Monitoring.new, listeners,
+      monitoring_io: false)
+  end
+
+  let(:monitor) do
+    register_background_thread_object(
+      described_class.new(server, listeners, Mongo::Monitoring.new,
+        SpecConfig.instance.test_options.merge(cluster: cluster).merge(monitor_options))
+    )
+  end
+
   describe '#scan!' do
 
     context 'when calling multiple times in succession' do
 
-      let(:monitor) do
-        described_class.new(address, listeners, Mongo::Monitoring.new,
-          SpecConfig.instance.test_options)
-      end
-
       it 'throttles the scans to minimum 500ms' do
         start = Time.now
         monitor.scan!
@@ -32,9 +50,8 @@ describe Mongo::Server::Monitor do
 
     context 'when the ismaster fails the first time' do
 
-      let(:monitor) do
-        described_class.new(address, listeners, Mongo::Monitoring.new,
-          SpecConfig.instance.test_options.merge(monitoring_io: false))
+      let(:monitor_options) do
+        {monitoring_io: false}
       end
 
       let(:socket) do
@@ -42,70 +59,27 @@ describe Mongo::Server::Monitor do
         monitor.connection.__send__(:socket)
       end
 
-      before do
+      it 'retries the ismaster' do
         expect(socket).to receive(:write).once.and_raise(Mongo::Error::SocketError)
         expect(socket).to receive(:write).and_call_original
+        expect(cluster).to receive(:run_sdam_flow)
         monitor.scan!
       end
-
-      context 'in single topology' do
-        require_topology :single
-
-        it 'retries the ismaster' do
-          expect(monitor.description).to be_standalone
-        end
-      end
-
-      context 'in replica set topology' do
-        require_topology :replica_set
-
-        it 'retries the ismaster' do
-          expect(monitor.description).to be_primary
-        end
-      end
-
-      context 'in sharded topology' do
-        require_topology :sharded
-
-        it 'retries the ismaster' do
-          expect(monitor.description).to be_mongos
-        end
-      end
     end
 
     context 'when the ismaster command succeeds' do
 
-      let(:monitor) do
-        described_class.new(address, listeners, Mongo::Monitoring.new,
-          SpecConfig.instance.test_options)
-      end
-
-      before do
-        monitor.scan!
-      end
-
-      context 'in single topology' do
-        require_topology :single
+      it 'invokes sdam flow' do
+        server.unknown!
+        expect(server.description).to be_unknown
 
-        it 'updates the server description' do
-          expect(monitor.description).to be_standalone
+        updated_desc = nil
+        expect(cluster).to receive(:run_sdam_flow) do |prev_desc, _updated_desc|
+          updated_desc = _updated_desc
         end
-      end
-
-      context 'in replica set topology' do
-        require_topology :replica_set
-
-        it 'updates the server description' do
-          expect(monitor.description).to be_primary
-        end
-      end
-
-      context 'in sharded topology' do
-        require_topology :sharded
+        monitor.scan!
 
-        it 'updates the server description' do
-          expect(monitor.description).to be_mongos
-        end
+        expect(updated_desc).not_to be_unknown
       end
     end
 
@@ -113,33 +87,27 @@ describe Mongo::Server::Monitor do
 
       context 'when no server is running on the address' do
 
-        let(:bad_address) do
+        let(:address) do
           Mongo::Address.new('127.0.0.1:27050')
         end
 
-        let(:monitor) do
-          described_class.new(bad_address, listeners, Mongo::Monitoring.new)
-        end
-
         before do
+          server.unknown!
+          expect(server.description).to be_unknown
           monitor.scan!
         end
 
         it 'keeps the server unknown' do
-          expect(monitor.description).to be_unknown
+          expect(server.description).to be_unknown
         end
       end
 
       context 'when the socket gets an exception' do
 
-        let(:bad_address) do
+        let(:address) do
           default_address
         end
 
-        let(:monitor) do
-          described_class.new(bad_address, listeners, Mongo::Monitoring.new)
-        end
-
         let(:socket) do
           monitor.connection.connect!
           monitor.connection.__send__(:socket)
@@ -147,11 +115,13 @@ describe Mongo::Server::Monitor do
 
         before do
           expect(socket).to receive(:write).twice.and_raise(Mongo::Error::SocketError)
+          server.unknown!
+          expect(server.description).to be_unknown
           monitor.scan!
         end
 
         it 'keeps the server unknown' do
-          expect(monitor.description).to be_unknown
+          expect(server.description).to be_unknown
         end
 
         it 'disconnects the connection' do
@@ -161,12 +131,13 @@ describe Mongo::Server::Monitor do
     end
   end
 
+=begin heartbeat interval is now taken out of cluster, monitor has no useful options
   describe '#heartbeat_frequency' do
 
     context 'when an option is provided' do
 
-      let(:monitor) do
-        described_class.new(address, listeners, Mongo::Monitoring.new, :heartbeat_frequency => 5)
+      let(:monitor_options) do
+        {:heartbeat_frequency => 5}
       end
 
       it 'returns the option' do
@@ -176,8 +147,8 @@ describe Mongo::Server::Monitor do
 
     context 'when no option is provided' do
 
-      let(:monitor) do
-        described_class.new(address, listeners, Mongo::Monitoring.new)
+      let(:monitor_options) do
+        {:heartbeat_frequency => nil}
       end
 
       it 'defaults to 10' do
@@ -185,29 +156,10 @@ describe Mongo::Server::Monitor do
       end
     end
   end
-
-  describe '#run!' do
-
-    let(:monitor) do
-      described_class.new(address, listeners, Mongo::Monitoring.new, :heartbeat_frequency => 1)
-    end
-
-    before do
-      monitor.run!
-      sleep(1)
-    end
-
-    it 'refreshes the server on the provided interval' do
-      expect(monitor.description).to_not be_nil
-    end
-  end
+=end
 
   describe '#restart!' do
 
-    let(:monitor) do
-      described_class.new(address, listeners, Mongo::Monitoring.new, SpecConfig.instance.test_options)
-    end
-
     let!(:thread) do
       monitor.run!
     end
@@ -233,10 +185,6 @@ describe Mongo::Server::Monitor do
   end
 
   describe '#stop' do
-    let(:monitor) do
-      described_class.new(address, listeners, Mongo::Monitoring.new,
-        SpecConfig.instance.test_options)
-    end
 
     let(:thread) do
       monitor.run!
@@ -245,10 +193,13 @@ describe Mongo::Server::Monitor do
     it 'kills the monitor thread' do
       ClientRegistry.instance.close_all_clients
       thread
-      sleep 1
-      expect(monitor.connection).to receive(:disconnect!).and_call_original
-      monitor.stop!(true)
-      expect(thread.alive?).to be(false)
+      sleep 0.5
+
+      RSpec::Mocks.with_temporary_scope do
+        expect(monitor.connection).to receive(:disconnect!).and_call_original
+        monitor.stop!
+        expect(thread.alive?).to be(false)
+      end
     end
   end
 
@@ -260,8 +211,8 @@ describe Mongo::Server::Monitor do
         1
       end
 
-      let(:monitor) do
-        described_class.new(address, listeners, Mongo::Monitoring.new, SpecConfig.instance.test_options.merge(connect_timeout: connect_timeout))
+      let(:monitor_options) do
+        {connect_timeout: connect_timeout}
       end
 
       it 'sets the value as the timeout on the connection' do
@@ -274,4 +225,12 @@ describe Mongo::Server::Monitor do
       end
     end
   end
+
+  describe '#log_warn' do
+    it 'works' do
+      expect do
+        monitor.log_warn('test warning')
+      end.not_to raise_error
+    end
+  end
 end