mongo 2.11.2 → 2.13.0.beta1

data/spec/integration/get_more_spec.rb

@@ -4,8 +4,16 @@ describe 'getMore operation' do
   # https://jira.mongodb.org/browse/RUBY-1987
   min_server_fcv '3.2'
 
+  let(:subscriber) { EventSubscriber.new }
+
+  let(:client) do
+    authorized_client.tap do |client|
+      client.subscribe(Mongo::Monitoring::COMMAND, subscriber)
+    end
+  end
+
   let(:collection) do
-    subscribed_client['get_more_spec']
+    client['get_more_spec']
   end
 
   let(:scope) do
@@ -16,11 +24,10 @@ describe 'getMore operation' do
     collection.delete_many
     collection.insert_one(a: 1)
     #collection.insert_one(a: 2)
-    EventSubscriber.clear_events!
   end
 
   let(:get_more_command) do
-    event = EventSubscriber.single_command_started_event('getMore')
+    event = subscriber.single_command_started_event('getMore')
     event.command['getMore']
   end
 

data/spec/integration/heartbeat_events_spec.rb

@@ -62,7 +62,7 @@ describe 'Heartbeat events' do
 
   it 'notifies on failed heartbeats' do
     exc = HeartbeatEventsSpecTestException.new
-    expect_any_instance_of(Mongo::Server::Monitor::Connection).to receive(:ismaster).at_least(:once).and_raise(exc)
+    expect_any_instance_of(Mongo::Server::Monitor).to receive(:ismaster).at_least(:once).and_raise(exc)
 
     expect do
       client.database.command(ismaster: 1)

data/spec/integration/read_preference_spec.rb

@@ -77,11 +77,11 @@ describe 'Read preference' do
       it_behaves_like 'does not send read preference when reading'
     end
 
-    context 'RS, sharded cluster' do
+    context 'replica set' do
       # Supposedly read preference should only be sent in a sharded cluster
       # topology. However, transactions spec tests contain read preference
       # assertions also when they are run in RS topologies.
-      require_topology :sharded, :replica_set
+      require_topology :replica_set
 
       context 'pre-OP_MSG server' do
         max_server_version '3.4'
@@ -95,6 +95,13 @@ describe 'Read preference' do
         it_behaves_like 'sends expected read preference when reading'
       end
     end
+
+    context 'sharded cluster' do
+      # Driver does not send $readPreference document to mongos when
+      # specified mode is primary.
+      require_topology :sharded
+      it_behaves_like 'does not send read preference when reading'
+    end
   end
 
   shared_examples_for 'sends expected read preference' do
@@ -264,18 +271,41 @@ describe 'Read preference' do
     shared_examples_for 'sends expected read preference' do
       it_behaves_like 'non-transactional read preference examples'
 
-      it 'sends expected read preference when starting transaction' do
-        collection.insert_one(hello: 'world')
+      context 'on sharded cluster' do
+        require_topology :sharded
 
-        session = client.start_session(session_options)
-        session.with_transaction(tx_options) do
-          res = collection.find({}, {session: session}.merge(find_options || {})).to_a.count
-          expect(res).to eq(1)
+        it 'does not send read preference' do
+          # Driver does not send $readPreference document to mongos when
+          # specified mode is primary.
+          collection.insert_one(hello: 'world')
+
+          session = client.start_session(session_options)
+          session.with_transaction(tx_options) do
+            res = collection.find({}, {session: session}.merge(find_options || {})).to_a.count
+            expect(res).to eq(1)
+          end
+
+          event = subscriber.single_command_started_event('find')
+          actual_preference = event.command['$readPreference']
+          expect(actual_preference).to be_nil
         end
+      end
+
+      context 'on replica set' do
+        require_topology :replica_set
+        it 'sends expected read preference when starting transaction' do
+          collection.insert_one(hello: 'world')
 
-        event = subscriber.single_command_started_event('find')
-        actual_preference = event.command['$readPreference']
-        expect(actual_preference).to eq(expected_read_preference)
+          session = client.start_session(session_options)
+          session.with_transaction(tx_options) do
+            res = collection.find({}, {session: session}.merge(find_options || {})).to_a.count
+            expect(res).to eq(1)
+          end
+
+          event = subscriber.single_command_started_event('find')
+          actual_preference = event.command['$readPreference']
+          expect(actual_preference).to eq(expected_read_preference)
+        end
       end
     end
 
@@ -482,4 +512,30 @@ describe 'Read preference' do
       end
     end
   end
+
+  context 'secondary read with direct connection' do
+    require_topology :replica_set
+
+    let(:address_str) do
+      Mongo::ServerSelector.get(mode: :secondary).
+        select_server(authorized_client.cluster).address.seed
+    end
+
+    let(:secondary_client) do
+      new_local_client([address_str],
+        SpecConfig.instance.all_test_options.merge(connect: :direct))
+    end
+
+    it 'succeeds without read preference' do
+      secondary_client['foo'].find.to_a
+    end
+
+    it 'succeeds with read preference: secondary' do
+      secondary_client['foo', {read: {mode: :secondary}}].find.to_a
+    end
+
+    it 'succeeds with read preference: primary' do
+      secondary_client['foo', {read: {mode: :primary}}].find.to_a
+    end
+  end
 end

data/spec/integration/reconnect_spec.rb

@@ -54,9 +54,7 @@ describe 'Client after reconnect' do
   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
+      "mongodb+srv://test1.test.build.10gen.cc/?tls=#{SpecConfig.instance.ssl?}"
     end
 
     # Debug logging to troubleshoot failures in Evergreen
@@ -67,9 +65,8 @@ describe 'Client after reconnect' do
     end
 
     let(:client) do
-      ClientRegistry.instance.register_local_client(
-        Mongo::Client.new(uri, server_selection_timeout: 3.86,
-          logger: logger))
+      new_local_client(uri, SpecConfig.instance.ssl_options.merge(
+        server_selection_timeout: 3.86, logger: logger))
     end
 
     let(:wait_for_discovery) do
@@ -134,7 +131,10 @@ describe 'Client after reconnect' do
 
       let(:client) do
         ClientRegistry.instance.register_local_client(
-          Mongo::Client.new(uri, server_selection_timeout: 3.89,
+          Mongo::Client.new(uri,
+            timeout: 5,
+            connect_timeout: 5,
+            server_selection_timeout: 3.89,
             resolv_options: {
               nameserver: 'localhost',
               nameserver_port: [['localhost', 5300], ['127.0.0.1', 5300]],

data/spec/integration/retryable_errors_spec.rb

@@ -4,8 +4,16 @@ describe 'Failing retryable operations' do
   # Requirement for fail point
   min_server_fcv '4.0'
 
+  let(:subscriber) { EventSubscriber.new }
+
+  let(:client_options) do
+    {}
+  end
+
   let(:client) do
-    subscribed_client
+    authorized_client.with(client_options).tap do |client|
+      client.subscribe(Mongo::Monitoring::COMMAND, subscriber)
+    end
   end
 
   let(:collection) do
@@ -24,7 +32,7 @@ describe 'Failing retryable operations' do
     end
 
     after do
-      ClusterTools.instance.direct_client_for_each_server do |client|
+      ClusterTools.instance.direct_client_for_each_data_bearing_server do |client|
         client.use(:admin).database.command(clear_fail_point_command)
       end
     end
@@ -62,7 +70,7 @@ describe 'Failing retryable operations' do
           server.monitor.stop!
         end
 
-        ClusterTools.instance.direct_client_for_each_server do |client|
+        ClusterTools.instance.direct_client_for_each_data_bearing_server do |client|
           client.use(:admin).database.command(fail_point_command)
         end
       end
@@ -83,13 +91,13 @@ describe 'Failing retryable operations' do
       end
 
       let(:events) do
-        EventSubscriber.command_started_events('find')
+        subscriber.command_started_events('find')
       end
     end
 
     shared_context 'write operation' do
       let(:fail_point_command) do
-        {
+        command = {
           configureFailPoint: 'failCommand',
           mode: {times: 2},
           data: {
@@ -97,6 +105,15 @@ describe 'Failing retryable operations' do
             errorCode: 11600,
           },
         }
+
+        if ClusterConfig.instance.short_server_version >= '4.3'
+          # Server versions 4.4 and newer will add the RetryableWriteError
+          # label to all retryable errors, and the driver must not add the label
+          # if it is not already present.
+          command[:data][:errorLabels] = ['RetryableWriteError']
+        end
+
+        command
       end
 
       let(:set_fail_point) do
@@ -119,7 +136,7 @@ describe 'Failing retryable operations' do
       end
 
       let(:events) do
-        EventSubscriber.command_started_events('insert')
+        subscriber.command_started_events('insert')
       end
     end
 
@@ -132,6 +149,7 @@ describe 'Failing retryable operations' do
       end
 
       it 'publishes two events' do
+        operation_exception
 
         expect(events.length).to eq(2)
       end
@@ -146,6 +164,7 @@ describe 'Failing retryable operations' do
       end
 
       it 'publishes one event' do
+        operation_exception
 
         expect(events.length).to eq(1)
       end
@@ -208,8 +227,8 @@ describe 'Failing retryable operations' do
       context 'modern read retries' do
         require_wired_tiger_on_36
 
-        let(:client) do
-          subscribed_client.with(retry_reads: true)
+        let(:client_options) do
+          {retry_reads: true}
         end
 
         it_behaves_like 'failing retry'
@@ -217,8 +236,8 @@ describe 'Failing retryable operations' do
       end
 
       context 'legacy read retries' do
-        let(:client) do
-          subscribed_client.with(retry_reads: false, read_retry_interval: 0)
+        let(:client_options) do
+          {retry_reads: false, read_retry_interval: 0}
         end
 
         it_behaves_like 'failing retry'
@@ -227,8 +246,8 @@ describe 'Failing retryable operations' do
     end
 
     context 'when read retries are disabled' do
-      let(:client) do
-        subscribed_client.with(retry_reads: false, max_read_retries: 0)
+      let(:client_options) do
+        {retry_reads: false, max_read_retries: 0}
       end
 
       include_context 'read operation'
@@ -243,8 +262,8 @@ describe 'Failing retryable operations' do
       context 'modern write retries' do
         require_wired_tiger_on_36
 
-        let(:client) do
-          subscribed_client.with(retry_writes: true)
+        let(:client_options) do
+          {retry_writes: true}
         end
 
         it_behaves_like 'failing retry'
@@ -252,8 +271,8 @@ describe 'Failing retryable operations' do
       end
 
       context 'legacy write' do
-        let(:client) do
-          subscribed_client.with(retry_writes: false)
+        let(:client_options) do
+          {retry_writes: false}
         end
 
         it_behaves_like 'failing retry'

data/spec/integration/{retryable_writes_spec.rb → retryable_writes/retryable_writes_36_and_older_spec.rb}

@@ -19,6 +19,12 @@ describe 'Retryable writes integration tests' do
   # eligible servers as would be the case in a multi-shard sharded cluster
   require_no_multi_shard
 
+  # Note: these tests are deprecated in favor of the tests in the file
+  # spec/integration/retryable_writes/retryable_writes_40_and_newer_spec.rb
+  # If you are changing functionality in the driver that only impacts server
+  # versions 4.0 or newer, test that functionality in the other test file.
+  max_server_fcv '3.6'
+
   before do
     authorized_collection.delete_many
   end
@@ -26,7 +32,7 @@ describe 'Retryable writes integration tests' do
   let(:check_collection) do
     # Verify data in the collection using another client instance to avoid
     # having the verification read trigger cluster scans on the writing client
-    subscribed_client[TEST_COLL]
+    root_authorized_client[TEST_COLL]
   end
 
   let(:primary_connection) do
@@ -43,7 +49,7 @@ describe 'Retryable writes integration tests' do
       before do
         wait_for_all_servers(client.cluster)
 
-        allow(primary_socket).to receive(:write).and_raise(error)
+        allow(primary_socket).to receive(:do_write).and_raise(error.dup)
       end
 
       context 'when the error is retryable' do
@@ -52,10 +58,10 @@ describe 'Retryable writes integration tests' do
           expect(Mongo::Logger.logger).to receive(:warn).once.and_call_original
         end
 
-        context 'when the error is a SocketError' do
+        context 'when the error is a socket error' do
 
           let(:error) do
-            Mongo::Error::SocketError
+            IOError.new('first error')
           end
 
           it 'retries writes' do
@@ -64,10 +70,10 @@ describe 'Retryable writes integration tests' do
           end
         end
 
-        context 'when the error is a SocketTimeoutError' do
+        context 'when the error is a socket timeout error' do
 
           let(:error) do
-            Mongo::Error::SocketTimeoutError
+            Errno::ETIMEDOUT.new
           end
 
           it 'retries writes' do
@@ -126,7 +132,7 @@ describe 'Retryable writes integration tests' do
     context 'when the operation fails on the first attempt and again on the second attempt' do
 
       before do
-        allow(primary_socket).to receive(:write).and_raise(error)
+        allow(primary_socket).to receive(:do_write).and_raise(error.dup)
       end
 
       context 'when the selected server does not support retryable writes' do
@@ -134,33 +140,38 @@ describe 'Retryable writes integration tests' do
         before do
           legacy_primary = double('legacy primary', :retry_writes? => false)
           expect(collection).to receive(:select_server).and_return(primary_server, legacy_primary)
-          expect(primary_socket).to receive(:write).and_raise(error)
+          expect(primary_socket).to receive(:do_write).and_raise(error.dup)
         end
 
-        context 'when the error is a SocketError' do
+        context 'when the error is a socket error' do
 
           let(:error) do
+            IOError.new('first error')
+          end
+
+          let(:exposed_error_class) do
             Mongo::Error::SocketError
           end
 
           it 'does not retry writes and raises the original error' do
             expect do
               operation
-            end.to raise_error(error)
+            end.to raise_error(exposed_error_class, /first error/)
             expect(expectation).to eq(unsuccessful_retry_value)
           end
         end
 
-        context 'when the error is a SocketTimeoutError' do
+        context 'when the error is a socket timeout error' do
 
           let(:error) do
-            Mongo::Error::SocketTimeoutError
+            Errno::ETIMEDOUT.new('first error')
           end
 
           it 'does not retry writes and raises the original error' do
             expect do
               operation
-            end.to raise_error(error)
+            # The exception message is different because of added diagnostics.
+            end.to raise_error(Mongo::Error::SocketTimeoutError, /first error/)
             expect(expectation).to eq(unsuccessful_retry_value)
           end
         end
@@ -174,18 +185,18 @@ describe 'Retryable writes integration tests' do
           it 'does not retry writes and raises the original error' do
             expect do
               operation
-            end.to raise_error(error)
+            end.to raise_error(Mongo::Error::OperationFailure, /not master/)
             expect(expectation).to eq(unsuccessful_retry_value)
           end
         end
       end
 
       [
-        [Mongo::Error::SocketError],
-        [Mongo::Error::SocketTimeoutError],
-        [Mongo::Error::OperationFailure, 'not master'],
-        [Mongo::Error::OperationFailure, 'node is recovering'],
-      ].each do |error_cls, error_msg|
+        [IOError, 'first error', Mongo::Error::SocketError],
+        [Errno::ETIMEDOUT, 'first error', Mongo::Error::SocketTimeoutError],
+        [Mongo::Error::OperationFailure, 'first error: not master', Mongo::Error::OperationFailure],
+        [Mongo::Error::OperationFailure, 'first error: node is recovering', Mongo::Error::OperationFailure],
+      ].each do |error_cls, error_msg, exposed_first_error_class|
         # Note: actual exception instances must be different between tests
 
         context "when the first error is a #{error_cls}/#{error_msg}" do
@@ -200,20 +211,24 @@ describe 'Retryable writes integration tests' do
                                                            primary_connection.send(:ssl_options))
             good_socket = primary_connection.address.socket(primary_connection.socket_timeout,
                                                             primary_connection.send(:ssl_options))
-            allow(bad_socket).to receive(:write).and_raise(second_error)
+            allow(bad_socket).to receive(:do_write).and_raise(second_error.dup)
             allow(primary_connection.address).to receive(:socket).and_return(bad_socket, good_socket)
           end
 
-          context 'when the second error is a SocketError' do
+          context 'when the second error is a socket error' do
 
             let(:second_error) do
+              IOError.new('second error')
+            end
+
+            let(:exposed_error_class) do
               Mongo::Error::SocketError
             end
 
             it 'raises the second error' do
               expect do
                 operation
-              end.to raise_error(second_error)
+              end.to raise_error(exposed_error_class, /second error/)
               expect(expectation).to eq(unsuccessful_retry_value)
             end
 
@@ -230,16 +245,20 @@ describe 'Retryable writes integration tests' do
             end
           end
 
-          context 'when the second error is a SocketTimeoutError' do
+          context 'when the second error is a socket timeout error' do
 
             let(:second_error) do
+              Errno::ETIMEDOUT.new('second error')
+            end
+
+            let(:exposed_error_class) do
               Mongo::Error::SocketTimeoutError
             end
 
             it 'raises the second error' do
               expect do
                 operation
-              end.to raise_error(second_error)
+              end.to raise_error(exposed_error_class, /second error/)
               expect(expectation).to eq(unsuccessful_retry_value)
             end
           end
@@ -247,13 +266,13 @@ describe 'Retryable writes integration tests' do
           context 'when the second error is a retryable OperationFailure' do
 
             let(:second_error) do
-              Mongo::Error::OperationFailure.new('not master')
+              Mongo::Error::OperationFailure.new('second error: not master')
             end
 
             it 'raises the second error' do
               expect do
                 operation
-              end.to raise_error(second_error)
+              end.to raise_error(Mongo::Error, /second error: not master/)
               expect(expectation).to eq(unsuccessful_retry_value)
             end
           end
@@ -267,41 +286,26 @@ describe 'Retryable writes integration tests' do
             it 'does not retry writes and raises the first error' do
               expect do
                 operation
-              end.to raise_error(error)
+              end.to raise_error(exposed_first_error_class, /first error/)
               expect(expectation).to eq(unsuccessful_retry_value)
             end
           end
 
-          context 'when the second error is a another error' do
+          # The driver shouldn't be producing non-Mongo::Error derived errors,
+          # but if those are produced (like ArgumentError), they would be
+          # immediately propagated to the application.
+          context 'when the second error is another error' do
 
             let(:second_error) do
-              StandardError
+              StandardError.new('second error')
             end
 
-            it 'raises the first error' do
+            it 'raises the second error' do
               expect do
                 operation
-              end.to raise_error(error)
+              end.to raise_error(StandardError, /second error/)
               expect(expectation).to eq(unsuccessful_retry_value)
             end
-
-            it 'indicates server used for operation' do
-              expect do
-                operation
-              end.to raise_error(Mongo::Error, /on #{ClusterConfig.instance.primary_address_str}/)
-            end
-
-            it 'indicates first attempt' do
-              expect do
-                operation
-              end.to raise_error(Mongo::Error, /attempt 1/)
-            end
-
-            it 'indicates retry was performed' do
-              expect do
-                operation
-              end.to raise_error(Mongo::Error, /later retry failed: StandardError/)
-            end
           end
         end
       end
@@ -315,7 +319,7 @@ describe 'Retryable writes integration tests' do
     end
 
     before do
-      expect(primary_socket).to receive(:write).exactly(:once).and_raise(Mongo::Error::SocketError)
+      expect(primary_socket).to receive(:do_write).exactly(:once).and_raise(Mongo::Error::SocketError)
     end
 
     it 'does not retry writes' do
@@ -337,7 +341,7 @@ describe 'Retryable writes integration tests' do
     end
 
     before do
-      expect(primary_socket).to receive(:write).and_raise(Mongo::Error::SocketError)
+      expect(primary_socket).to receive(:do_write).and_raise(Mongo::Error::SocketError)
     end
 
     it 'does not retry writes' do