mongo 2.12.1 → 2.13.0

data/spec/integration/reconnect_spec.rb

@@ -65,9 +65,8 @@ describe 'Client after reconnect' do
     end
 
     let(:client) do
-      ClientRegistry.instance.register_local_client(
-        Mongo::Client.new(uri, SpecConfig.instance.ssl_options.merge(
-          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

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
@@ -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.4'
+          # 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

data/spec/integration/retryable_writes/retryable_writes_40_and_newer_spec.rb

@@ -0,0 +1,401 @@
+require 'spec_helper'
+
+require_relative './shared/supports_retries'
+require_relative './shared/only_supports_legacy_retries'
+require_relative './shared/does_not_support_retries'
+
+describe 'Retryable Writes' do
+  require_fail_command
+  require_wired_tiger
+  require_no_multi_shard
+
+  let(:client) do
+    authorized_client.with(
+      socket_timeout: socket_timeout,
+      retry_writes: retry_writes,
+      max_write_retries: max_write_retries,
+    )
+  end
+
+  let(:socket_timeout) { nil }
+  let(:retry_writes) { nil }
+  let(:max_write_retries) { nil }
+
+  let(:collection) { client['test'] }
+
+  before do
+    collection.drop
+  end
+
+  context 'collection#insert_one' do
+    let(:command_name) { 'insert' }
+
+    let(:perform_operation) do
+      collection.insert_one(_id: 1)
+    end
+
+    let(:actual_result) do
+      collection.count(_id: 1)
+    end
+
+    let(:expected_successful_result) do
+      1
+    end
+
+    let(:expected_failed_result) do
+      0
+    end
+
+    it_behaves_like 'it supports retries'
+  end
+
+  context 'collection#update_one' do
+    before do
+      collection.insert_one(_id: 1)
+    end
+
+    let(:command_name) { 'update' }
+
+    let(:perform_operation) do
+      collection.update_one({ _id: 1 }, { '$set' => { a: 1 } })
+    end
+
+    let(:actual_result) do
+      collection.count(a: 1)
+    end
+
+    let(:expected_successful_result) do
+      1
+    end
+
+    let(:expected_failed_result) do
+      0
+    end
+
+    it_behaves_like 'it supports retries'
+  end
+
+  context 'collection#replace_one' do
+    before do
+      collection.insert_one(_id: 1, text: 'hello world')
+    end
+
+    let(:command_name) { 'update' }
+
+    let(:perform_operation) do
+      collection.replace_one({ text: 'hello world' }, { text: 'goodbye' })
+    end
+
+    let(:actual_result) do
+      collection.count(text: 'goodbye')
+    end
+
+    let(:expected_successful_result) do
+      1
+    end
+
+    let(:expected_failed_result) do
+      0
+    end
+
+    it_behaves_like 'it supports retries'
+  end
+
+  context 'collection#delete_one' do
+    before do
+      collection.insert_one(_id: 1)
+    end
+
+    let(:command_name) { 'delete' }
+
+    let(:perform_operation) do
+      collection.delete_one(_id: 1)
+    end
+
+    let(:actual_result) do
+      collection.count(_id: 1)
+    end
+
+    let(:expected_successful_result) do
+      0
+    end
+
+    let(:expected_failed_result) do
+      1
+    end
+
+    it_behaves_like 'it supports retries'
+  end
+
+  context 'collection#find_one_and_update' do
+    before do
+      collection.insert_one(_id: 1)
+    end
+
+    let(:command_name) { 'findAndModify' }
+
+    let(:perform_operation) do
+      collection.find_one_and_update({ _id: 1 }, { '$set' => { text: 'hello world' } })
+    end
+
+    let(:actual_result) do
+      collection.count(text: 'hello world')
+    end
+
+    let(:expected_successful_result) do
+      1
+    end
+
+    let(:expected_failed_result) do
+      0
+    end
+
+    it_behaves_like 'it supports retries'
+  end
+
+  context 'collection#find_one_and_replace' do
+    before do
+      collection.insert_one(_id: 1, text: 'hello world')
+    end
+
+    let(:command_name) { 'findAndModify' }
+
+    let(:perform_operation) do
+      collection.find_one_and_replace({ text: 'hello world' }, { text: 'goodbye' })
+    end
+
+    let(:actual_result) do
+      collection.count(text: 'goodbye')
+    end
+
+    let(:expected_successful_result) do
+      1
+    end
+
+    let(:expected_failed_result) do
+      0
+    end
+
+    it_behaves_like 'it supports retries'
+  end
+
+  context 'collection#find_one_and_delete' do
+    before do
+      collection.insert_one(_id: 1)
+    end
+
+    let(:command_name) { 'findAndModify' }
+
+    let(:perform_operation) do
+      collection.find_one_and_delete(_id: 1)
+    end
+
+    let(:actual_result) do
+      collection.count(_id: 1)
+    end
+
+    let(:expected_successful_result) do
+      0
+    end
+
+    let(:expected_failed_result) do
+      1
+    end
+
+    it_behaves_like 'it supports retries'
+  end
+
+  context 'collection#update_many' do
+    let(:command_name) { 'update' }
+
+    before do
+      collection.insert_one(_id: 1, text: 'hello world')
+      collection.insert_one(_id: 2, text: 'hello world')
+    end
+
+    let(:perform_operation) do
+      collection.update_many({ text: 'hello world' }, { '$set' => { text: 'goodbye' } })
+    end
+
+    let(:actual_result) do
+      collection.count(text: 'goodbye')
+    end
+
+    let(:expected_successful_result) do
+      2
+    end
+
+    let(:expected_failed_result) do
+      0
+    end
+
+    it_behaves_like 'it only supports legacy retries'
+  end
+
+  context 'collection#delete_many' do
+    let(:command_name) { 'delete' }
+
+    before do
+      collection.insert_one(_id: 1, text: 'hello world')
+      collection.insert_one(_id: 2, text: 'hello world')
+    end
+
+    let(:perform_operation) do
+      collection.delete_many(text: 'hello world')
+    end
+
+    let(:actual_result) do
+      collection.count(text: 'hello world')
+    end
+
+    let(:expected_successful_result) do
+      0
+    end
+
+    let(:expected_failed_result) do
+      2
+    end
+
+    it_behaves_like 'it only supports legacy retries'
+  end
+
+  context 'collection#bulk_write' do
+    context 'with insert_one' do
+      let(:command_name) { 'insert' }
+
+      let(:perform_operation) do
+        collection.bulk_write([{ insert_one: { _id: 1 } }])
+      end
+
+      let(:actual_result) do
+        collection.count(_id: 1)
+      end
+
+      let(:expected_successful_result) do
+        1
+      end
+
+      let(:expected_failed_result) do
+        0
+      end
+
+      it_behaves_like 'it supports retries'
+    end
+
+    context 'with delete_one' do
+      let(:command_name) { 'delete' }
+
+      before do
+        collection.insert_one(_id: 1)
+      end
+
+      let(:perform_operation) do
+        collection.bulk_write([{ delete_one: { filter: { _id: 1 } } }])
+      end
+
+      let(:actual_result) do
+        collection.count(_id: 1)
+      end
+
+      let(:expected_successful_result) do
+        0
+      end
+
+      let(:expected_failed_result) do
+        1
+      end
+
+      it_behaves_like 'it supports retries'
+    end
+
+    context 'with update_one' do
+      let(:command_name) { 'update' }
+
+      before do
+        collection.insert_one(_id: 1, text: 'hello world')
+      end
+
+      let(:perform_operation) do
+        collection.bulk_write([{ update_one: { filter: { text: 'hello world' }, update: { '$set' => { text: 'goodbye' } } } }])
+      end
+
+      let(:actual_result) do
+        collection.count(text: 'goodbye')
+      end
+
+      let(:expected_successful_result) do
+        1
+      end
+
+      let(:expected_failed_result) do
+        0
+      end
+
+      it_behaves_like 'it supports retries'
+    end
+
+    context 'with delete_many' do
+      let(:command_name) { 'delete' }
+
+      before do
+        collection.insert_one(_id: 1, text: 'hello world')
+        collection.insert_one(_id: 2, text: 'hello world')
+      end
+
+      let(:perform_operation) do
+        collection.bulk_write([{ delete_many: { filter: { text: 'hello world' } } }])
+      end
+
+      let(:actual_result) do
+        collection.count(text: 'hello world')
+      end
+
+      let(:expected_successful_result) do
+        0
+      end
+
+      let(:expected_failed_result) do
+        2
+      end
+
+      it_behaves_like 'it only supports legacy retries'
+    end
+
+    context 'with update_many' do
+      let(:command_name) { 'update' }
+
+      before do
+        collection.insert_one(_id: 1, text: 'hello world')
+        collection.insert_one(_id: 2, text: 'hello world')
+      end
+
+      let(:perform_operation) do
+        collection.bulk_write([{ update_many: { filter: { text: 'hello world' }, update: { '$set' => { text: 'goodbye' } } } }])
+      end
+
+      let(:actual_result) do
+        collection.count(text: 'goodbye')
+      end
+
+      let(:expected_successful_result) do
+        2
+      end
+
+      let(:expected_failed_result) do
+        0
+      end
+
+      it_behaves_like 'it only supports legacy retries'
+    end
+  end
+
+  context 'database#command' do
+    let(:command_name) { 'ping' }
+
+    let(:perform_operation) do
+      collection.database.command(ping: 1)
+    end
+
+    it_behaves_like 'it does not support retries'
+  end
+end