mongo 2.12.4 → 2.13.0.beta1

data/spec/mongo/operation/result_spec.rb

@@ -2,8 +2,13 @@ require 'spec_helper'
 
 describe Mongo::Operation::Result do
 
+  let(:description) do
+    Mongo::Server::Description.new(double('description address'),
+      'minWireVersion' => 0, 'maxWireVersion' => 2)
+  end
+
   let(:result) do
-    described_class.new(reply)
+    described_class.new(reply, description)
   end
 
   let(:cursor_id) { 0 }

data/spec/mongo/operation/update/bulk_spec.rb

@@ -98,7 +98,9 @@ describe Mongo::Operation::Update do
         end
 
         it 'updates the document' do
-          op.bulk_execute(authorized_primary, client: nil)
+          authorized_primary.with_connection do |connection|
+            op.bulk_execute(connection, client: nil)
+          end
           expect(authorized_collection.find(field: 'blah').count).to eq(1)
         end
       end
@@ -122,7 +124,9 @@ describe Mongo::Operation::Update do
         end
 
         it 'updates the documents' do
-          op.bulk_execute(authorized_primary, client: nil)
+          authorized_primary.with_connection do |connection|
+            op.bulk_execute(connection, client: nil)
+          end
           expect(authorized_collection.find(field: 'blah').count).to eq(2)
         end
       end
@@ -154,7 +158,9 @@ describe Mongo::Operation::Update do
         context 'when write concern is acknowledged' do
 
           it 'aborts after first error' do
-            failing_update.bulk_execute(authorized_primary, client: nil)
+            authorized_primary.with_connection do |connection|
+              failing_update.bulk_execute(connection, client: nil)
+            end
             expect(authorized_collection.find(other: 'blah').count).to eq(0)
           end
         end
@@ -166,7 +172,9 @@ describe Mongo::Operation::Update do
           end
 
           it 'aborts after first error' do
-            failing_update.bulk_execute(authorized_primary, client: nil)
+            authorized_primary.with_connection do |connection|
+              failing_update.bulk_execute(connection, client: nil)
+            end
             expect(authorized_collection.find(other: 'blah').count).to eq(0)
           end
         end
@@ -199,7 +207,9 @@ describe Mongo::Operation::Update do
         context 'when write concern is acknowledged' do
 
           it 'does not abort after first error' do
-            failing_update.bulk_execute(authorized_primary, client: nil)
+            authorized_primary.with_connection do |connection|
+              failing_update.bulk_execute(connection, client: nil)
+            end
             expect(authorized_collection.find(other: 'blah').count).to eq(1)
           end
         end
@@ -211,7 +221,9 @@ describe Mongo::Operation::Update do
           end
 
           it 'does not abort after first error' do
-            failing_update.bulk_execute(authorized_primary, client: nil)
+            authorized_primary.with_connection do |connection|
+              failing_update.bulk_execute(connection, client: nil)
+            end
             expect(authorized_collection.find(other: 'blah').count).to eq(1)
           end
         end

data/spec/mongo/operation/update/command_spec.rb

@@ -68,6 +68,8 @@ describe Mongo::Operation::Update::Command do
   end
 
   describe 'write concern' do
+    # https://jira.mongodb.org/browse/RUBY-2224
+    skip_if_linting
 
     context 'when write concern is not specified' do
 
@@ -93,6 +95,8 @@ describe Mongo::Operation::Update::Command do
   end
 
   describe '#message' do
+    # https://jira.mongodb.org/browse/RUBY-2224
+    skip_if_linting
 
     context 'when the server does not support OP_MSG' do
       max_server_version '3.4'

data/spec/mongo/operation/update/op_msg_spec.rb

@@ -23,6 +23,15 @@ describe Mongo::Operation::Update::OpMsg do
 
   let(:op) { described_class.new(spec) }
 
+  let(:connection) do
+    double('connection').tap do |connection|
+      allow(connection).to receive(:server).and_return(authorized_primary)
+      allow(connection).to receive(:features).and_return(authorized_primary.features)
+      allow(connection).to receive(:description).and_return(authorized_primary.description)
+      allow(connection).to receive(:cluster_time).and_return(authorized_primary.cluster_time)
+    end
+  end
+
   describe '#initialize' do
 
     context 'spec' do
@@ -68,6 +77,8 @@ describe Mongo::Operation::Update::OpMsg do
   end
 
   describe 'write concern' do
+    # https://jira.mongodb.org/browse/RUBY-2224
+    skip_if_linting
 
     context 'when write concern is not specified' do
 
@@ -80,19 +91,21 @@ describe Mongo::Operation::Update::OpMsg do
       end
 
       it 'does not include write concern in the selector' do
-        expect(op.send(:command, authorized_primary)[:writeConcern]).to be_nil
+        expect(op.send(:command, connection)[:writeConcern]).to be_nil
       end
     end
 
     context 'when write concern is specified' do
 
       it 'includes write concern in the selector' do
-        expect(op.send(:command, authorized_primary)[:writeConcern]).to eq(write_concern.options)
+        expect(op.send(:command, connection)[:writeConcern]).to eq(write_concern.options)
       end
     end
   end
 
   describe '#message' do
+    # https://jira.mongodb.org/browse/RUBY-2224
+    skip_if_linting
 
     context 'when the server supports OP_MSG' do
       min_server_fcv '3.6'
@@ -126,7 +139,7 @@ describe Mongo::Operation::Update::OpMsg do
         it 'creates the correct OP_MSG message' do
           authorized_client.command(ping:1)
           expect(Mongo::Protocol::Msg).to receive(:new).with([], {}, expected_global_args, expected_payload_1)
-          op.send(:message, authorized_primary)
+          op.send(:message, connection)
         end
       end
 
@@ -141,7 +154,7 @@ describe Mongo::Operation::Update::OpMsg do
         it 'creates the correct OP_MSG message' do
           authorized_client.command(ping:1)
           expect(Mongo::Protocol::Msg).to receive(:new).with([], {}, expected_global_args, expected_payload_1)
-          op.send(:message, authorized_primary)
+          op.send(:message, connection)
         end
 
         context 'when an implicit session is created and the topology is then updated and the server does not support sessions' do
@@ -156,19 +169,14 @@ describe Mongo::Operation::Update::OpMsg do
 
           before do
             session.instance_variable_set(:@options, { implicit: true })
-            # Topology is standalone, hence there is exactly one server
-            authorized_primary.monitor.stop!
           end
 
           it 'creates the correct OP_MSG message' do
             RSpec::Mocks.with_temporary_scope do
-              # Override description as it gets replaced on every connection
-              description = authorized_primary.description
-              allow(authorized_primary).to receive(:description).and_return(description)
-              allow(description.features).to receive(:sessions_enabled?).and_return(false)
+              expect(connection.features).to receive(:sessions_enabled?).and_return(false)
 
               expect(Mongo::Protocol::Msg).to receive(:new).with([], {}, expected_global_args, expected_payload_1)
-              op.send(:message, authorized_primary)
+              op.send(:message, connection)
             end
           end
         end
@@ -201,7 +209,7 @@ describe Mongo::Operation::Update::OpMsg do
             it 'does not send a session id in the command' do
               authorized_client.command(ping:1)
               expect(Mongo::Protocol::Msg).to receive(:new).with([:more_to_come], {}, expected_global_args, expected_payload_1)
-              op.send(:message, authorized_primary)
+              op.send(:message, connection)
             end
           end
 
@@ -218,7 +226,7 @@ describe Mongo::Operation::Update::OpMsg do
             it 'creates the correct OP_MSG message' do
               authorized_client.command(ping:1)
               expect(Mongo::Protocol::Msg).to receive(:new).with([:more_to_come], {}, expected_global_args, expected_payload_1)
-              op.send(:message, authorized_primary)
+              op.send(:message, connection)
             end
           end
         end
@@ -242,7 +250,7 @@ describe Mongo::Operation::Update::OpMsg do
             authorized_client.command(ping:1)
             RSpec::Mocks.with_temporary_scope do
               expect(Mongo::Protocol::Msg).to receive(:new).with([:more_to_come], {}, expected_global_args, expected_payload_1)
-              op.send(:message, authorized_primary)
+              op.send(:message, connection)
             end
           end
         end

data/spec/mongo/retryable_spec.rb

@@ -218,11 +218,13 @@ describe Mongo::Retryable do
 
           before do
             expect(retryable).to receive(:select_server).ordered
-            expect(operation).to receive(:execute).and_raise(error).ordered
+            expect(operation).to receive(:execute).and_raise(error.dup).ordered
 
             expect(client).to receive(:read_retry_interval).and_return(0.1).ordered
             expect(retryable).to receive(:select_server).ordered
-            expect(operation).to receive(:execute).and_raise(error).ordered
+            # Since exception is mutated when notes are added to it,
+            # we need to ensure each attempt starts with a pristine exception.
+            expect(operation).to receive(:execute).and_raise(error.dup).ordered
 
             expect(client).to receive(:read_retry_interval).and_return(0.1).ordered
             expect(retryable).to receive(:select_server).ordered
@@ -350,23 +352,13 @@ describe Mongo::Retryable do
       end
     end
 
-    context 'when a not master error occurs' do
-
-      before do
-        expect(operation).to receive(:execute).and_raise(
-          Mongo::Error::OperationFailure.new('not master')).ordered
-        expect(cluster).to receive(:scan!).and_return(true).ordered
-        expect(operation).to receive(:execute).and_return(true).ordered
+    context 'when an operation failure error occurs with a RetryableWriteError label' do
+      let(:error) do
+        Mongo::Error::OperationFailure.new(nil, nil, labels: ['RetryableWriteError'])
       end
 
-      it_behaves_like 'executes the operation twice'
-    end
-
-    context 'when a node is recovering error occurs' do
-
       before do
-        expect(operation).to receive(:execute).and_raise(
-          Mongo::Error::OperationFailure.new('node is recovering')).ordered
+        expect(operation).to receive(:execute).and_raise(error).ordered
         expect(cluster).to receive(:scan!).and_return(true).ordered
         expect(operation).to receive(:execute).and_return(true).ordered
       end
@@ -374,21 +366,7 @@ describe Mongo::Retryable do
       it_behaves_like 'executes the operation twice'
     end
 
-    context 'when a retryable error occurs with a code' do
-
-      before do
-        expect(operation).to receive(:execute).and_raise(
-          Mongo::Error::OperationFailure.new('message missing', nil,
-            :code => 91, :code_name => 'ShutdownInProgress')).ordered
-        expect(cluster).to receive(:scan!).and_return(true).ordered
-        expect(operation).to receive(:execute).and_return(true).ordered
-      end
-
-      it_behaves_like 'executes the operation twice'
-    end
-
-    context 'when a normal operation failure occurs' do
-
+    context 'when an operation failure error occurs without a RetryableWriteError label' do
       before do
         expect(operation).to receive(:execute).and_raise(Mongo::Error::OperationFailure).ordered
       end
@@ -400,11 +378,15 @@ describe Mongo::Retryable do
       end
     end
 
-    context 'when a socket error occurs' do
+    context 'when a socket error occurs with a RetryableWriteError label' do
+      let(:error) do
+        error = Mongo::Error::SocketError.new('socket error')
+        error.add_label('RetryableWriteError')
+        error
+      end
 
       before do
-        expect(operation).to receive(:execute).and_raise(
-          Mongo::Error::SocketError.new('socket error')).ordered
+        expect(operation).to receive(:execute).and_raise(error).ordered
       end
 
       it 'raises an exception' do
@@ -414,11 +396,15 @@ describe Mongo::Retryable do
       end
     end
 
-    context 'when a socket timeout occurs' do
+    context 'when a socket timeout error occurs with a RetryableWriteError label' do
+      let(:error) do
+        error = Mongo::Error::SocketTimeoutError.new('socket timeout error')
+        error.add_label('RetryableWriteError')
+        error
+      end
 
       before do
-        expect(operation).to receive(:execute).and_raise(
-          Mongo::Error::SocketTimeoutError.new('socket timeout')).ordered
+        expect(operation).to receive(:execute).and_raise(error).ordered
       end
 
       it 'raises an exception' do
@@ -441,7 +427,6 @@ describe Mongo::Retryable do
         }.to raise_error(Mongo::Error::UnsupportedCollation)
       end
     end
-
   end
 
   describe '#write_with_retry - modern' do
@@ -475,85 +460,101 @@ describe Mongo::Retryable do
       end
     end
 
-    context 'when a not master error occurs' do
+    context 'when an operation failure error occurs with a RetryableWriteError label' do
+      let(:error) do
+        Mongo::Error::OperationFailure.new(nil, nil, labels: ['RetryableWriteError'])
+      end
 
       before do
         server = cluster.next_primary
-        expect(operation).to receive(:execute).and_raise(
-          Mongo::Error::OperationFailure.new('not master')).ordered
+        expect(operation).to receive(:execute).and_raise(error).ordered
         expect(operation).to receive(:execute).and_return(true).ordered
       end
 
       it_behaves_like 'executes the operation twice'
     end
 
-    context 'when a node is recovering error occurs' do
-
+    context 'when an operation failure error occurs without a RetryableWriteError label' do
       before do
-        server = cluster.next_primary
-        expect(operation).to receive(:execute).and_raise(
-          Mongo::Error::OperationFailure.new('node is recovering')).ordered
-        expect(operation).to receive(:execute).and_return(true).ordered
+        expect(operation).to receive(:execute).and_raise(Mongo::Error::OperationFailure).ordered
       end
 
-      it_behaves_like 'executes the operation twice'
+      it 'raises an exception' do
+        expect {
+          retryable.write
+        }.to raise_error(Mongo::Error::OperationFailure)
+      end
     end
 
-    context 'when a retryable error occurs with a code' do
+    context 'when a socket error occurs with a RetryableWriteError label' do
+      let(:error) do
+        error = Mongo::Error::SocketError.new('socket error')
+        error.add_label('RetryableWriteError')
+        error
+      end
 
       before do
-        server = cluster.next_primary
-        expect(operation).to receive(:execute).and_raise(
-          Mongo::Error::OperationFailure.new('message missing', nil,
-            :code => 91, :code_name => 'ShutdownInProgress')).ordered
+        expect(operation).to receive(:execute).and_raise(error).ordered
+        # This is where the server would be marked unknown, but since
+        # we are not tracking which server the operation was sent to,
+        # we are not able to assert this.
+        # There is no explicit cluster scan requested.
         expect(operation).to receive(:execute).and_return(true).ordered
       end
 
       it_behaves_like 'executes the operation twice'
     end
 
-    context 'when a normal operation failure occurs' do
+    context 'when a socket error occurs without a RetryableWriteError label' do
+      let(:error) do
+        Mongo::Error::SocketError.new('socket error')
+      end
 
       before do
-        expect(operation).to receive(:execute).and_raise(Mongo::Error::OperationFailure).ordered
+        expect(operation).to receive(:execute).and_raise(error).ordered
       end
 
       it 'raises an exception' do
         expect {
           retryable.write
-        }.to raise_error(Mongo::Error::OperationFailure)
+        }.to raise_error(Mongo::Error::SocketError)
       end
     end
 
-    context 'when a socket error occurs' do
+    context 'when a socket timeout occurs with a RetryableWriteError label' do
+      let(:error) do
+        error = Mongo::Error::SocketTimeoutError.new('socket timeout error')
+        error.add_label('RetryableWriteError')
+        error
+      end
 
       before do
-        expect(operation).to receive(:execute).and_raise(
-          Mongo::Error::SocketError.new('socket error')).ordered
+        expect(operation).to receive(:execute).and_raise(error).ordered
         # This is where the server would be marked unknown, but since
         # we are not tracking which server the operation was sent to,
         # we are not able to assert this.
-        # There is no explicit cluster scan requested.
+        # There is no explicit cluster scan requested (and the operation may
+        # end up being sent to the same server it was sent to originally).
         expect(operation).to receive(:execute).and_return(true).ordered
       end
 
       it_behaves_like 'executes the operation twice'
     end
 
-    context 'when a socket timeout occurs' do
+    context 'when a socket timeout occurs without a RetryableWriteError label' do
+      let(:error) do
+        Mongo::Error::SocketTimeoutError.new('socket timeout error')
+      end
 
       before do
-        expect(operation).to receive(:execute).and_raise(
-          Mongo::Error::SocketTimeoutError.new('socket timeout')).ordered
-        # This is where the server would be marked unknown, but since
-        # we are not tracking which server the operation was sent to,
-        # we are not able to assert this.
-        # There is no explicit cluster scan requested (and the operation may
-        # end up being sent to the same server it was sent to originally).
-        expect(operation).to receive(:execute).and_return(true).ordered
+        expect(operation).to receive(:execute).and_raise(error).ordered
       end
 
-      it_behaves_like 'executes the operation twice'
+      it 'raises an exception' do
+        expect {
+          retryable.write
+        }.to raise_error(Mongo::Error::SocketTimeoutError)
+      end
     end
 
     context 'when a non-retryable exception occurs' do