mongo 2.5.3 → 2.6.0

data/spec/mongo/retryable_writes_spec.rb

@@ -1,813 +1,737 @@
 require 'spec_helper'
 
-describe 'Retryable Writes' do
+describe 'Retryable writes integration tests' do
+  include PrimarySocket
 
-  RETRYABLE_WRITES_TESTS.each do |file|
+  after do
+    authorized_collection.delete_many
+  end
 
-    spec = Mongo::CRUD::Spec.new(file)
+  shared_examples_for 'an operation that is retried' do
 
-    context(spec.description) do
+    context 'when the operation fails on the first attempt' do
 
-      spec.tests.each do |test|
+      before do
+        # Note that for writes, server.connectable? is called, refreshing the socket
+        allow(primary_server).to receive(:connectable?).and_return(true)
+        expect(primary_socket).to receive(:write).and_raise(error)
+      end
 
-        context(test.description) do
+      context 'when the error is retryable' do
 
-          let(:collection) do
-            client[TEST_COLL]
-          end
+        before do
+          expect(Mongo::Logger.logger).to receive(:warn).once.and_call_original
+          expect(client.cluster).to receive(:scan!)
+        end
+
+        context 'when the error is a SocketError' do
 
-          let(:client) do
-            authorized_client_with_retry_writes
+          let(:error) do
+            Mongo::Error::SocketError
           end
 
-          before do
-            test.setup_test(collection)
+          it 'retries writes' do
+            operation
+            expect(expectation).to eq(successful_retry_value)
           end
+        end
 
-          after do
-            test.clear_fail_point(collection)
-            collection.delete_many
+        context 'when the error is a SocketTimeoutError' do
+
+          let(:error) do
+            Mongo::Error::SocketTimeoutError
           end
 
-          let(:results) do
-            if test.error?
-              error = nil
-              begin; test.run(collection); rescue => e; error = e; end
-              error
-            else
-              test.run(collection)
-            end
+          it 'retries writes' do
+            operation
+            expect(expectation).to eq(successful_retry_value)
           end
+        end
 
-          it 'has the correct data in the collection', if: (sessions_enabled? && replica_set? && test.outcome_collection_data) do
-            skip 'Test cannot be run on this server version' unless spec.server_version_satisfied?(client)
-            results
-            expect(collection.find.to_a).to match_collection_data(test)
+        context 'when the error is a retryable OperationFailure' do
+
+          let(:error) do
+            Mongo::Error::OperationFailure.new('not master')
           end
 
-          if test.error?
-            it 'raises an error', if: sessions_enabled? && replica_set? do
-              skip 'Test cannot be run on this server version' unless spec.server_version_satisfied?(client)
-              expect(results).to be_a(Mongo::Error)
-            end
-          else
-            it 'returns the correct result', if: sessions_enabled? && replica_set? do
-              skip 'Test cannot be run on this server version' unless spec.server_version_satisfied?(client)
-              expect(results).to match_operation_result(test)
-            end
+          it 'retries writes' do
+            operation
+            expect(expectation).to eq(successful_retry_value)
           end
         end
       end
-    end
-  end
 
-  describe 'Retryable writes integration tests' do
+      context 'when the error is not retryable' do
 
-    let(:primary) do
-      primary = client.cluster.next_primary
-    end
+        context 'when the error is a non-retryable OperationFailure' do
 
-    let(:primary_connection) do
-      connection = primary.pool.checkout
-      connection.connect!
-      primary.pool.checkin(connection)
-      connection
-    end
+          let(:error) do
+            Mongo::Error::OperationFailure.new('other error')
+          end
 
-    let(:primary_socket) do
-      primary_connection.send(:socket)
+          it 'does not retry writes' do
+            expect {
+              operation
+            }.to raise_error(error)
+            expect(expectation).to eq(unsuccessful_retry_value)
+          end
+        end
+      end
     end
 
-    after do
-      authorized_collection.delete_many
-    end
+    context 'when the operation fails on the first attempt and again on the second attempt' do
 
-    shared_examples_for 'an operation that is retried' do
+      before do
+        # Note that for writes, server.connectable? is called, refreshing the socket
+        allow(primary_server).to receive(:connectable?).and_return(true)
+        allow(primary_socket).to receive(:write).and_raise(error)
+      end
 
-      context 'when the operation fails on the first attempt' do
+      context 'when the selected server does not support retryable writes' do
 
         before do
-          # Note that for writes, server.connectable? is called, refreshing the socket
-          allow(primary).to receive(:connectable?).and_return(true)
+          legacy_primary = double('legacy primary', :'retry_writes?' => false)
+          allow(client.cluster).to receive(:next_primary).and_return(primary_server, legacy_primary)
           expect(primary_socket).to receive(:write).and_raise(error)
         end
 
-        context 'when the error is retryable' do
+        context 'when the error is a SocketError' do
 
-          before do
-            expect(Mongo::Logger.logger).to receive(:warn).once.and_call_original
-            expect(client.cluster).to receive(:scan!)
+          let(:error) do
+            Mongo::Error::SocketError
           end
 
-          context 'when the error is a SocketError' do
-
-            let(:error) do
-              Mongo::Error::SocketError
-            end
-
-            it 'retries writes' do
+          it 'does not retry writes and raises the original error' do
+            expect {
               operation
-              expect(expectation).to eq(successful_retry_value)
-            end
+            }.to raise_error(error)
+            expect(expectation).to eq(unsuccessful_retry_value)
           end
+        end
 
-          context 'when the error is a SocketTimeoutError' do
-
-            let(:error) do
-              Mongo::Error::SocketTimeoutError
-            end
+        context 'when the error is a SocketTimeoutError' do
 
-            it 'retries writes' do
-              operation
-              expect(expectation).to eq(successful_retry_value)
-            end
+          let(:error) do
+            Mongo::Error::SocketTimeoutError
           end
 
-          context 'when the error is a retryable OperationFailure' do
-
-            let(:error) do
-              Mongo::Error::OperationFailure.new('not master')
-            end
-
-            it 'retries writes' do
+          it 'does not retry writes and raises the original error' do
+            expect {
               operation
-              expect(expectation).to eq(successful_retry_value)
-            end
+            }.to raise_error(error)
+            expect(expectation).to eq(unsuccessful_retry_value)
           end
         end
 
-        context 'when the error is not retryable' do
-
-          context 'when the error is a non-retryable OperationFailure' do
+        context 'when the error is a retryable OperationFailure' do
 
-            let(:error) do
-              Mongo::Error::OperationFailure.new('other error')
-            end
+          let(:error) do
+            Mongo::Error::OperationFailure.new('not master')
+          end
 
-            it 'does not retry writes' do
-              expect {
-                operation
-              }.to raise_error(error)
-              expect(expectation).to eq(unsuccessful_retry_value)
-            end
+          it 'does not retry writes and raises the original error' do
+            expect {
+              operation
+            }.to raise_error(error)
+            expect(expectation).to eq(unsuccessful_retry_value)
           end
         end
       end
 
-      context 'when the operation fails on the first attempt and again on the second attempt' do
+      [Mongo::Error::SocketError,
+       Mongo::Error::SocketTimeoutError,
+       Mongo::Error::OperationFailure.new('not master')].each do |retryable_error|
 
-        before do
-          # Note that for writes, server.connectable? is called, refreshing the socket
-          allow(primary).to receive(:connectable?).and_return(true)
-          allow(primary_socket).to receive(:write).and_raise(error)
-        end
+        context "when the first error is a #{retryable_error}" do
 
-        context 'when the selected server does not support retryable writes' do
+          let(:error) do
+            retryable_error
+          end
 
           before do
-            legacy_primary = double('legacy primary', :'retry_writes?' => false)
-            allow(client.cluster).to receive(:next_primary).and_return(primary, legacy_primary)
-            expect(primary_socket).to receive(:write).and_raise(error)
+            bad_socket = primary_connection.address.socket(primary_connection.socket_timeout,
+                                                           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(primary_connection.address).to receive(:socket).and_return(bad_socket, good_socket)
           end
 
-          context 'when the error is a SocketError' do
+          context 'when the second error is a SocketError' do
 
-            let(:error) do
+            let(:second_error) do
               Mongo::Error::SocketError
             end
 
-            it 'does not retry writes and raises the original error' do
+            before do
+              expect(client.cluster).to receive(:scan!).twice
+            end
+
+            it 'does not retry writes and raises the second error' do
               expect {
                 operation
-              }.to raise_error(error)
+              }.to raise_error(second_error)
               expect(expectation).to eq(unsuccessful_retry_value)
             end
           end
 
-          context 'when the error is a SocketTimeoutError' do
+          context 'when the second error is a SocketTimeoutError' do
 
-            let(:error) do
+            before do
+              expect(client.cluster).to receive(:scan!).twice
+            end
+
+            let(:second_error) do
               Mongo::Error::SocketTimeoutError
             end
 
-            it 'does not retry writes and raises the original error' do
+            it 'does not retry writes and raises the second error' do
               expect {
                 operation
-              }.to raise_error(error)
+              }.to raise_error(second_error)
               expect(expectation).to eq(unsuccessful_retry_value)
             end
           end
 
-          context 'when the error is a retryable OperationFailure' do
+          context 'when the second error is a retryable OperationFailure' do
 
-            let(:error) do
+            before do
+              expect(client.cluster).to receive(:scan!).twice
+            end
+
+            let(:second_error) do
               Mongo::Error::OperationFailure.new('not master')
             end
 
-            it 'does not retry writes and raises the original error' do
+            it 'does not retry writes and raises the second error' do
               expect {
                 operation
-              }.to raise_error(error)
+              }.to raise_error(second_error)
               expect(expectation).to eq(unsuccessful_retry_value)
             end
           end
-        end
-
-        [Mongo::Error::SocketError,
-         Mongo::Error::SocketTimeoutError,
-         Mongo::Error::OperationFailure.new('not master')].each do |retryable_error|
 
-          context "when the first error is a #{retryable_error}" do
-
-            let(:error) do
-              retryable_error
-            end
+          context 'when the second error is a non-retryable OperationFailure' do
 
             before do
-              bad_socket = primary_connection.address.socket(primary_connection.socket_timeout,
-                                                             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(primary_connection.address).to receive(:socket).and_return(bad_socket, good_socket)
+              expect(client.cluster).to receive(:scan!).once
             end
 
-            context 'when the second error is a SocketError' do
-
-              let(:second_error) do
-                Mongo::Error::SocketError
-              end
-
-              before do
-                expect(client.cluster).to receive(:scan!).twice
-              end
-
-              it 'does not retry writes and raises the second error' do
-                expect {
-                  operation
-                }.to raise_error(second_error)
-                expect(expectation).to eq(unsuccessful_retry_value)
-              end
-            end
-
-            context 'when the second error is a SocketTimeoutError' do
-
-              before do
-                expect(client.cluster).to receive(:scan!).twice
-              end
-
-              let(:second_error) do
-                Mongo::Error::SocketTimeoutError
-              end
-
-              it 'does not retry writes and raises the second error' do
-                expect {
-                  operation
-                }.to raise_error(second_error)
-                expect(expectation).to eq(unsuccessful_retry_value)
-              end
+            let(:second_error) do
+              Mongo::Error::OperationFailure.new('other error')
             end
 
-            context 'when the second error is a retryable OperationFailure' do
-
-              before do
-                expect(client.cluster).to receive(:scan!).twice
-              end
-
-              let(:second_error) do
-                Mongo::Error::OperationFailure.new('not master')
-              end
-
-              it 'does not retry writes and raises the second error' do
-                expect {
-                  operation
-                }.to raise_error(second_error)
-                expect(expectation).to eq(unsuccessful_retry_value)
-              end
+            it 'does not retry writes and raises the first error' do
+              expect {
+                operation
+              }.to raise_error(error)
+              expect(expectation).to eq(unsuccessful_retry_value)
             end
+          end
 
-            context 'when the second error is a non-retryable OperationFailure' do
-
-              before do
-                expect(client.cluster).to receive(:scan!).once
-              end
-
-              let(:second_error) do
-                Mongo::Error::OperationFailure.new('other error')
-              end
+          context 'when the second error is a another error' do
 
-              it 'does not retry writes and raises the first error' do
-                expect {
-                  operation
-                }.to raise_error(error)
-                expect(expectation).to eq(unsuccessful_retry_value)
-              end
+            let(:second_error) do
+              StandardError
             end
 
-            context 'when the second error is a another error' do
-
-              let(:second_error) do
-                StandardError
-              end
-
-              it 'does not retry writes and raises the first error' do
-                expect {
-                  operation
-                }.to raise_error(error)
-                expect(expectation).to eq(unsuccessful_retry_value)
-              end
+            it 'does not retry writes and raises the first error' do
+              expect {
+                operation
+              }.to raise_error(error)
+              expect(expectation).to eq(unsuccessful_retry_value)
             end
           end
         end
       end
     end
+  end
 
-    shared_examples_for 'an operation that is not retried' do
-
-      before do
-        # Note that for writes, server.connectable? is called, refreshing the socket
-        allow(primary).to receive(:connectable?).and_return(true)
-        expect(primary_socket).to receive(:write).and_raise(Mongo::Error::SocketError)
-        expect(client.cluster).not_to receive(:scan!)
-      end
+  shared_examples_for 'an operation that is not retried' do
 
-      it 'does not retry writes' do
-        expect {
-          operation
-        }.to raise_error(Mongo::Error::SocketError)
-        expect(expectation).to eq(unsuccessful_retry_value)
-      end
+    before do
+      # Note that for writes, server.connectable? is called, refreshing the socket
+      allow(primary_server).to receive(:connectable?).and_return(true)
+      expect(primary_socket).to receive(:write).and_raise(Mongo::Error::SocketError)
+      expect(client.cluster).not_to receive(:scan!)
     end
 
-    shared_examples_for 'an operation that does not support retryable writes' do
+    it 'does not retry writes' do
+      expect {
+        operation
+      }.to raise_error(Mongo::Error::SocketError)
+      expect(expectation).to eq(unsuccessful_retry_value)
+    end
+  end
 
-      let!(:client) do
-        authorized_client_with_retry_writes
-      end
+  shared_examples_for 'an operation that does not support retryable writes' do
 
-      let!(:collection) do
-        client[TEST_COLL, write: WRITE_CONCERN]
-      end
+    let!(:client) do
+      authorized_client_with_retry_writes
+    end
 
-      before do
-        # Note that for writes, server.connectable? is called, refreshing the socket
-        allow(primary).to receive(:connectable?).and_return(true)
-        expect(primary_socket).to receive(:write).and_raise(Mongo::Error::SocketError)
-        expect(client.cluster).not_to receive(:scan!)
-      end
+    let!(:collection) do
+      client[TEST_COLL, write: WRITE_CONCERN]
+    end
 
-      it 'does not retry writes' do
-        expect {
-          operation
-        }.to raise_error(Mongo::Error::SocketError)
-        expect(expectation).to eq(unsuccessful_retry_value)
-      end
+    before do
+      # Note that for writes, server.connectable? is called, refreshing the socket
+      allow(primary_server).to receive(:connectable?).and_return(true)
+      expect(primary_socket).to receive(:write).and_raise(Mongo::Error::SocketError)
+      expect(client.cluster).not_to receive(:scan!)
     end
 
-    shared_examples_for 'supported retryable writes' do
+    it 'does not retry writes' do
+      expect {
+        operation
+      }.to raise_error(Mongo::Error::SocketError)
+      expect(expectation).to eq(unsuccessful_retry_value)
+    end
+  end
 
-      context 'when the client has retry_writes set to true' do
+  shared_examples_for 'supported retryable writes' do
 
-        let!(:client) do
-          authorized_client_with_retry_writes
-        end
+    context 'when the client has retry_writes set to true' do
 
-        context 'when the collection has write concern acknowledged' do
+      let!(:client) do
+        authorized_client_with_retry_writes
+      end
 
-          let!(:collection) do
-            client[TEST_COLL, write: WRITE_CONCERN]
-          end
+      context 'when the collection has write concern acknowledged' do
 
-          context 'when the server supports retryable writes' do
+        let!(:collection) do
+          client[TEST_COLL, write: WRITE_CONCERN]
+        end
 
-            before do
-              allow(primary).to receive(:retry_writes?).and_return(true)
-            end
+        context 'when the server supports retryable writes' do
 
-            if standalone? && sessions_enabled?
-              it_behaves_like 'an operation that is not retried'
-            elsif sessions_enabled?
-              it_behaves_like 'an operation that is retried'
-            end
+          before do
+            allow(primary_server).to receive(:retry_writes?).and_return(true)
           end
 
-          context 'when the server does not support retryable writes' do
-
-            before do
-              allow(primary).to receive(:retry_writes?).and_return(false)
-            end
-
+          if standalone? && sessions_enabled?
             it_behaves_like 'an operation that is not retried'
+          elsif sessions_enabled?
+            it_behaves_like 'an operation that is retried'
           end
         end
 
-        context 'when the collection has write concern unacknowledged' do
+        context 'when the server does not support retryable writes' do
 
-          let!(:collection) do
-            client[TEST_COLL, write: { w: 0 }]
+          before do
+            allow(primary_server).to receive(:retry_writes?).and_return(false)
           end
 
           it_behaves_like 'an operation that is not retried'
         end
+      end
 
-        context 'when the collection has write concern not set' do
+      context 'when the collection has write concern unacknowledged' do
 
-          let!(:collection) do
-            client[TEST_COLL]
-          end
+        let!(:collection) do
+          client[TEST_COLL, write: { w: 0 }]
+        end
 
-          context 'when the server supports retryable writes' do
+        it_behaves_like 'an operation that is not retried'
+      end
 
-            before do
-              allow(primary).to receive(:retry_writes?).and_return(true)
-            end
+      context 'when the collection has write concern not set' do
 
-            if standalone? && sessions_enabled?
-              it_behaves_like 'an operation that is not retried'
-            elsif sessions_enabled?
-              it_behaves_like 'an operation that is retried'
-            end
-          end
+        let!(:collection) do
+          client[TEST_COLL]
+        end
 
-          context 'when the server does not support retryable writes' do
+        context 'when the server supports retryable writes' do
 
-            before do
-              allow(primary).to receive(:retry_writes?).and_return(false)
-            end
+          before do
+            allow(primary_server).to receive(:retry_writes?).and_return(true)
+          end
 
+          if standalone? && sessions_enabled?
             it_behaves_like 'an operation that is not retried'
+          elsif sessions_enabled?
+            it_behaves_like 'an operation that is retried'
           end
         end
-      end
-
-      context 'when the client has retry_writes set to false' do
-
-        let!(:client) do
-          authorized_client.with(retry_writes: false)
-        end
-
-        after do
-          client.close
-        end
 
-        context 'when the collection has write concern acknowledged' do
+        context 'when the server does not support retryable writes' do
 
-          let!(:collection) do
-            client[TEST_COLL, write: WRITE_CONCERN]
+          before do
+            allow(primary_server).to receive(:retry_writes?).and_return(false)
           end
 
           it_behaves_like 'an operation that is not retried'
         end
+      end
+    end
 
-        context 'when the collection has write concern unacknowledged' do
+    context 'when the client has retry_writes set to false' do
 
-          let!(:collection) do
-            client[TEST_COLL, write: { w: 0 }]
-          end
+      let!(:client) do
+        authorized_client.with(retry_writes: false)
+      end
 
-          it_behaves_like 'an operation that is not retried'
+      after do
+        client.close
+      end
+
+      context 'when the collection has write concern acknowledged' do
+
+        let!(:collection) do
+          client[TEST_COLL, write: WRITE_CONCERN]
         end
 
-        context 'when the collection has write concern not set' do
+        it_behaves_like 'an operation that is not retried'
+      end
 
-          let!(:collection) do
-            client[TEST_COLL]
-          end
+      context 'when the collection has write concern unacknowledged' do
 
-          it_behaves_like 'an operation that is not retried'
+        let!(:collection) do
+          client[TEST_COLL, write: { w: 0 }]
         end
+
+        it_behaves_like 'an operation that is not retried'
       end
 
-      context 'when the client has retry_writes not set' do
+      context 'when the collection has write concern not set' do
 
-        let!(:client) do
-          authorized_client
+        let!(:collection) do
+          client[TEST_COLL]
         end
 
-        context 'when the collection has write concern acknowledged' do
+        it_behaves_like 'an operation that is not retried'
+      end
+    end
 
-          let!(:collection) do
-            client[TEST_COLL, write: WRITE_CONCERN]
-          end
+    context 'when the client has retry_writes not set' do
 
-          it_behaves_like 'an operation that is not retried'
+      let!(:client) do
+        authorized_client
+      end
+
+      context 'when the collection has write concern acknowledged' do
+
+        let!(:collection) do
+          client[TEST_COLL, write: WRITE_CONCERN]
         end
 
-        context 'when the collection has write concern unacknowledged' do
+        it_behaves_like 'an operation that is not retried'
+      end
 
-          let!(:collection) do
-            client[TEST_COLL, write: { w: 0 }]
-          end
+      context 'when the collection has write concern unacknowledged' do
 
-          it_behaves_like 'an operation that is not retried'
+        let!(:collection) do
+          client[TEST_COLL, write: { w: 0 }]
         end
 
-        context 'when the collection has write concern not set' do
+        it_behaves_like 'an operation that is not retried'
+      end
 
-          let!(:collection) do
-            client[TEST_COLL]
-          end
+      context 'when the collection has write concern not set' do
 
-          it_behaves_like 'an operation that is not retried'
+        let!(:collection) do
+          client[TEST_COLL]
         end
+
+        it_behaves_like 'an operation that is not retried'
       end
     end
+  end
 
-    context 'when the operation is insert_one' do
-
-      let(:operation) do
-        collection.insert_one(a:1)
-      end
+  context 'when the operation is insert_one' do
 
-      let(:expectation) do
-        collection.find(a: 1).count
-      end
+    let(:operation) do
+      collection.insert_one(a:1)
+    end
 
-      let(:successful_retry_value) do
-        1
-      end
+    let(:expectation) do
+      collection.find(a: 1).count
+    end
 
-      let(:unsuccessful_retry_value) do
-        0
-      end
+    let(:successful_retry_value) do
+      1
+    end
 
-      it_behaves_like 'supported retryable writes'
+    let(:unsuccessful_retry_value) do
+      0
     end
 
-    context 'when the operation is update_one' do
+    it_behaves_like 'supported retryable writes'
+  end
 
-      before do
-        # Account for when the collection has unacknowledged write concern and use authorized_collection here.
-        authorized_collection.insert_one(a:0)
-      end
+  context 'when the operation is update_one' do
 
-      let(:operation) do
-        collection.update_one({ a: 0 }, { '$set' => { a: 1 } })
-      end
+    before do
+      # Account for when the collection has unacknowledged write concern and use authorized_collection here.
+      authorized_collection.insert_one(a:0)
+    end
 
-      let(:expectation) do
-        collection.find(a: 1).count
-      end
+    let(:operation) do
+      collection.update_one({ a: 0 }, { '$set' => { a: 1 } })
+    end
 
-      let(:successful_retry_value) do
-        1
-      end
+    let(:expectation) do
+      collection.find(a: 1).count
+    end
 
-      let(:unsuccessful_retry_value) do
-        0
-      end
+    let(:successful_retry_value) do
+      1
+    end
 
-      it_behaves_like 'supported retryable writes'
+    let(:unsuccessful_retry_value) do
+      0
     end
 
-    context 'when the operation is replace_one' do
+    it_behaves_like 'supported retryable writes'
+  end
 
-      before do
-        # Account for when the collection has unacknowledged write concern and use authorized_collection here.
-        authorized_collection.insert_one(a:0)
-      end
+  context 'when the operation is replace_one' do
 
-      let(:operation) do
-        collection.replace_one({ a: 0 }, { a: 1 })
-      end
+    before do
+      # Account for when the collection has unacknowledged write concern and use authorized_collection here.
+      authorized_collection.insert_one(a:0)
+    end
 
-      let(:expectation) do
-        collection.find(a: 1).count
-      end
+    let(:operation) do
+      collection.replace_one({ a: 0 }, { a: 1 })
+    end
 
-      let(:successful_retry_value) do
-        1
-      end
+    let(:expectation) do
+      collection.find(a: 1).count
+    end
 
-      let(:unsuccessful_retry_value) do
-        0
-      end
+    let(:successful_retry_value) do
+      1
+    end
 
-      it_behaves_like 'supported retryable writes'
+    let(:unsuccessful_retry_value) do
+      0
     end
 
-    context 'when the operation is delete_one' do
+    it_behaves_like 'supported retryable writes'
+  end
 
-      before do
-        # Account for when the collection has unacknowledged write concern and use authorized_collection here.
-        authorized_collection.insert_one(a:1)
-      end
+  context 'when the operation is delete_one' do
 
-      let(:operation) do
-        collection.delete_one(a:1)
-      end
+    before do
+      # Account for when the collection has unacknowledged write concern and use authorized_collection here.
+      authorized_collection.insert_one(a:1)
+    end
 
-      let(:expectation) do
-        collection.find(a: 1).count
-      end
+    let(:operation) do
+      collection.delete_one(a:1)
+    end
 
-      let(:successful_retry_value) do
-        0
-      end
+    let(:expectation) do
+      collection.find(a: 1).count
+    end
 
-      let(:unsuccessful_retry_value) do
-        1
-      end
+    let(:successful_retry_value) do
+      0
+    end
 
-      it_behaves_like 'supported retryable writes'
+    let(:unsuccessful_retry_value) do
+      1
     end
 
-    context 'when the operation is find_one_and_update' do
+    it_behaves_like 'supported retryable writes'
+  end
 
-      before do
-        # Account for when the collection has unacknowledged write concern and use authorized_collection here.
-        authorized_collection.insert_one(a:0)
-      end
+  context 'when the operation is find_one_and_update' do
 
-      let(:operation) do
-        collection.find_one_and_update({ a: 0 }, { '$set' => { a: 1 } })
-      end
+    before do
+      # Account for when the collection has unacknowledged write concern and use authorized_collection here.
+      authorized_collection.insert_one(a:0)
+    end
 
-      let(:expectation) do
-        collection.find(a: 1).count
-      end
+    let(:operation) do
+      collection.find_one_and_update({ a: 0 }, { '$set' => { a: 1 } })
+    end
 
-      let(:successful_retry_value) do
-        1
-      end
+    let(:expectation) do
+      collection.find(a: 1).count
+    end
 
-      let(:unsuccessful_retry_value) do
-        0
-      end
+    let(:successful_retry_value) do
+      1
+    end
 
-      it_behaves_like 'supported retryable writes'
+    let(:unsuccessful_retry_value) do
+      0
     end
 
-    context 'when the operation is find_one_and_replace' do
+    it_behaves_like 'supported retryable writes'
+  end
 
-      before do
-        # Account for when the collection has unacknowledged write concern and use authorized_collection here.
-        authorized_collection.insert_one(a:0)
-      end
+  context 'when the operation is find_one_and_replace' do
 
-      let(:operation) do
-        collection.find_one_and_replace({ a: 0 }, { a: 3 })
-      end
+    before do
+      # Account for when the collection has unacknowledged write concern and use authorized_collection here.
+      authorized_collection.insert_one(a:0)
+    end
 
-      let(:expectation) do
-        collection.find(a: 3).count
-      end
+    let(:operation) do
+      collection.find_one_and_replace({ a: 0 }, { a: 3 })
+    end
 
-      let(:successful_retry_value) do
-        1
-      end
+    let(:expectation) do
+      collection.find(a: 3).count
+    end
 
-      let(:unsuccessful_retry_value) do
-        0
-      end
+    let(:successful_retry_value) do
+      1
+    end
 
-      it_behaves_like 'supported retryable writes'
+    let(:unsuccessful_retry_value) do
+      0
     end
 
-    context 'when the operation is find_one_and_delete' do
+    it_behaves_like 'supported retryable writes'
+  end
 
-      before do
-        # Account for when the collection has unacknowledged write concern and use authorized_collection here.
-        authorized_collection.insert_one(a:1)
-      end
+  context 'when the operation is find_one_and_delete' do
 
-      let(:operation) do
-        collection.find_one_and_delete({ a: 1 })
-      end
+    before do
+      # Account for when the collection has unacknowledged write concern and use authorized_collection here.
+      authorized_collection.insert_one(a:1)
+    end
 
-      let(:expectation) do
-        collection.find(a: 1).count
-      end
+    let(:operation) do
+      collection.find_one_and_delete({ a: 1 })
+    end
 
-      let(:successful_retry_value) do
-        0
-      end
+    let(:expectation) do
+      collection.find(a: 1).count
+    end
 
-      let(:unsuccessful_retry_value) do
-        1
-      end
+    let(:successful_retry_value) do
+      0
+    end
 
-      it_behaves_like 'supported retryable writes'
+    let(:unsuccessful_retry_value) do
+      1
     end
 
-    context 'when the operation is update_many' do
+    it_behaves_like 'supported retryable writes'
+  end
 
-      before do
-        # Account for when the collection has unacknowledged write concern and use authorized_collection here.
-        authorized_collection.insert_one(a:0)
-        authorized_collection.insert_one(a:0)
-      end
+  context 'when the operation is update_many' do
 
-      let(:operation) do
-        collection.update_many({ a: 0 }, { '$set' => { a: 1 } })
-      end
+    before do
+      # Account for when the collection has unacknowledged write concern and use authorized_collection here.
+      authorized_collection.insert_one(a:0)
+      authorized_collection.insert_one(a:0)
+    end
 
-      let(:expectation) do
-        collection.find(a: 1).count
-      end
+    let(:operation) do
+      collection.update_many({ a: 0 }, { '$set' => { a: 1 } })
+    end
 
-      let(:unsuccessful_retry_value) do
-        0
-      end
+    let(:expectation) do
+      collection.find(a: 1).count
+    end
 
-      it_behaves_like 'an operation that does not support retryable writes'
+    let(:unsuccessful_retry_value) do
+      0
     end
 
-    context 'when the operation is delete_many' do
+    it_behaves_like 'an operation that does not support retryable writes'
+  end
 
-      before do
-        # Account for when the collection has unacknowledged write concern and use authorized_collection here.
-        authorized_collection.insert_one(a:1)
-        authorized_collection.insert_one(a:1)
-      end
+  context 'when the operation is delete_many' do
 
-      let(:operation) do
-        collection.delete_many(a: 1)
-      end
+    before do
+      # Account for when the collection has unacknowledged write concern and use authorized_collection here.
+      authorized_collection.insert_one(a:1)
+      authorized_collection.insert_one(a:1)
+    end
 
-      let(:expectation) do
-        collection.find(a: 1).count
-      end
+    let(:operation) do
+      collection.delete_many(a: 1)
+    end
 
-      let(:unsuccessful_retry_value) do
-        2
-      end
+    let(:expectation) do
+      collection.find(a: 1).count
+    end
 
-      it_behaves_like 'an operation that does not support retryable writes'
+    let(:unsuccessful_retry_value) do
+      2
     end
 
-    context 'when the operation is a bulk write' do
+    it_behaves_like 'an operation that does not support retryable writes'
+  end
 
-      before do
-        # Account for when the collection has unacknowledged write concern and use authorized_collection here.
-        authorized_collection.insert_one(a: 1)
-      end
+  context 'when the operation is a bulk write' do
 
-      let(:operation) do
-        collection.bulk_write([{ delete_one: { filter: { a: 1 } } },
-                               { insert_one: { a: 1 } },
-                               { insert_one: { a: 1 } }])
-      end
+    before do
+      # Account for when the collection has unacknowledged write concern and use authorized_collection here.
+      authorized_collection.insert_one(a: 1)
+    end
 
-      let(:expectation) do
-        collection.find(a: 1).count
-      end
+    let(:operation) do
+      collection.bulk_write([{ delete_one: { filter: { a: 1 } } },
+                             { insert_one: { a: 1 } },
+                             { insert_one: { a: 1 } }])
+    end
 
-      let(:successful_retry_value) do
-        2
-      end
+    let(:expectation) do
+      collection.find(a: 1).count
+    end
 
-      let(:unsuccessful_retry_value) do
-        1
-      end
+    let(:successful_retry_value) do
+      2
+    end
 
-      it_behaves_like 'supported retryable writes'
+    let(:unsuccessful_retry_value) do
+      1
     end
 
-    context 'when the operation is bulk write including delete_many' do
+    it_behaves_like 'supported retryable writes'
+  end
 
-      before do
-        # Account for when the collection has unacknowledged write concern and use authorized_collection here.
-        authorized_collection.insert_one(a:1)
-        authorized_collection.insert_one(a:1)
-      end
+  context 'when the operation is bulk write including delete_many' do
 
-      let(:operation) do
-        collection.bulk_write([{ delete_many: { filter: { a: 1 } } }])
-      end
+    before do
+      # Account for when the collection has unacknowledged write concern and use authorized_collection here.
+      authorized_collection.insert_one(a:1)
+      authorized_collection.insert_one(a:1)
+    end
 
-      let(:expectation) do
-        collection.find(a: 1).count
-      end
+    let(:operation) do
+      collection.bulk_write([{ delete_many: { filter: { a: 1 } } }])
+    end
 
-      let(:unsuccessful_retry_value) do
-        2
-      end
+    let(:expectation) do
+      collection.find(a: 1).count
+    end
 
-      it_behaves_like 'an operation that does not support retryable writes'
+    let(:unsuccessful_retry_value) do
+      2
     end
 
-    context 'when the operation is bulk write including update_many' do
+    it_behaves_like 'an operation that does not support retryable writes'
+  end
 
-      before do
-        # Account for when the collection has unacknowledged write concern and use authorized_collection here.
-        authorized_collection.insert_one(a:0)
-        authorized_collection.insert_one(a:0)
-      end
+  context 'when the operation is bulk write including update_many' do
 
-      let(:operation) do
-        collection.bulk_write([{ update_many: { filter: { a: 0 }, update: { a: 1 } } }])
-      end
+    before do
+      # Account for when the collection has unacknowledged write concern and use authorized_collection here.
+      authorized_collection.insert_one(a:0)
+      authorized_collection.insert_one(a:0)
+    end
 
-      let(:expectation) do
-        collection.find(a: 1).count
-      end
+    let(:operation) do
+      collection.bulk_write([{ update_many: { filter: { a: 0 }, update: { a: 1 } } }])
+    end
 
-      let(:unsuccessful_retry_value) do
-        0
-      end
+    let(:expectation) do
+      collection.find(a: 1).count
+    end
 
-      it_behaves_like 'an operation that does not support retryable writes'
+    let(:unsuccessful_retry_value) do
+      0
     end
+
+    it_behaves_like 'an operation that does not support retryable writes'
   end
 end