mongo 2.20.0 → 2.21.0

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