mongo 2.19.1 → 2.21.0

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/view/explainable_spec.rb

@@ -42,6 +42,7 @@ describe Mongo::Collection::View::Explainable do
             max_server_version '3.0'
 
             it 'executes the explain' do
+              skip 'https://jira.mongodb.org/browse/RUBY-3399'
               explain[:queryPlanner][:parsedQuery].should be_a(Hash)
             end
           end
@@ -50,6 +51,7 @@ describe Mongo::Collection::View::Explainable do
             min_server_fcv '3.2'
 
             it 'executes the explain' do
+              skip 'https://jira.mongodb.org/browse/RUBY-3399'
               explain[:queryPlanner][:mongosPlannerVersion].should == 1
             end
           end

data/spec/mongo/collection_crud_spec.rb

@@ -4,6 +4,7 @@
 require 'spec_helper'
 
 describe Mongo::Collection do
+  retry_test
 
   let(:subscriber) { Mrss::EventSubscriber.new }
 
@@ -2491,7 +2492,7 @@ describe Mongo::Collection do
       end
 
       let(:updated) do
-        authorized_collection.find.to_a.last
+        authorized_collection.find.sort(_id: 1).to_a.last
       end
 
       it 'reports that a document was written' do

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