mongo 2.20.1 → 2.21.0

data/spec/mongo/client_spec.rb

@@ -561,6 +561,75 @@ describe Mongo::Client do
         expect(command['comment']).to eq('comment')
       end
     end
+
+    context 'with timeout_ms' do
+      # To make it easier with failCommand
+      require_topology :single
+      min_server_version '4.4'
+
+      before do
+        root_authorized_client.use('admin').command({
+          configureFailPoint: "failCommand",
+          mode: "alwaysOn",
+          data: {
+              failCommands: ["listDatabases"],
+              blockConnection: true,
+              blockTimeMS: 100
+            }
+        })
+      end
+
+      after do
+        root_authorized_client.use('admin').command({
+          configureFailPoint: "failCommand",
+          mode: "off"
+        })
+      end
+
+      context 'when timeout_ms is set on command level' do
+        context 'when there is not enough time' do
+          it 'raises' do
+            expect do
+              monitored_client.database_names({}, timeout_ms: 50)
+            end.to raise_error(Mongo::Error::TimeoutError)
+          end
+        end
+
+        context 'when there is enough time' do
+          it 'does not raise' do
+            expect do
+              monitored_client.database_names({}, timeout_ms: 200)
+            end.not_to raise_error
+          end
+        end
+      end
+
+      context 'when timeout_ms is set on client level' do
+        context 'when there is not enough time' do
+          let(:client) do
+            root_authorized_client.with(timeout_ms: 50)
+          end
+
+          it 'raises' do
+            expect do
+              client.database_names({})
+            end.to raise_error(Mongo::Error::TimeoutError)
+          end
+        end
+
+        context 'when there is enough time' do
+          let(:client) do
+            root_authorized_client.with(timeout_ms: 200)
+          end
+
+          it 'does not raise' do
+            expect do
+              monitored_client.database_names({})
+            end.not_to raise_error
+          end
+        end
+      end
+    end
   end
 
   describe '#list_databases' do
@@ -572,8 +641,6 @@ describe Mongo::Client do
     end
 
     context 'when filter criteria is present' do
-      min_server_fcv '3.6'
-
       include_context 'ensure test db exists'
 
       let(:result) do
@@ -591,8 +658,6 @@ describe Mongo::Client do
     end
 
     context 'when name_only is true' do
-      min_server_fcv '3.6'
-
       let(:command) do
         Utils.get_command_event(root_authorized_client, 'listDatabases') do |client|
           client.list_databases({}, true)
@@ -667,6 +732,75 @@ describe Mongo::Client do
         expect(command['comment']).to eq('comment')
       end
     end
+
+    context 'with timeout_ms' do
+      # To make it easier with failCommand
+      require_topology :single
+      min_server_version '4.4'
+
+      before do
+        root_authorized_client.use('admin').command({
+          configureFailPoint: "failCommand",
+          mode: "alwaysOn",
+          data: {
+              failCommands: ["listDatabases"],
+              blockConnection: true,
+              blockTimeMS: 100
+            }
+        })
+      end
+
+      after do
+        root_authorized_client.use('admin').command({
+          configureFailPoint: "failCommand",
+          mode: "off"
+        })
+      end
+
+      context 'when timeout_ms is set on command level' do
+        context 'when there is not enough time' do
+          it 'raises' do
+            expect do
+              monitored_client.list_databases({}, false, timeout_ms: 50)
+            end.to raise_error(Mongo::Error::TimeoutError)
+          end
+        end
+
+        context 'when there is enough time' do
+          it 'does not raise' do
+            expect do
+              monitored_client.list_databases({}, false, timeout_ms: 200)
+            end.not_to raise_error
+          end
+        end
+      end
+
+      context 'when timeout_ms is set on client level' do
+        context 'when there is not enough time' do
+          let(:client) do
+            root_authorized_client.with(timeout_ms: 50)
+          end
+
+          it 'raises' do
+            expect do
+              client.list_databases({})
+            end.to raise_error(Mongo::Error::TimeoutError)
+          end
+        end
+
+        context 'when there is enough time' do
+          let(:client) do
+            root_authorized_client.with(timeout_ms: 200)
+          end
+
+          it 'does not raise' do
+            expect do
+              monitored_client.list_databases({})
+            end.not_to raise_error
+          end
+        end
+      end
+    end
   end
 
   describe '#list_mongo_databases' do
@@ -1156,6 +1290,26 @@ describe Mongo::Client do
         }.to raise_exception(Mongo::Error::InvalidSession)
       end
     end
+
+    context 'when CSOT is set on the client' do
+      require_topology :replica_set
+
+      let(:timeout_ms) { 10 }
+
+      let(:timeout_sec) { timeout_ms / 1_000.0 }
+
+      let(:client) do
+        authorized_client.with(timeout_ms: timeout_ms)
+      end
+
+      it 'uses CSOT timeout set on the client' do
+        expect_any_instance_of(Mongo::ServerSelector::PrimaryPreferred).to(
+          receive(:select_server).with(anything, {timeout: timeout_sec}).and_call_original
+        )
+
+        client.start_session
+      end
+    end
   end
 
   describe '#summary' do

data/spec/mongo/collection/view/aggregation_spec.rb

@@ -156,8 +156,6 @@ describe Mongo::Collection::View::Aggregation do
     end
 
     context 'when the initial response has no results but an active cursor' do
-      min_server_fcv '3.2'
-
       let(:documents) do
         [
             { city: 'a'*6000000 },
@@ -166,7 +164,7 @@ describe Mongo::Collection::View::Aggregation do
       end
 
       let(:options) do
-        { :use_cursor => true }
+        {}
       end
 
       let(:pipeline) do
@@ -486,48 +484,25 @@ describe Mongo::Collection::View::Aggregation do
       end
     end
 
-    context 'when use_cursor is set' do
-
-      context 'when use_cursor is true' do
-
-        context 'when batch_size is set' do
-
-          let(:options) do
-            { :use_cursor => true,
-              :batch_size => 10
-            }
-          end
-
-          it 'sets a batch size document in the spec' do
-            expect(aggregation_spec[:selector][:cursor][:batchSize]).to eq(options[:batch_size])
-          end
-        end
-
-        context 'when batch_size is not set' do
-
-          let(:options) do
-            { :use_cursor => true }
-          end
+    context 'when batch_size is set' do
 
-          it 'sets an empty document in the spec' do
-            expect(aggregation_spec[:selector][:cursor]).to eq({})
-          end
-        end
+      let(:options) do
+        { :batch_size => 10 }
+      end
 
+      it 'sets a batch size document in the spec' do
+        expect(aggregation_spec[:selector][:cursor][:batchSize]).to eq(options[:batch_size])
       end
+    end
 
-      context 'when use_cursor is false' do
+    context 'when batch_size is not set' do
 
-        let(:options) do
-          { :use_cursor => false }
-        end
-
-        context 'when batch_size is set' do
+      let(:options) do
+        {}
+      end
 
-          it 'does not set the cursor option in the spec' do
-            expect(aggregation_spec[:selector][:cursor]).to be_nil
-          end
-        end
+      it 'sets an empty document in the spec' do
+        expect(aggregation_spec[:selector][:cursor]).to eq({})
       end
     end
   end

data/spec/mongo/collection/view/change_stream_spec.rb

@@ -507,7 +507,7 @@ describe Mongo::Collection::View::ChangeStream do
       end
 
       it 'includes the max_await_time value in the formatted string' do
-        expect(change_stream.inspect).to include({ max_await_time_ms: 10 }.to_s)
+        expect(change_stream.inspect).to include({ 'max_await_time_ms' => 10 }.to_s)
       end
     end
 
@@ -518,7 +518,7 @@ describe Mongo::Collection::View::ChangeStream do
       end
 
       it 'includes the batch_size value in the formatted string' do
-        expect(change_stream.inspect).to include({ batch_size: 5 }.to_s)
+        expect(change_stream.inspect).to include({ 'batch_size' => 5 }.to_s)
       end
     end
 
@@ -529,7 +529,7 @@ describe Mongo::Collection::View::ChangeStream do
       end
 
       it 'includes the collation value in the formatted string' do
-        expect(change_stream.inspect).to include({ 'collation' => { locale: 'en_US', strength: 2 } }.to_s)
+        expect(change_stream.inspect).to include({ 'collation' => { 'locale' => 'en_US', 'strength' => 2 } }.to_s)
       end
     end
 

data/spec/mongo/collection_spec.rb

@@ -828,13 +828,12 @@ describe Mongo::Collection do
 
         let(:enum) { change_stream.to_enum }
 
+        let(:get_more) { subscriber.started_events.detect { |e| e.command['getMore'] }.command }
+
         it 'sets the option correctly' do
-          expect(change_stream.instance_variable_get(:@cursor)).to receive(:get_more_operation).once.and_wrap_original do |m, *args, &block|
-            m.call(*args).tap do |op|
-              expect(op.max_time_ms).to eq(3000)
-            end
-          end
-          enum.next
+          enum.try_next
+          expect(get_more).not_to be_nil
+          expect(get_more['maxTimeMS']).to be == 3000
         end
 
         it "waits the appropriate amount of time" do

data/spec/mongo/crypt/auto_encrypter_spec.rb

@@ -58,6 +58,8 @@ describe Mongo::Crypt::AutoEncrypter do
     )
   end
 
+  let(:operation_context) { Mongo::Operation::Context.new }
+
   shared_context 'with jsonSchema validator' do
     before do
       users_collection = client.use(db_name)[collection_name]
@@ -81,14 +83,14 @@ describe Mongo::Crypt::AutoEncrypter do
   shared_examples 'a functioning auto encrypter' do
     describe '#encrypt' do
       it 'replaces the ssn field with a BSON::Binary' do
-        result = auto_encrypter.encrypt(db_name, command)
+        result = auto_encrypter.encrypt(db_name, command, operation_context)
         expect(result).to eq(encrypted_command)
       end
     end
 
     describe '#decrypt' do
       it 'returns the unencrypted document' do
-        result = auto_encrypter.decrypt(encrypted_command)
+        result = auto_encrypter.decrypt(encrypted_command, operation_context)
         expect(result).to eq(command)
       end
     end
@@ -329,14 +331,14 @@ describe Mongo::Crypt::AutoEncrypter do
 
       describe '#encrypt' do
         it 'does not perform encryption' do
-          result = auto_encrypter.encrypt(db_name, command)
+          result = auto_encrypter.encrypt(db_name, command, operation_context)
           expect(result).to eq(command)
         end
       end
 
       describe '#decrypt' do
         it 'still performs decryption' do
-          result = auto_encrypter.decrypt(encrypted_command)
+          result = auto_encrypter.decrypt(encrypted_command, operation_context)
           expect(result).to eq(command)
         end
       end
@@ -347,14 +349,14 @@ describe Mongo::Crypt::AutoEncrypter do
 
       describe '#encrypt' do
         it 'does not perform encryption' do
-          result = auto_encrypter.encrypt(db_name, command)
+          result = auto_encrypter.encrypt(db_name, command, operation_context)
           expect(result).to eq(command)
         end
       end
 
       describe '#decrypt' do
         it 'still performs decryption' do
-          result = auto_encrypter.decrypt(encrypted_command)
+          result = auto_encrypter.decrypt(encrypted_command, operation_context)
           expect(result).to eq(command)
         end
       end
@@ -365,14 +367,14 @@ describe Mongo::Crypt::AutoEncrypter do
 
       describe '#encrypt' do
         it 'does not perform encryption' do
-          result = auto_encrypter.encrypt(db_name, command)
+          result = auto_encrypter.encrypt(db_name, command, operation_context)
           expect(result).to eq(command)
         end
       end
 
       describe '#decrypt' do
         it 'still performs decryption' do
-          result = auto_encrypter.decrypt(encrypted_command)
+          result = auto_encrypter.decrypt(encrypted_command, operation_context)
           expect(result).to eq(command)
         end
       end
@@ -383,14 +385,14 @@ describe Mongo::Crypt::AutoEncrypter do
 
       describe '#encrypt' do
         it 'does not perform encryption' do
-          result = auto_encrypter.encrypt(db_name, command)
+          result = auto_encrypter.encrypt(db_name, command, operation_context)
           expect(result).to eq(command)
         end
       end
 
       describe '#decrypt' do
         it 'still performs decryption' do
-          result = auto_encrypter.decrypt(encrypted_command)
+          result = auto_encrypter.decrypt(encrypted_command, operation_context)
           expect(result).to eq(command)
         end
       end
@@ -401,14 +403,14 @@ describe Mongo::Crypt::AutoEncrypter do
 
       describe '#encrypt' do
         it 'does not perform encryption' do
-          result = auto_encrypter.encrypt(db_name, command)
+          result = auto_encrypter.encrypt(db_name, command, operation_context)
           expect(result).to eq(command)
         end
       end
 
       describe '#decrypt' do
         it 'still performs decryption' do
-          result = auto_encrypter.decrypt(encrypted_command)
+          result = auto_encrypter.decrypt(encrypted_command, operation_context)
           expect(result).to eq(command)
         end
       end

data/spec/mongo/crypt/data_key_context_spec.rb

@@ -136,8 +136,10 @@ describe Mongo::Crypt::DataKeyContext do
         )
       end
 
+      let(:operation_context) { Mongo::Operation::Context.new }
+
       it 'creates a data key' do
-        expect(context.run_state_machine).to be_a_kind_of(Hash)
+        expect(context.run_state_machine(operation_context)).to be_a_kind_of(Hash)
       end
     end
   end

data/spec/mongo/crypt/explicit_encryption_context_spec.rb

@@ -139,7 +139,7 @@ describe Mongo::Crypt::ExplicitEncryptionContext do
               value,
               options.merge(query_type: "equality")
             )
-          end.to raise_error(ArgumentError, /query_type is allowed only for "Indexed" or "RangePreview" algorithm/)
+          end.to raise_error(ArgumentError, /query_type is allowed only for "Indexed" or "Range" algorithm/)
         end
       end
 
@@ -154,7 +154,7 @@ describe Mongo::Crypt::ExplicitEncryptionContext do
               value,
               options.merge(contention_factor: 10)
             )
-          end.to raise_error(ArgumentError, /contention_factor is allowed only for "Indexed" or "RangePreview" algorithm/)
+          end.to raise_error(ArgumentError, /contention_factor is allowed only for "Indexed" or "Range" algorithm/)
         end
       end
 

data/spec/mongo/crypt/handle_spec.rb

@@ -188,7 +188,7 @@ describe Mongo::Crypt::Handle do
         end
 
         it 'raises an exception' do
-          expect { handle }.to raise_error(Mongo::Error::CryptError, 'local key must be 96 bytes (libmongocrypt error code 1)')
+          expect { handle }.to raise_error(Mongo::Error::CryptError, /local key must be 96 bytes \(libmongocrypt error code 1\)/)
         end
       end
 

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