mongo 2.20.2 → 2.21.0

data/spec/mongo/cursor_spec.rb

@@ -8,6 +8,10 @@ describe Mongo::Cursor do
     authorized_client['cursor_spec_collection']
   end
 
+  let(:context) do
+    Mongo::Operation::Context.new(client: authorized_client)
+  end
+
   before do
     authorized_collection.drop
   end
@@ -18,7 +22,7 @@ describe Mongo::Cursor do
     end
 
     let(:reply) do
-      view.send(:send_initial_query, server)
+      view.send(:send_initial_query, server, context)
     end
 
     let(:cursor) do
@@ -118,7 +122,7 @@ describe Mongo::Cursor do
     end
 
     let(:reply) do
-      view.send(:send_initial_query, server)
+      view.send(:send_initial_query, server, context)
     end
 
     let(:cursor) do
@@ -170,7 +174,11 @@ describe Mongo::Cursor do
 
           before do
             expect(cursor).to receive(:get_more_operation).and_return(op).ordered
-            expect(op).to receive(:execute).and_raise(Mongo::Error::SocketError).ordered
+            if SpecConfig.instance.connect_options[:connect] == :load_balanced
+              expect(op).to receive(:execute_with_connection).and_raise(Mongo::Error::SocketError).ordered
+            else
+              expect(op).to receive(:execute).and_raise(Mongo::Error::SocketError).ordered
+            end
           end
 
           it 'raises the error' do
@@ -617,6 +625,9 @@ describe Mongo::Cursor do
         allow(reply).to receive(:connection_description).and_return(conn_desc)
         allow(reply).to receive(:cursor_id).and_return(42)
         allow(reply).to receive(:connection_global_id).and_return(1)
+        if SpecConfig.instance.connect_options[:connect] == :load_balanced
+          allow(reply).to receive(:connection).and_return(nil)
+        end
       end
     end
 
@@ -645,7 +656,7 @@ describe Mongo::Cursor do
     end
 
     let(:reply) do
-      view.send(:send_initial_query, authorized_primary)
+      view.send(:send_initial_query, authorized_primary, context)
     end
 
     let(:cursor) do
@@ -721,7 +732,7 @@ describe Mongo::Cursor do
     end
 
     let(:reply) do
-      view.send(:send_initial_query, server)
+      view.send(:send_initial_query, server, context)
     end
 
     let(:cursor) do
@@ -770,10 +781,16 @@ describe Mongo::Cursor do
 
       it 'does not raise an error' do
         cursor
-        server.with_connection do |conn|
-          expect(conn).to receive(:deliver)
-            .at_least(:once)
-            .and_raise(Mongo::Error::SocketError, "test error")
+        if SpecConfig.instance.connect_options[:connect] == :load_balanced
+          expect(cursor.connection).to receive(:deliver)
+              .at_least(:once)
+              .and_raise(Mongo::Error::SocketError, "test error")
+        else
+          server.with_connection do |conn|
+            expect(conn).to receive(:deliver)
+              .at_least(:once)
+              .and_raise(Mongo::Error::SocketError, "test error")
+          end
         end
         expect do
           cursor.close

data/spec/mongo/error/operation_failure_heavy_spec.rb

@@ -39,7 +39,7 @@ describe Mongo::Error::OperationFailure do
 
       begin
         authorized_client['foo'].insert_one(test: 1)
-      rescue Mongo::Error::OperationFailure => exc
+      rescue Mongo::Error::OperationFailure::Family => exc
         expect(exc.details).to eq(exc.document['writeConcernError']['errInfo'])
         expect(exc.server_message).to eq(exc.document['writeConcernError']['errmsg'])
         expect(exc.code).to eq(exc.document['writeConcernError']['code'])
@@ -90,7 +90,7 @@ describe Mongo::Error::OperationFailure do
       it 'succeeds and prints the error' do
         begin
           collection.insert_one({x: 1})
-        rescue Mongo::Error::OperationFailure => e
+        rescue Mongo::Error::OperationFailure::Family => e
           insert_events = subscriber.succeeded_events.select { |e| e.command_name == "insert" }
           expect(insert_events.length).to eq 1
           expect(e.message).to match(/\[#{e.code}(:.*)?\].+ -- .+/)

data/spec/mongo/operation/context_spec.rb

@@ -0,0 +1,79 @@
+# frozen_string_literal: true
+
+require 'lite_spec_helper'
+
+describe Mongo::Operation::Context do
+  describe '#initialize' do
+    context 'when timeout_ms is negative' do
+      it 'raises an error' do
+        expect do
+          described_class.new(operation_timeouts: { operation_timeout_ms: -1 })
+        end.to raise_error ArgumentError, /must be a non-negative integer/
+      end
+    end
+  end
+
+  describe '#deadline' do
+    let(:context) { described_class.new(operation_timeouts: { operation_timeout_ms: timeout_ms }) }
+
+    context 'when timeout_ms is nil' do
+      let(:timeout_ms) { nil }
+
+      it 'returns nil' do
+        expect(context.deadline).to be_nil
+      end
+    end
+
+    context 'when timeout_ms is zero' do
+      let(:timeout_ms) { 0 }
+
+      it 'returns nil' do
+        expect(context.deadline).to eq(0)
+      end
+    end
+
+    context 'when timeout_ms is positive' do
+      before do
+        allow(Mongo::Utils).to receive(:monotonic_time).and_return(100.0)
+      end
+
+      let(:timeout_ms) { 10_000 }
+
+      it 'calculates the deadline' do
+        expect(context.deadline).to eq(110)
+      end
+    end
+  end
+
+  describe '#remaining_timeout_ms' do
+    let(:context) { described_class.new(operation_timeouts: { operation_timeout_ms: timeout_ms }) }
+
+    context 'when timeout_ms is nil' do
+      let(:timeout_ms) { nil }
+
+      it 'returns nil' do
+        expect(context.remaining_timeout_ms).to be_nil
+      end
+    end
+
+    context 'when timeout_ms is zero' do
+      let(:timeout_ms) { 0 }
+
+      it 'returns nil' do
+        expect(context.remaining_timeout_ms).to be_nil
+      end
+    end
+
+    context 'when timeout_ms is positive' do
+      before do
+        allow(Mongo::Utils).to receive(:monotonic_time).and_return(100.0, 105.0)
+      end
+
+      let(:timeout_ms) { 10_000 }
+
+      it 'calculates the remaining time' do
+        expect(context.remaining_timeout_ms).to eq(5_000)
+      end
+    end
+  end
+end

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

@@ -2,8 +2,12 @@
 # rubocop:todo all
 
 require 'spec_helper'
+require_relative '../shared/csot/examples'
 
 describe Mongo::Operation::Create::OpMsg do
+  include CSOT::Examples
+
+  let(:context) { Mongo::Operation::Context.new }
 
   let(:write_concern) do
     Mongo::WriteConcern.get(w: :majority)
@@ -73,8 +77,6 @@ describe Mongo::Operation::Create::OpMsg do
   end
 
   describe '#selector' do
-    min_server_fcv '3.6'
-
     it 'does not mutate user input' do
       user_input = IceNine.deep_freeze(spec.dup)
       expect do
@@ -87,158 +89,152 @@ describe Mongo::Operation::Create::OpMsg do
     # https://jira.mongodb.org/browse/RUBY-2224
     require_no_linting
 
-    context 'when the server supports OP_MSG' do
+    let(:global_args) do
+      {
+          create: TEST_COLL,
+          writeConcern: write_concern.options,
+          '$db' => SpecConfig.instance.test_db,
+          lsid: session.session_id
+      }
+    end
+
+    let(:session) do
+      authorized_client.start_session
+    end
 
-      let(:global_args) do
-        {
-            create: TEST_COLL,
-            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
 
-      let(:session) do
-        authorized_client.start_session
+      it 'creates the correct OP_MSG message' do
+        authorized_client.command(ping:1)
+        expect(Mongo::Protocol::Msg).to receive(:new).with([], {}, expected_global_args)
+        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 the topology is standalone' do
+      require_topology :single
 
-        let(:expected_global_args) do
-          global_args.merge(Mongo::Operation::CLUSTER_TIME => authorized_client.cluster.cluster_time)
-        end
+      let(:expected_global_args) do
+        global_args
+      end
 
-        it 'creates the correct OP_MSG message' do
-          authorized_client.command(ping:1)
-          expect(Mongo::Protocol::Msg).to receive(:new).with([], {}, expected_global_args)
-          op.send(:message, connection)
-        end
+      it 'creates the correct OP_MSG message' do
+        authorized_client.command(ping:1)
+        expect(Mongo::Protocol::Msg).to receive(:new).with([], {}, expected_global_args)
+        op.send(:message, connection)
       end
 
-      context 'when the topology is standalone' do
-        min_server_fcv '3.6'
-        require_topology :single
+      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
-        end
-
-        it 'creates the correct OP_MSG message' do
-          authorized_client.command(ping:1)
-          expect(Mongo::Protocol::Msg).to receive(:new).with([], {}, expected_global_args)
-          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
-          # Mocks on features are incompatible with linting
-          require_no_linting
-
-          let(:expected_global_args) do
-            global_args.dup.tap do |args|
-              args.delete(:lsid)
-            end
+          global_args.dup.tap do |args|
+            args.delete(:lsid)
           end
+        end
 
-          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
+        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
 
-          it 'creates the correct OP_MSG message' do
-            RSpec::Mocks.with_temporary_scope do
-              expect(connection.features).to receive(:sessions_enabled?).and_return(false)
+        it 'creates the correct OP_MSG message' do
+          RSpec::Mocks.with_temporary_scope do
+            expect(connection.features).to receive(:sessions_enabled?).and_return(false)
 
-              expect(expected_global_args[:session]).to be nil
-              expect(Mongo::Protocol::Msg).to receive(:new).with([], {}, expected_global_args)
-              op.send(:message, connection)
-            end
+            expect(expected_global_args[:session]).to be nil
+            expect(Mongo::Protocol::Msg).to receive(:new).with([], {}, expected_global_args)
+            op.send(:message, connection)
           end
         end
       end
+    end
 
-      context 'when the write concern is 0' do
+    context 'when the write concern is 0' do
 
-        let(:write_concern) do
-          Mongo::WriteConcern.get(w: 0)
-        end
+      let(:write_concern) do
+        Mongo::WriteConcern.get(w: 0)
+      end
 
-        context 'when the session is implicit' do
+      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
+        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
+        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
+          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)
-              expect(Mongo::Protocol::Msg).to receive(:new).with([:more_to_come], {}, expected_global_args)
-              op.send(:message, connection)
-            end
+          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)
+            op.send(:message, connection)
           end
+        end
 
-          context 'when the topology is standalone' do
-            min_server_fcv '3.6'
-            require_topology :single
+        context 'when the topology is standalone' do
+          require_topology :single
 
-            let(:expected_global_args) do
-              global_args.dup.tap do |args|
-                args.delete(:lsid)
-              end
+          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)
-              expect(Mongo::Protocol::Msg).to receive(:new).with([:more_to_come], {}, expected_global_args)
-              op.send(:message, connection)
-            end
+          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)
+            op.send(:message, connection)
           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)
-              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)
+            op.send(:message, connection)
           end
         end
       end
     end
   end
+
+  it_behaves_like 'a CSOT-compliant OpMsg subclass'
 end

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

@@ -2,8 +2,12 @@
 # rubocop:todo all
 
 require 'spec_helper'
+require_relative '../shared/csot/examples'
 
 describe Mongo::Operation::Delete::OpMsg do
+  include CSOT::Examples
+
+  let(:context) { Mongo::Operation::Context.new }
 
   let(:write_concern) do
     Mongo::WriteConcern.get(w: :majority)
@@ -125,7 +129,6 @@ describe Mongo::Operation::Delete::OpMsg do
       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
@@ -140,7 +143,6 @@ describe Mongo::Operation::Delete::OpMsg do
       end
 
       context 'when the topology is standalone' do
-        min_server_fcv '3.6'
         require_topology :single
 
         let(:expected_global_args) do
@@ -198,7 +200,6 @@ describe Mongo::Operation::Delete::OpMsg do
           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
@@ -216,7 +217,6 @@ describe Mongo::Operation::Delete::OpMsg do
           end
 
           context 'when the topology is standalone' do
-            min_server_fcv '3.6'
             require_topology :single
 
             let(:expected_global_args) do
@@ -234,7 +234,6 @@ describe Mongo::Operation::Delete::OpMsg do
         end
 
         context 'when the session is explicit' do
-          min_server_fcv '3.6'
           require_topology :replica_set, :sharded
 
           let(:session) do
@@ -263,4 +262,6 @@ describe Mongo::Operation::Delete::OpMsg do
       end
     end
   end
+
+  it_behaves_like 'a CSOT-compliant OpMsg subclass'
 end

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

@@ -0,0 +1,66 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+require_relative '../shared/csot/examples'
+
+describe Mongo::Operation::Find::OpMsg do
+  include CSOT::Examples
+
+  let(:spec) do
+    { coll_name: 'coll_name',
+      filter: {},
+      db_name: 'db_name' }
+  end
+
+  let(:op) { described_class.new(spec) }
+
+  context 'when it is a CSOT-compliant OpMsg' 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 timeout_ms is set' do
+      let(:remaining_timeout_sec) { 3 }
+
+      context 'when cursor is non-tailable' do
+        let(:cursor_type) { nil }
+
+        context 'when timeout_mode is cursor_lifetime' do
+          let(:timeout_mode) { :cursor_lifetime }
+
+          it 'sets maxTimeMS' do
+            expect(body[:maxTimeMS]).to be == 3_000
+          end
+        end
+
+        context 'when timeout_mode is iteration' do
+          let(:timeout_mode) { :iteration }
+
+          it 'omits maxTimeMS' do
+            expect(body[:maxTimeMS]).to be_nil
+          end
+        end
+      end
+
+      context 'when cursor is tailable' do
+        let(:cursor_type) { :tailable }
+
+        it 'omits maxTimeMS' do
+          expect(body[:maxTimeMS]).to be_nil
+        end
+      end
+
+      context 'when cursor is tailable_await' do
+        let(:cursor_type) { :tailable_await }
+
+        it 'sets maxTimeMS' do
+          expect(body[:maxTimeMS]).to be == 3_000
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,65 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+require_relative '../shared/csot/examples'
+
+describe Mongo::Operation::GetMore::OpMsg do
+  include CSOT::Examples
+
+  let(:spec) do
+    {
+      options: {},
+      db_name: 'db_name',
+      coll_name: 'coll_name',
+      cursor_id: 1_234_567_890,
+    }
+  end
+
+  let(:op) { described_class.new(spec) }
+
+  context 'when it is a CSOT-compliant OpMsg' 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 timeout_ms is set' do
+      let(:remaining_timeout_sec) { 3 }
+
+      context 'when cursor is non-tailable' do
+        it 'omits maxTimeMS' do
+          expect(body[:maxTimeMS]).to be_nil
+        end
+      end
+
+      context 'when cursor is tailable' do
+        let(:cursor_type) { :tailable }
+
+        it 'omits maxTimeMS' do
+          expect(body[:maxTimeMS]).to be_nil
+        end
+      end
+
+      context 'when cursor is tailable_await' do
+        let(:cursor_type) { :tailable_await }
+
+        context 'when max_await_time_ms is omitted' do
+          it 'omits maxTimeMS' do
+            expect(body[:maxTimeMS]).to be_nil
+          end
+        end
+
+        context 'when max_await_time_ms is given' do
+          let(:max_await_time_ms) { 1_234 }
+
+          it 'sets maxTimeMS' do
+            expect(body[:maxTimeMS]).to be == 1_234
+          end
+        end
+      end
+    end
+  end
+end