mongo 2.20.1 → 2.21.0

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

@@ -2,8 +2,12 @@
 # rubocop:todo all
 
 require 'spec_helper'
+require_relative '../shared/csot/examples'
 
 describe Mongo::Operation::Insert::OpMsg do
+  include CSOT::Examples
+
+  let(:context) { Mongo::Operation::Context.new }
 
   let(:documents) { [{ :_id => 1, :foo => 1 }] }
   let(:session) { nil }
@@ -104,193 +108,186 @@ describe Mongo::Operation::Insert::OpMsg do
     # https://jira.mongodb.org/browse/RUBY-2224
     require_no_linting
 
-    context 'when the server supports OP_MSG' do
-      min_server_fcv '3.6'
+    let(:documents) do
+      [ { foo: 1 }, { bar: 2 }]
+    end
+
+    let(:global_args) do
+      {
+          insert: TEST_COLL,
+          ordered: true,
+          writeConcern: write_concern.options,
+          '$db' => SpecConfig.instance.test_db,
+          lsid: session.session_id
+      }
+    end
+
+    let!(:expected_payload_1) do
+      Mongo::Protocol::Msg::Section1.new('documents', op.documents)
+    end
 
-      let(:documents) do
-        [ { foo: 1 }, { bar: 2 }]
+    let(:session) do
+      Mongo::Session.new(nil, authorized_client, implicit: true).tap do |session|
+        allow(session).to receive(:session_id).and_return(42)
       end
+    end
 
-      let(:global_args) do
-        {
-            insert: TEST_COLL,
-            ordered: true,
-            writeConcern: write_concern.options,
-            '$db' => SpecConfig.instance.test_db,
-            lsid: session.session_id
-        }
+    context 'when the topology is replica set or sharded' do
+      require_topology :replica_set, :sharded
+
+      let(:expected_global_args) do
+        global_args.merge(Mongo::Operation::CLUSTER_TIME => authorized_client.cluster.cluster_time)
+      end
+
+      it 'creates the correct OP_MSG message' do
+        authorized_client.command(ping:1)
+        RSpec::Mocks.with_temporary_scope do
+          expect(Mongo::Protocol::Msg).to receive(:new).with([],
+                                                              {},
+                                                              expected_global_args,
+                                                              expected_payload_1)
+          op.send(:message, connection)
+        end
       end
+    end
+
+    context 'when the topology is standalone' do
+      require_topology :single
 
-      let!(:expected_payload_1) do
-        Mongo::Protocol::Msg::Section1.new('documents', op.documents)
+      let(:expected_global_args) do
+        global_args
       end
 
-      let(:session) do
-        Mongo::Session.new(nil, authorized_client, implicit: true).tap do |session|
-          allow(session).to receive(:session_id).and_return(42)
+      it 'creates the correct OP_MSG message' do
+        RSpec::Mocks.with_temporary_scope do
+          authorized_client.command(ping:1)
+          expect(Mongo::Protocol::Msg).to receive(:new).with([],
+                                                              {},
+                                                              expected_global_args,
+                                                              expected_payload_1)
+          op.send(:message, connection)
         end
       end
 
-      context 'when the topology is replica set or sharded' do
-        min_server_fcv '3.6'
-        require_topology :replica_set, :sharded
+      context 'when an implicit session is created and the topology is then updated and the server does not support sessions' do
+        # Mocks on features are incompatible with linting
+        require_no_linting
 
         let(:expected_global_args) do
-          global_args.merge(Mongo::Operation::CLUSTER_TIME => authorized_client.cluster.cluster_time)
+          global_args.dup.tap do |args|
+            args.delete(:lsid)
+          end
+        end
+
+        before do
+          session.implicit?.should be true
         end
 
         it 'creates the correct OP_MSG message' do
-          authorized_client.command(ping:1)
           RSpec::Mocks.with_temporary_scope do
+            expect(connection.features).to receive(:sessions_enabled?).and_return(false)
+
+            expect(expected_global_args).not_to have_key(:lsid)
             expect(Mongo::Protocol::Msg).to receive(:new).with([],
-                                                               {},
-                                                               expected_global_args,
-                                                               expected_payload_1)
+                                                                {},
+                                                                expected_global_args,
+                                                                expected_payload_1)
             op.send(:message, connection)
           end
         end
       end
+    end
 
-      context 'when the topology is standalone' do
-        min_server_fcv '3.6'
-        require_topology :single
+    context 'when the write concern is 0' do
 
-        let(:expected_global_args) do
-          global_args
-        end
+      let(:write_concern) do
+        Mongo::WriteConcern.get(w: 0)
+      end
 
-        it 'creates the correct OP_MSG message' do
-          RSpec::Mocks.with_temporary_scope do
-            authorized_client.command(ping:1)
-            expect(Mongo::Protocol::Msg).to receive(:new).with([],
-                                                               {},
-                                                               expected_global_args,
-                                                               expected_payload_1)
-            op.send(:message, connection)
+      context 'when the session is implicit' do
+
+        let(:session) do
+          Mongo::Session.new(nil, authorized_client, implicit: true).tap do |session|
+            allow(session).to receive(:session_id).and_return(42)
+            session.should be_implicit
           end
         end
 
-        context 'when an implicit session is created and the topology is then updated and the server does not support sessions' do
-          # Mocks on features are incompatible with linting
-          require_no_linting
+        context 'when the topology is replica set or sharded' do
+          require_topology :replica_set, :sharded
 
           let(:expected_global_args) do
             global_args.dup.tap do |args|
               args.delete(:lsid)
+              args.merge!(Mongo::Operation::CLUSTER_TIME => authorized_client.cluster.cluster_time)
             end
           end
 
-          before do
-            session.implicit?.should be true
-          end
-
-          it 'creates the correct OP_MSG message' do
+          it 'does not send a session id in the command' do
+            authorized_client.command(ping:1)
             RSpec::Mocks.with_temporary_scope do
-              expect(connection.features).to receive(:sessions_enabled?).and_return(false)
-
-              expect(expected_global_args).not_to have_key(:lsid)
-              expect(Mongo::Protocol::Msg).to receive(:new).with([],
-                                                                 {},
-                                                                 expected_global_args,
-                                                                 expected_payload_1)
+              expect(Mongo::Protocol::Msg).to receive(:new).with([:more_to_come],
+                                                                  {},
+                                                                  expected_global_args,
+                                                                  expected_payload_1)
               op.send(:message, connection)
             end
           end
         end
-      end
 
-      context 'when the write concern is 0' do
-
-        let(:write_concern) do
-          Mongo::WriteConcern.get(w: 0)
-        end
+        context 'when the topology is standalone' do
+          require_topology :single
 
-        context 'when the session is implicit' do
-
-          let(:session) do
-            Mongo::Session.new(nil, authorized_client, implicit: true).tap do |session|
-              allow(session).to receive(:session_id).and_return(42)
-              session.should be_implicit
-            end
-          end
-
-          context 'when the topology is replica set or sharded' do
-            min_server_fcv '3.6'
-            require_topology :replica_set, :sharded
-
-            let(:expected_global_args) do
-              global_args.dup.tap do |args|
-                args.delete(:lsid)
-                args.merge!(Mongo::Operation::CLUSTER_TIME => authorized_client.cluster.cluster_time)
-              end
-            end
-
-            it 'does not send a session id in the command' 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, connection)
-              end
+          let(:expected_global_args) do
+            global_args.dup.tap do |args|
+              args.delete(:lsid)
             end
           end
 
-          context 'when the topology is standalone' do
-            min_server_fcv '3.6'
-            require_topology :single
-
-            let(:expected_global_args) do
-              global_args.dup.tap do |args|
-                args.delete(:lsid)
-              end
-            end
-
-            it 'creates the correct OP_MSG message' 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, connection)
-              end
+          it 'creates the correct OP_MSG message' 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, connection)
             end
           end
         end
+      end
 
-        context 'when the session is explicit' do
-          min_server_fcv '3.6'
-          require_topology :replica_set, :sharded
+      context 'when the session is explicit' do
+        require_topology :replica_set, :sharded
 
-          let(:session) do
-            authorized_client.start_session
-          end
+        let(:session) do
+          authorized_client.start_session
+        end
 
-          before do
-            session.should_not be_implicit
-          end
+        before do
+          session.should_not be_implicit
+        end
 
-          let(:expected_global_args) do
-            global_args.dup.tap do |args|
-              args.delete(:lsid)
-              args.merge!(Mongo::Operation::CLUSTER_TIME => authorized_client.cluster.cluster_time)
-            end
+        let(:expected_global_args) do
+          global_args.dup.tap do |args|
+            args.delete(:lsid)
+            args.merge!(Mongo::Operation::CLUSTER_TIME => authorized_client.cluster.cluster_time)
           end
+        end
 
-          it 'does not send a session id in the command' 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, connection)
-            end
+        it 'does not send a session id in the command' 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, connection)
           end
         end
       end
     end
   end
+
+  it_behaves_like 'a CSOT-compliant OpMsg subclass'
 end

data/spec/mongo/operation/shared/csot/examples.rb

@@ -0,0 +1,113 @@
+# frozen_string_literal: true
+# rubocop:todo all
+
+module CSOT
+  module Examples
+    # expects the following values to be available:
+    #  `op` -- an instance of an OpMsgBase subclass
+    def self.included(example_context)
+      example_context.shared_examples 'mock CSOT environment' do
+        # Linting freaks out because of the doubles used in these specs.
+        require_no_linting
+
+        let(:message) { op.send(:message, connection) }
+
+        let(:body) { message.documents.first }
+
+        let(:cursor_type) { nil }
+        let(:timeout_mode) { nil }
+        let(:remaining_timeout_sec) { nil }
+        let(:minimum_round_trip_time) { 0 }
+        let(:view_options) { {} }
+        let(:max_await_time_ms) { nil }
+
+        let(:view) do
+          instance_double(Mongo::Collection::View).tap do |view|
+            allow(view).to receive(:cursor_type).and_return(cursor_type)
+            allow(view).to receive(:timeout_mode).and_return(timeout_mode)
+            allow(view).to receive(:options).and_return(view_options)
+            allow(view).to receive(:max_await_time_ms).and_return(max_await_time_ms)
+          end
+        end
+
+        let(:context) do
+          Mongo::Operation::Context.new(view: view).tap do |context|
+            allow(context).to receive(:remaining_timeout_sec).and_return(remaining_timeout_sec)
+            allow(context).to receive(:timeout?).and_return(!remaining_timeout_sec.nil?)
+          end
+        end
+
+        let(:server) do
+          instance_double(Mongo::Server).tap do |server|
+            allow(server).to receive(:minimum_round_trip_time).and_return(minimum_round_trip_time)
+          end
+        end
+
+        let(:address) { Mongo::Address.new('127.0.0.1') }
+
+        let(:description) do
+          Mongo::Server::Description.new(
+            address, { Mongo::Operation::Result::OK => 1 }
+          )
+        end
+
+        let(:features) do
+          Mongo::Server::Description::Features.new(
+            Mongo::Server::Description::Features::DRIVER_WIRE_VERSIONS,
+            address
+          )
+        end
+
+        let(:connection) do
+          instance_double(Mongo::Server::Connection).tap do |conn|
+            allow(conn).to receive(:server).and_return(server)
+            allow(conn).to receive(:description).and_return(description)
+            allow(conn).to receive(:features).and_return(features)
+          end
+        end
+
+        before do
+          # context is normally set when calling `execute` on the operation,
+          # but since we're not doing that, we have to tell the operation
+          # what the context is.
+          op.context = context
+        end
+      end
+
+      example_context.shared_examples 'a CSOT-compliant OpMsg subclass' do
+        include_examples 'mock CSOT environment'
+
+        context 'when no timeout_ms set' do
+          it 'does not set maxTimeMS' do
+            expect(body.key?(:maxTimeMS)).to be false
+          end
+        end
+
+        context 'when there is enough time to send the message' do
+          # Ten seconds remaining
+          let(:remaining_timeout_sec) { 10 }
+
+          # One second RTT
+          let(:minimum_round_trip_time) { 1 }
+
+          it 'sets the maxTimeMS' do
+            # Nine seconds
+            expect(body[:maxTimeMS]).to eq(9_000)
+          end
+        end
+
+        context 'when there is not enough time to send the message' do
+          # Ten seconds remaining
+          let(:remaining_timeout_sec) { 0.1 }
+
+          # One second RTT
+          let(:minimum_round_trip_time) { 1 }
+
+          it 'fails with an exception' do
+            expect { message }.to raise_error(Mongo::Error::TimeoutError)
+          end
+        end
+      end
+    end
+  end
+end