mongo 2.10.5 → 2.11.0.rc0

data/spec/integration/connection_spec.rb

@@ -1,14 +1,22 @@
 require 'spec_helper'
 
 describe 'Connections' do
-  before(:all) do
-    ClientRegistry.instance.close_all_clients
+  clean_slate
+
+  let(:client) do
+    ClientRegistry.instance.global_client('authorized').tap do |client|
+      stop_monitoring(client)
+    end
   end
 
-  let(:client) { ClientRegistry.instance.global_client('authorized') }
   let(:server) { client.cluster.servers.first }
 
   describe '#connect!' do
+    # On JRuby 9.2.7.0, this line:
+    # expect_any_instance_of(Mongo::Socket).to receive(:write).and_raise(exception)
+    # ... appears to produce a moment in which Mongo::Socket#write is undefined
+    # entirely, resulting in this failure:
+    # RSpec::Expectations::ExpectationNotMetError: expected Mongo::Error::SocketError, got #<NameError: undefined method `write' for class `Mongo::Socket'>
     fails_on_jruby
 
     context 'network error during handshake' do
@@ -74,17 +82,17 @@ describe 'Connections' do
 
           # need to use the primary here, otherwise a secondary will be
           # changed to unknown which wouldn't alter topology
-          let(:server) { client.cluster.servers.detect { |s| s.primary? } }
+          let(:server) { client.cluster.next_primary }
 
           it 'changes topology type' do
             # wait for topology to get discovered
-            client.database.command(ismaster: 1)
+            client.cluster.next_primary
 
             expect(client.cluster.topology.class).to eql(Mongo::Cluster::Topology::ReplicaSetWithPrimary)
 
             # stop background monitoring to prevent it from racing with the test
-            client.cluster.servers.each do |server|
-              server.monitor.stop!(true)
+            client.cluster.servers_list.each do |server|
+              server.monitor.stop!
             end
 
             connection
@@ -98,12 +106,11 @@ describe 'Connections' do
       context 'error during handshake to primary in a replica set' do
         require_topology :replica_set
 
-        let(:server) { client.cluster.servers.detect { |server| server.primary? } }
+        let(:server) { client.cluster.next_primary }
 
         before do
-          ClientRegistry.instance.close_all_clients
           # insert to perform server selection and get topology to primary
-          client[:test].insert_one(foo: 'bar')
+          client.cluster.next_primary
         end
 
         it 'sets cluster type to replica set without primary' do
@@ -148,17 +155,19 @@ describe 'Connections' do
         server.monitor.instance_variable_set('@description',
           Mongo::Server::Description.new(server.address))
 
-        # now pretend an ismaster returned a different range
-        features = Mongo::Server::Description::Features.new(0..3)
-        # the second Features instantiation is for SDAM event publication
-        expect(Mongo::Server::Description::Features).to receive(:new).twice.and_return(features)
+        RSpec::Mocks.with_temporary_scope do
+          # now pretend an ismaster returned a different range
+          features = Mongo::Server::Description::Features.new(0..3)
+          # the second Features instantiation is for SDAM event publication
+          expect(Mongo::Server::Description::Features).to receive(:new).twice.and_return(features)
 
-        connection = Mongo::Server::Connection.new(server, server.options)
-        expect(connection.connect!).to be true
+          connection = Mongo::Server::Connection.new(server, server.options)
+          expect(connection.connect!).to be true
 
-        # ismaster response should update server description via sdam flow,
-        # which includes wire version range
-        expect(server.features.server_wire_versions.max).to eq(3)
+          # ismaster response should update server description via sdam flow,
+          # which includes wire version range
+          expect(server.features.server_wire_versions.max).to eq(3)
+        end
       end
     end
 
@@ -173,8 +182,8 @@ describe 'Connections' do
 
       it 'performs SDAM flow' do
         client['foo'].insert_one(bar: 1)
-        client.cluster.servers.each do |server|
-          server.monitor.stop!(true)
+        client.cluster.servers_list.each do |server|
+          server.monitor.stop!
         end
         expect(client.cluster.topology.class).to eq(Mongo::Cluster::Topology::ReplicaSetWithPrimary)
 
@@ -184,7 +193,7 @@ describe 'Connections' do
         end
 
         # overwrite server description
-        server.monitor.instance_variable_set('@description', Mongo::Server::Description.new(
+        server.instance_variable_set('@description', Mongo::Server::Description.new(
           server.address))
 
         # overwrite topology

data/spec/integration/cursor_reaping_spec.rb

@@ -59,8 +59,7 @@ describe 'Cursor reaping' do
       client.cluster.instance_variable_get('@periodic_executor').execute
 
       started_event = EventSubscriber.started_events.detect do |event|
-        event.command['killCursors'] &&
-        event.command['cursors'].map { |c| Utils.int64_value(c) }.include?(cursor_id)
+        event.command['killCursors'] && event.command['cursors'].include?(cursor_id)
       end
 
       expect(started_event).not_to be_nil

data/spec/integration/docs_examples_spec.rb

@@ -1,10 +1,6 @@
 require 'spec_helper'
 
 describe 'aggregation examples in Ruby' do
-  before(:all) do
-    ClientRegistry.instance.close_all_clients
-  end
-
   let(:client) do
     authorized_client
   end

data/spec/integration/heartbeat_events_spec.rb

@@ -25,11 +25,9 @@ end
 describe 'Heartbeat events' do
   class HeartbeatEventsSpecTestException < StandardError; end
 
-  let(:subscriber) { TestHeartbeatSubscriber.new }
+  clean_slate_for_all
 
-  before(:all) do
-    ClientRegistry.instance.close_all_clients
-  end
+  let(:subscriber) { TestHeartbeatSubscriber.new }
 
   before do
     Mongo::Monitoring::Global.subscribe(Mongo::Monitoring::SERVER_HEARTBEAT, subscriber)
@@ -39,8 +37,11 @@ describe 'Heartbeat events' do
     Mongo::Monitoring::Global.unsubscribe(Mongo::Monitoring::SERVER_HEARTBEAT, subscriber)
   end
 
-  let(:client) { new_local_client([SpecConfig.instance.addresses.first],
-    authorized_client.options.merge(server_selection_timeout: 0.1, connect: :direct)) }
+  let(:address_str) { ClusterConfig.instance.primary_address_str }
+
+  let(:client) { new_local_client([address_str],
+    SpecConfig.instance.all_test_options.merge(
+      server_selection_timeout: 0.1, connect: :direct)) }
 
   it 'notifies on successful heartbeats' do
     client.database.command(ismaster: 1)
@@ -48,12 +49,12 @@ describe 'Heartbeat events' do
     started_event = subscriber.started_events.first
     expect(started_event).not_to be nil
     expect(started_event.address).to be_a(Mongo::Address)
-    expect(started_event.address.seed).to eq(SpecConfig.instance.addresses.first)
+    expect(started_event.address.seed).to eq(address_str)
 
     succeeded_event = subscriber.succeeded_events.first
     expect(succeeded_event).not_to be nil
     expect(succeeded_event.address).to be_a(Mongo::Address)
-    expect(succeeded_event.address.seed).to eq(SpecConfig.instance.addresses.first)
+    expect(succeeded_event.address.seed).to eq(address_str)
 
     failed_event = subscriber.failed_events.first
     expect(failed_event).to be nil
@@ -70,7 +71,7 @@ describe 'Heartbeat events' do
     started_event = subscriber.started_events.first
     expect(started_event).not_to be nil
     expect(started_event.address).to be_a(Mongo::Address)
-    expect(started_event.address.seed).to eq(SpecConfig.instance.addresses.first)
+    expect(started_event.address.seed).to eq(address_str)
 
     succeeded_event = subscriber.succeeded_events.first
     expect(succeeded_event).to be nil
@@ -80,13 +81,13 @@ describe 'Heartbeat events' do
     expect(failed_event.error).to be exc
     expect(failed_event.failure).to be exc
     expect(failed_event.address).to be_a(Mongo::Address)
-    expect(failed_event.address.seed).to eq(SpecConfig.instance.addresses.first)
+    expect(failed_event.address.seed).to eq(address_str)
   end
 
   context 'when monitoring option is false' do
-    let(:client) { new_local_client([SpecConfig.instance.addresses.first],
-      authorized_client.options.merge(server_selection_timeout: 0.1, connect: :direct,
-        monitoring: false)) }
+    let(:client) { new_local_client([address_str],
+      SpecConfig.instance.all_test_options.merge(
+        server_selection_timeout: 0.1, connect: :direct, monitoring: false)) }
 
     shared_examples_for 'does not notify on heartbeats' do
       it 'does not notify on heartbeats' do
@@ -105,8 +106,9 @@ describe 'Heartbeat events' do
           client.subscribe(Mongo::Monitoring::SERVER_HEARTBEAT, subscriber)
         end
 
-        new_local_client([SpecConfig.instance.addresses.first],
-          authorized_client.options.merge(server_selection_timeout: 0.1, connect: :direct,
+        new_local_client([address_str],
+          SpecConfig.instance.all_test_options.merge(
+            server_selection_timeout: 0.1, connect: :direct,
             monitoring: false, sdam_proc: sdam_proc))
       end
 

data/spec/integration/reconnect_spec.rb

@@ -3,7 +3,7 @@ require 'spec_helper'
 describe 'Client after reconnect' do
   let(:client) { authorized_client }
 
-  it 'works' do
+  it 'is a functioning client' do
     client['test'].insert_one('testk' => 'testv')
 
     client.reconnect
@@ -28,4 +28,147 @@ describe 'Client after reconnect' do
     expect(new_thread).not_to eq(thread)
     expect(new_thread).to be_alive
   end
+
+  context 'with min_pool_size > 0' do
+    let(:client) { authorized_client.with(min_pool_size: 1) }
+
+    it 'recreates connection pool populator thread' do
+      server = client.cluster.next_primary
+      thread = server.pool.populator.instance_variable_get('@thread')
+      expect(thread).to be_alive
+
+      thread.kill
+      # context switch to let the thread get killed
+      sleep 0.1
+      expect(thread).not_to be_alive
+
+      client.reconnect
+
+      new_server = client.cluster.next_primary
+      new_thread = new_server.pool.populator.instance_variable_get('@thread')
+      expect(new_thread).not_to eq(thread)
+      expect(new_thread).to be_alive
+    end
+  end
+
+  context 'SRV monitor thread' do
+
+    let(:uri) do
+      "mongodb+srv://test1.test.build.10gen.cc/?tls=#{SpecConfig.instance.ssl?}&tlsInsecure=true".tap do |uri|
+        puts "Constructed URI: #{uri}"
+      end
+    end
+
+    # Debug logging to troubleshoot failures in Evergreen
+    let(:logger) do
+      Logger.new(STDERR). tap do |logger|
+        logger.level = :debug
+      end
+    end
+
+    let(:client) do
+      ClientRegistry.instance.register_local_client(
+        Mongo::Client.new(uri, server_selection_timeout: 3.86,
+          logger: logger))
+    end
+
+    let(:wait_for_discovery) do
+      client.cluster.next_primary
+    end
+
+    let(:wait_for_discovery_again) do
+      client.cluster.next_primary
+    end
+
+    shared_examples_for 'recreates SRV monitor' do
+      # JRuby produces this error:
+      # RSpec::Expectations::ExpectationNotMetError: expected nil to respond to `alive?`
+      # for this assertion:
+      # expect(thread).not_to be_alive
+      # This is bizarre because if thread was nil, the earlier call to
+      # thread.kill should've similarly failed, but it doesn't.
+      fails_on_jruby
+
+      it 'recreates SRV monitor' do
+        wait_for_discovery
+
+        expect(client.cluster.topology).to be_a(expected_topology_cls)
+        thread = client.cluster.srv_monitor.instance_variable_get('@thread')
+        expect(thread).to be_alive
+
+        thread.kill
+        # context switch to let the thread get killed
+        sleep 0.1
+        expect(thread).not_to be_alive
+
+        client.reconnect
+
+        wait_for_discovery_again
+
+        new_thread = client.cluster.srv_monitor.instance_variable_get('@thread')
+        expect(new_thread).not_to eq(thread)
+        expect(new_thread).to be_alive
+      end
+    end
+
+    context 'in sharded topology' do
+      require_topology :sharded
+      require_default_port_deployment
+      require_multi_shard
+
+      let(:expected_topology_cls) { Mongo::Cluster::Topology::Sharded }
+
+      it_behaves_like 'recreates SRV monitor'
+    end
+
+    context 'in unknown topology' do
+
+      # JRuby apparently does not implement non-blocking UDP I/O which is used
+      # by RubyDNS:
+      # NotImplementedError: recvmsg_nonblock is not implemented
+      fails_on_jruby
+
+      let(:uri) do
+        "mongodb+srv://test-fake.test.build.10gen.cc/"
+      end
+
+      let(:client) do
+        ClientRegistry.instance.register_local_client(
+          Mongo::Client.new(uri, server_selection_timeout: 3.89,
+            resolv_options: {
+              nameserver: 'localhost',
+              nameserver_port: [['localhost', 5300], ['127.0.0.1', 5300]],
+            },
+            logger: logger))
+      end
+
+      let(:expected_topology_cls) { Mongo::Cluster::Topology::Unknown }
+
+      let(:wait_for_discovery) do
+        # Since the entire test is done in unknown topology, we cannot use
+        # next_primary to wait for the client to discover the topology.
+        sleep 5
+      end
+
+      let(:wait_for_discovery_again) do
+        sleep 5
+      end
+
+      around do |example|
+        require 'support/dns'
+
+        rules = [
+          ['_mongodb._tcp.test-fake.test.build.10gen.cc', :srv,
+            [0, 0, 2799, 'localhost.test.build.10gen.cc'],
+          ],
+        ]
+
+        mock_dns(rules) do
+          example.run
+        end
+      end
+
+      it_behaves_like 'recreates SRV monitor'
+    end
+  end
 end

data/spec/integration/retryable_writes_errors_spec.rb

@@ -18,10 +18,6 @@ describe 'Retryable writes errors tests' do
       authorized_client.with(retry_writes: true)
     end
 
-    after do
-      client.close(true)
-    end
-
     context 'when a retryable write is attempted' do
       it 'raises an actionable error message' do
         expect {

data/spec/integration/retryable_writes_spec.rb

@@ -102,22 +102,22 @@ describe 'Retryable writes integration tests' do
           end
 
           it 'does not retry writes' do
-            expect do
+            expect {
               operation
-            end.to raise_error(Mongo::Error::OperationFailure, /other error/)
+            }.to raise_error(Mongo::Error::OperationFailure, /other error/)
             expect(expectation).to eq(unsuccessful_retry_value)
           end
 
           it 'indicates server used for operation' do
-            expect do
+            expect {
               operation
-            end.to raise_error(Mongo::Error::OperationFailure, /on #{ClusterConfig.instance.primary_address_str}/)
+            }.to raise_error(Mongo::Error::OperationFailure, /on #{ClusterConfig.instance.primary_address_str}/)
           end
 
           it 'indicates first attempt' do
-            expect do
+            expect {
               operation
-            end.to raise_error(Mongo::Error::OperationFailure, /attempt 1/)
+            }.to raise_error(Mongo::Error::OperationFailure, /attempt 1/)
           end
         end
       end
@@ -144,9 +144,9 @@ describe 'Retryable writes integration tests' do
           end
 
           it 'does not retry writes and raises the original error' do
-            expect do
+            expect {
               operation
-            end.to raise_error(error)
+            }.to raise_error(error)
             expect(expectation).to eq(unsuccessful_retry_value)
           end
         end
@@ -158,9 +158,9 @@ describe 'Retryable writes integration tests' do
           end
 
           it 'does not retry writes and raises the original error' do
-            expect do
+            expect {
               operation
-            end.to raise_error(error)
+            }.to raise_error(error)
             expect(expectation).to eq(unsuccessful_retry_value)
           end
         end
@@ -172,9 +172,9 @@ describe 'Retryable writes integration tests' do
           end
 
           it 'does not retry writes and raises the original error' do
-            expect do
+            expect {
               operation
-            end.to raise_error(error)
+            }.to raise_error(error)
             expect(expectation).to eq(unsuccessful_retry_value)
           end
         end
@@ -211,22 +211,22 @@ describe 'Retryable writes integration tests' do
             end
 
             it 'raises the second error' do
-              expect do
+              expect {
                 operation
-              end.to raise_error(second_error)
+              }.to raise_error(second_error)
               expect(expectation).to eq(unsuccessful_retry_value)
             end
 
             it 'indicates server used for operation' do
-              expect do
+              expect {
                 operation
-              end.to raise_error(Mongo::Error, /on #{ClusterConfig.instance.primary_address_str}/)
+              }.to raise_error(Mongo::Error, /on #{ClusterConfig.instance.primary_address_str}/)
             end
 
             it 'indicates second attempt' do
-              expect do
+              expect {
                 operation
-              end.to raise_error(Mongo::Error, /attempt 2/)
+              }.to raise_error(Mongo::Error, /attempt 2/)
             end
           end
 
@@ -237,9 +237,9 @@ describe 'Retryable writes integration tests' do
             end
 
             it 'raises the second error' do
-              expect do
+              expect {
                 operation
-              end.to raise_error(second_error)
+              }.to raise_error(second_error)
               expect(expectation).to eq(unsuccessful_retry_value)
             end
           end
@@ -251,9 +251,9 @@ describe 'Retryable writes integration tests' do
             end
 
             it 'raises the second error' do
-              expect do
+              expect {
                 operation
-              end.to raise_error(second_error)
+              }.to raise_error(second_error)
               expect(expectation).to eq(unsuccessful_retry_value)
             end
           end
@@ -265,9 +265,9 @@ describe 'Retryable writes integration tests' do
             end
 
             it 'does not retry writes and raises the first error' do
-              expect do
+              expect {
                 operation
-              end.to raise_error(error)
+              }.to raise_error(error)
               expect(expectation).to eq(unsuccessful_retry_value)
             end
           end
@@ -279,28 +279,28 @@ describe 'Retryable writes integration tests' do
             end
 
             it 'raises the first error' do
-              expect do
+              expect {
                 operation
-              end.to raise_error(error)
+              }.to raise_error(error)
               expect(expectation).to eq(unsuccessful_retry_value)
             end
 
             it 'indicates server used for operation' do
-              expect do
+              expect {
                 operation
-              end.to raise_error(Mongo::Error, /on #{ClusterConfig.instance.primary_address_str}/)
+              }.to raise_error(Mongo::Error, /on #{ClusterConfig.instance.primary_address_str}/)
             end
 
             it 'indicates first attempt' do
-              expect do
+              expect {
                 operation
-              end.to raise_error(Mongo::Error, /attempt 1/)
+              }.to raise_error(Mongo::Error, /attempt 1/)
             end
 
             it 'indicates retry was performed' do
-              expect do
+              expect {
                 operation
-              end.to raise_error(Mongo::Error, /later retry failed: StandardError/)
+              }.to raise_error(Mongo::Error, /later retry failed: StandardError/)
             end
           end
         end
@@ -319,9 +319,9 @@ describe 'Retryable writes integration tests' do
     end
 
     it 'does not retry writes' do
-      expect do
+      expect {
         operation
-      end.to raise_error(Mongo::Error::SocketError)
+      }.to raise_error(Mongo::Error::SocketError)
       expect(expectation).to eq(unsuccessful_retry_value)
     end
   end
@@ -341,9 +341,9 @@ describe 'Retryable writes integration tests' do
     end
 
     it 'does not retry writes' do
-      expect do
+      expect {
         operation
-      end.to raise_error(Mongo::Error::SocketError)
+      }.to raise_error(Mongo::Error::SocketError)
       expect(expectation).to eq(unsuccessful_retry_value)
     end
   end