mongo 2.12.4 → 2.13.0.beta1

data/spec/integration/retryable_writes/shared/adds_diagnostics.rb

@@ -0,0 +1,15 @@
+module AddsDiagnostics
+  shared_examples 'it adds diagnostics' do
+    it 'indicates the server used for the operation' do
+      expect do
+        perform_operation
+      end.to raise_error(Mongo::Error, /on #{ClusterConfig.instance.primary_address_str}/)
+    end
+
+    it 'indicates the second attempt' do
+      expect do
+        perform_operation
+      end.to raise_error(Mongo::Error, /attempt 2/)
+    end
+  end
+end

data/spec/integration/retryable_writes/shared/does_not_support_retries.rb

@@ -0,0 +1,24 @@
+require_relative './performs_no_retries'
+
+module DoesNotSupportRetries
+  shared_examples 'it does not support retries' do
+    context 'when retry_writes is true' do
+      let(:retry_writes) { true }
+
+      it_behaves_like 'it performs no retries'
+    end
+
+    context 'when retry_writes is false' do
+      let(:retry_writes) { false }
+
+      it_behaves_like 'it performs no retries'
+    end
+
+    context 'when retry_writes is false with no max_write_retries' do
+      let(:retry_writes) { false }
+      let(:max_write_retries) { 0 }
+
+      it_behaves_like 'it performs no retries'
+    end
+  end
+end

data/spec/integration/retryable_writes/shared/only_supports_legacy_retries.rb

@@ -0,0 +1,25 @@
+require_relative './performs_no_retries'
+require_relative './performs_legacy_retries'
+
+module OnlySupportsLegacyRetries
+  shared_examples 'it only supports legacy retries' do
+    context 'when retry_writes is true' do
+      let(:retry_writes) { true }
+
+      it_behaves_like 'it performs no retries'
+    end
+
+    context 'when retry_writes is false' do
+      let(:retry_writes) { false }
+
+      it_behaves_like 'it performs legacy retries'
+    end
+
+    context 'when retry_writes is false with no max_write_retries' do
+      let(:retry_writes) { false }
+      let(:max_write_retries) { 0 }
+
+      it_behaves_like 'it performs no retries'
+    end
+  end
+end

data/spec/integration/retryable_writes/shared/performs_legacy_retries.rb

@@ -0,0 +1,215 @@
+require_relative './adds_diagnostics'
+
+module PerformsLegacyRetries
+  shared_examples 'it performs legacy retries' do
+    context 'for connection error' do
+      before do
+        client.use('admin').command(
+          configureFailPoint: 'failCommand',
+          mode: { times: 1 },
+          data: {
+            failCommands: [command_name],
+            closeConnection: true,
+          }
+        )
+      end
+
+      it 'does not retry the operation' do
+        expect(Mongo::Logger.logger).not_to receive(:warn).with(/legacy/)
+
+        expect do
+          perform_operation
+        end.to raise_error(Mongo::Error::SocketError)
+
+        expect(actual_result).to eq(expected_failed_result)
+      end
+    end
+
+    context 'for ETIMEDOUT' do
+      min_server_fcv '4.3'
+
+      # shorten socket timeout so these tests take less time to run
+      let(:socket_timeout) { 1 }
+
+      before do
+        client.use('admin').command(
+          configureFailPoint: 'failCommand',
+          mode: { times: 1 },
+          data: {
+            failCommands: [command_name],
+            blockConnection: true,
+            blockTimeMS: 1100,
+          }
+        )
+      end
+
+      it 'does not retry the operation' do
+        expect(Mongo::Logger.logger).not_to receive(:warn).with(/legacy/)
+
+        expect do
+          perform_operation
+        end.to raise_error(Mongo::Error::SocketTimeoutError)
+      end
+
+      after do
+        # Assure that the server has completed the operation before moving
+        # on to the next test.
+        sleep 1
+      end
+    end
+
+    context 'on server versions >= 4.4' do
+      min_server_fcv '4.3'
+
+      context 'for OperationFailure with RetryableWriteError label' do
+        before do
+          client.use('admin').command(
+            configureFailPoint: 'failCommand',
+            mode: { times: times },
+            data: {
+              failCommands: [command_name],
+              errorCode: 5, # normally NOT a retryable error code
+              errorLabels: ['RetryableWriteError']
+            }
+          )
+        end
+
+        context 'when error occurs once' do
+          let(:times) { 1 }
+
+          it 'retries and the operation and succeeds' do
+            expect(Mongo::Logger.logger).to receive(:warn).once.with(/legacy/).and_call_original
+            perform_operation
+            expect(actual_result).to eq(expected_successful_result)
+          end
+        end
+
+        context 'when error occurs twice' do
+          let(:times) { 2 }
+
+          it 'retries the operation and fails' do
+            expect(Mongo::Logger.logger).to receive(:warn).once.with(/legacy/).and_call_original
+
+            expect do
+              perform_operation
+            end.to raise_error(Mongo::Error::OperationFailure, /5/)
+
+            expect(actual_result).to eq(expected_failed_result)
+          end
+
+          it_behaves_like 'it adds diagnostics'
+
+          context 'and max_write_retries is set to 2' do
+            let(:max_write_retries) { 2 }
+
+            it 'retries twice and the operation succeeds' do
+              expect(Mongo::Logger.logger).to receive(:warn).twice.with(/legacy/).and_call_original
+              perform_operation
+              expect(actual_result).to eq(expected_successful_result)
+            end
+          end
+        end
+      end
+
+      context 'for OperationFailure without RetryableWriteError label' do
+        before do
+          client.use('admin').command(
+            configureFailPoint: 'failCommand',
+            mode: { times: 1 },
+            data: {
+              failCommands: [command_name],
+              errorCode: 91, # normally a retryable error code
+              errorLabels: [],
+            }
+          )
+        end
+
+        it 'raises the error' do
+          expect(Mongo::Logger.logger).not_to receive(:warn)
+
+          expect do
+            perform_operation
+          end.to raise_error(Mongo::Error::OperationFailure, /91/)
+
+          expect(actual_result).to eq(expected_failed_result)
+        end
+      end
+    end
+
+    context 'on server versions < 4.4' do
+      max_server_fcv '4.2'
+
+      context 'for OperationFailure with retryable code' do
+        before do
+          client.use('admin').command(
+            configureFailPoint: 'failCommand',
+            mode: { times: times },
+            data: {
+              failCommands: [command_name],
+              errorCode: 91, # a retryable error code
+            }
+          )
+        end
+
+        context 'when error occurs once' do
+          let(:times) { 1 }
+
+          it 'retries and the operation and succeeds' do
+            expect(Mongo::Logger.logger).to receive(:warn).once.with(/legacy/).and_call_original
+            perform_operation
+            expect(actual_result).to eq(expected_successful_result)
+          end
+        end
+
+        context 'when error occurs twice' do
+          let(:times) { 2 }
+
+          it 'retries and the operation and fails' do
+            expect(Mongo::Logger.logger).to receive(:warn).once.with(/legacy/).and_call_original
+
+            expect do
+              perform_operation
+            end.to raise_error(Mongo::Error::OperationFailure, /91/)
+
+            expect(actual_result).to eq(expected_failed_result)
+          end
+
+          it_behaves_like 'it adds diagnostics'
+
+          context 'and max_write_retries is set to 2' do
+            let(:max_write_retries) { 2 }
+
+            it 'retries twice and the operation succeeds' do
+              expect(Mongo::Logger.logger).to receive(:warn).twice.with(/legacy/).and_call_original
+              perform_operation
+              expect(actual_result).to eq(expected_successful_result)
+            end
+          end
+        end
+      end
+
+      context 'for OperationFailure with non-retryable code' do
+        before do
+          client.use('admin').command(
+            configureFailPoint: 'failCommand',
+            mode: { times: 1 },
+            data: {
+              failCommands: [command_name],
+              errorCode: 5, # a non-retryable error code
+            }
+          )
+        end
+
+        it 'raises the error' do
+          expect(Mongo::Logger.logger).not_to receive(:warn)
+
+          expect do
+            perform_operation
+          end.to raise_error(Mongo::Error::OperationFailure, /5/)
+
+          expect(actual_result).to eq(expected_failed_result)
+        end
+      end
+    end
+  end
+end

data/spec/integration/retryable_writes/shared/performs_modern_retries.rb

@@ -0,0 +1,232 @@
+require_relative './adds_diagnostics'
+
+module PerformsModernRetries
+  shared_examples 'it performs modern retries' do
+
+    context 'for connection error' do
+      before do
+        client.use('admin').command(
+          configureFailPoint: 'failCommand',
+          mode: { times: times },
+          data: {
+            failCommands: [command_name],
+            closeConnection: true,
+          }
+        )
+      end
+
+      context 'when error occurs once' do
+        let(:times) { 1 }
+
+        it 'retries and the operation succeeds' do
+          expect(Mongo::Logger.logger).to receive(:warn).once.with(/modern.*attempt 1/).and_call_original
+          perform_operation
+          expect(actual_result).to eq(expected_successful_result)
+        end
+      end
+
+      context 'when error occurs twice' do
+        let(:times) { 2 }
+
+        it 'retries and the operation and fails' do
+          expect(Mongo::Logger.logger).to receive(:warn).once.with(/modern.*attempt 1/).and_call_original
+
+          expect do
+            perform_operation
+          end.to raise_error(Mongo::Error::SocketError)
+
+          expect(actual_result).to eq(expected_failed_result)
+        end
+
+        it_behaves_like 'it adds diagnostics'
+      end
+    end
+
+    context 'for ETIMEDOUT' do
+      # blockConnection option in failCommand was introduced in
+      # server version 4.3
+      min_server_fcv '4.3'
+
+      # shorten socket timeout so these tests take less time to run
+      let(:socket_timeout) { 1 }
+
+      before do
+        client.use('admin').command(
+          configureFailPoint: 'failCommand',
+          mode: { times: times },
+          data: {
+            failCommands: [command_name],
+            blockConnection: true,
+            blockTimeMS: 1100,
+          }
+        )
+      end
+
+      context 'when error occurs once' do
+        let(:times) { 1 }
+
+        it 'retries and the operation succeeds' do
+          expect(Mongo::Logger.logger).to receive(:warn).once.with(/modern.*attempt 1/).and_call_original
+          perform_operation
+          expect(actual_result).to eq(expected_successful_result)
+        end
+      end
+
+      context 'when error occurs twice' do
+        let(:times) { 2 }
+
+        it 'retries and the operation and fails' do
+          expect(Mongo::Logger.logger).to receive(:warn).once.with(/modern.*attempt 1/).and_call_original
+
+          expect do
+            perform_operation
+          end.to raise_error(Mongo::Error::SocketTimeoutError)
+        end
+
+        it_behaves_like 'it adds diagnostics'
+
+        after do
+          # Assure that the server has completed the operation before moving
+          # on to the next test.
+          sleep 1
+        end
+      end
+    end
+
+    context 'on server versions >= 4.4' do
+      min_server_fcv '4.3'
+
+      context 'for OperationFailure with RetryableWriteError label' do
+        before do
+          client.use('admin').command(
+            configureFailPoint: 'failCommand',
+            mode: { times: times },
+            data: {
+              failCommands: [command_name],
+              errorCode: 5, # normally NOT a retryable error code
+              errorLabels: ['RetryableWriteError']
+            }
+          )
+        end
+
+        context 'when error occurs once' do
+          let(:times) { 1 }
+
+          it 'retries and the operation and succeeds' do
+            expect(Mongo::Logger.logger).to receive(:warn).once.with(/modern.*attempt 1/).and_call_original
+            perform_operation
+            expect(actual_result).to eq(expected_successful_result)
+          end
+        end
+
+        context 'when error occurs twice' do
+          let(:times) { 2 }
+
+          it 'retries the operation and fails' do
+            expect(Mongo::Logger.logger).to receive(:warn).once.with(/modern.*attempt 1/).and_call_original
+
+            expect do
+              perform_operation
+            end.to raise_error(Mongo::Error::OperationFailure, /5/)
+
+            expect(actual_result).to eq(expected_failed_result)
+          end
+
+          it_behaves_like 'it adds diagnostics'
+        end
+      end
+
+      context 'for OperationFailure without RetryableWriteError label' do
+        before do
+          client.use('admin').command(
+            configureFailPoint: 'failCommand',
+            mode: { times: 1 },
+            data: {
+              failCommands: [command_name],
+              errorCode: 91, # normally a retryable error code
+              errorLabels: [],
+            }
+          )
+        end
+
+        it 'raises the error' do
+          expect(Mongo::Logger.logger).not_to receive(:warn)
+
+          expect do
+            perform_operation
+          end.to raise_error(Mongo::Error::OperationFailure, /91/)
+
+          expect(actual_result).to eq(expected_failed_result)
+        end
+      end
+    end
+
+    context 'on server versions < 4.4' do
+      max_server_fcv '4.2'
+
+      context 'for OperationFailure with retryable code' do
+        before do
+          client.use('admin').command(
+            configureFailPoint: 'failCommand',
+            mode: { times: times },
+            data: {
+              failCommands: [command_name],
+              errorCode: 91, # a retryable error code
+            }
+          )
+        end
+
+        context 'when error occurs once' do
+          let(:times) { 1 }
+
+          it 'retries and the operation succeeds' do
+            expect(Mongo::Logger.logger).to receive(:warn).once.with(/modern.*attempt 1/).and_call_original
+            perform_operation
+            expect(actual_result).to eq(expected_successful_result)
+          end
+        end
+
+        context 'when error occurs twice' do
+          let(:times) { 2 }
+
+          it 'retries and the operation and fails' do
+            expect(Mongo::Logger.logger).to receive(:warn).once.with(/modern.*attempt 1/).and_call_original
+
+            expect do
+              perform_operation
+            end.to raise_error(Mongo::Error::OperationFailure, /91/)
+
+            expect(actual_result).to eq(expected_failed_result)
+          end
+
+          it_behaves_like 'it adds diagnostics'
+        end
+      end
+
+      context 'for OperationFailure with non-retryable code' do
+        before do
+          client.use('admin').command(
+            configureFailPoint: 'failCommand',
+            mode: { times: times },
+            data: {
+              failCommands: [command_name],
+              errorCode: 5, # a non-retryable error code
+            }
+          )
+        end
+
+        let(:times) { 1 }
+
+        it 'raises the error' do
+          expect(Mongo::Logger.logger).not_to receive(:warn)
+
+          expect do
+            perform_operation
+          end.to raise_error(Mongo::Error::OperationFailure, /5/)
+
+          expect(actual_result).to eq(expected_failed_result)
+        end
+      end
+    end
+  end
+end