mongo 2.19.3 → 2.20.1

data/spec/integration/retryable_reads_errors_spec.rb

@@ -4,6 +4,7 @@
 require 'spec_helper'
 
 describe 'Retryable reads errors tests' do
+  retry_test
 
   let(:client) { authorized_client.with(options.merge(retry_reads: true)) }
 
@@ -20,14 +21,14 @@ describe 'Retryable reads errors tests' do
 
     let(:failpoint) do
       {
-          configureFailPoint: "failCommand",
-          mode: { times: 1 },
-          data: {
-              failCommands: [ "find" ],
-              errorCode: 91,
-              blockConnection: true,
-              blockTimeMS: 1000
-          }
+        configureFailPoint: "failCommand",
+        mode: { times: 1 },
+        data: {
+          failCommands: [ "find" ],
+          errorCode: 91,
+          blockConnection: true,
+          blockTimeMS: 1000
+        }
       }
     end
 
@@ -73,31 +74,42 @@ describe 'Retryable reads errors tests' do
       client.subscribe(Mongo::Monitoring::CONNECTION_POOL, subscriber)
     end
 
-    it "retries on PoolClearedError" do
-      # After the first find fails, the pool is paused and retry is triggered.
-      # Now, a race is started between the second find acquiring a connection,
-      # and the first retrying the read. Now, retry reads cause the cluster to
-      # be rescanned and the pool to be unpaused, allowing the second checkout
-      # to succeed (when it should fail). Therefore we want the second find's
-      # check out to win the race. This gives the check out a little head start.
-      allow_any_instance_of(Mongo::Server::ConnectionPool).to receive(:ready).and_wrap_original do |m, *args, &block|
-        ::Utils.wait_for_condition(5) do
-          # check_out_results should contain:
-          # - find1 connection check out successful
-          # - pool cleared
-          # - find2 connection check out failed
-          # We wait here for the third event to happen before we ready the pool.
-          cmap_events.select do |e|
-            event_types.include?(e.class)
-          end.length >= 3
+    shared_examples_for 'retries on PoolClearedError' do
+      it "retries on PoolClearedError" do
+        # After the first find fails, the pool is paused and retry is triggered.
+        # Now, a race is started between the second find acquiring a connection,
+        # and the first retrying the read. Now, retry reads cause the cluster to
+        # be rescanned and the pool to be unpaused, allowing the second checkout
+        # to succeed (when it should fail). Therefore we want the second find's
+        # check out to win the race. This gives the check out a little head start.
+        allow_any_instance_of(Mongo::Server::ConnectionPool).to receive(:ready).and_wrap_original do |m, *args, &block|
+          ::Utils.wait_for_condition(5) do
+            # check_out_results should contain:
+            # - find1 connection check out successful
+            # - pool cleared
+            # - find2 connection check out failed
+            # We wait here for the third event to happen before we ready the pool.
+            cmap_events.select do |e|
+              event_types.include?(e.class)
+            end.length >= 3
+          end
+          m.call(*args, &block)
         end
-        m.call(*args, &block)
+        threads.map(&:join)
+        expect(check_out_results[0]).to be_a(Mongo::Monitoring::Event::Cmap::ConnectionCheckedOut)
+        expect(check_out_results[1]).to be_a(Mongo::Monitoring::Event::Cmap::PoolCleared)
+        expect(check_out_results[2]).to be_a(Mongo::Monitoring::Event::Cmap::ConnectionCheckOutFailed)
+        expect(find_events.length).to eq(3)
       end
-      threads.map(&:join)
-      expect(check_out_results[0]).to be_a(Mongo::Monitoring::Event::Cmap::ConnectionCheckedOut)
-      expect(check_out_results[1]).to be_a(Mongo::Monitoring::Event::Cmap::PoolCleared)
-      expect(check_out_results[2]).to be_a(Mongo::Monitoring::Event::Cmap::ConnectionCheckOutFailed)
-      expect(find_events.length).to eq(3)
+    end
+
+    it_behaves_like 'retries on PoolClearedError'
+
+    context 'legacy read retries' do
+
+      let(:client) { authorized_client.with(options.merge(retry_reads: false, max_read_retries: 1)) }
+
+      it_behaves_like 'retries on PoolClearedError'
     end
 
     after do
@@ -107,4 +119,157 @@ describe 'Retryable reads errors tests' do
       })
     end
   end
+
+  context 'Retries in a sharded cluster' do
+    require_topology :sharded
+    min_server_version '4.2'
+    require_no_auth
+
+    let(:subscriber) { Mrss::EventSubscriber.new }
+
+    let(:find_started_events) do
+      subscriber.started_events.select { |e| e.command_name == "find" }
+    end
+
+    let(:find_failed_events) do
+      subscriber.failed_events.select { |e| e.command_name == "find" }
+    end
+
+    let(:find_succeeded_events) do
+      subscriber.succeeded_events.select { |e| e.command_name == "find" }
+    end
+
+    context 'when another mongos is available' do
+
+      let(:first_mongos) do
+        Mongo::Client.new(
+          [SpecConfig.instance.addresses.first],
+          direct_connection: true,
+          database: 'admin'
+        )
+      end
+
+      let(:second_mongos) do
+        Mongo::Client.new(
+          [SpecConfig.instance.addresses.last],
+          direct_connection: false,
+          database: 'admin'
+        )
+      end
+
+      let(:client) do
+        new_local_client(
+          [
+            SpecConfig.instance.addresses.first,
+            SpecConfig.instance.addresses.last,
+          ],
+          SpecConfig.instance.test_options.merge(retry_reads: true)
+        )
+      end
+
+      let(:expected_servers) do
+        [
+          SpecConfig.instance.addresses.first.to_s,
+          SpecConfig.instance.addresses.last.to_s
+        ].sort
+      end
+
+      before do
+        skip 'This test requires at least two mongos' if SpecConfig.instance.addresses.length < 2
+
+        first_mongos.database.command(
+          configureFailPoint: 'failCommand',
+          mode: { times: 1 },
+          data: {
+            failCommands: %w(find),
+            closeConnection: false,
+            errorCode: 6
+          }
+        )
+
+        second_mongos.database.command(
+          configureFailPoint: 'failCommand',
+          mode: { times: 1 },
+          data: {
+            failCommands: %w(find),
+            closeConnection: false,
+            errorCode: 6
+          }
+        )
+      end
+
+      after do
+        [first_mongos, second_mongos].each do |admin_client|
+          admin_client.database.command(
+            configureFailPoint: 'failCommand',
+            mode: 'off'
+          )
+          admin_client.close
+        end
+        client.close
+      end
+
+      it 'retries on different mongos' do
+        client.subscribe(Mongo::Monitoring::COMMAND, subscriber)
+        expect { collection.find.first }.to raise_error(Mongo::Error::OperationFailure)
+        expect(find_started_events.map { |e| e.address.to_s }.sort).to eq(expected_servers)
+        expect(find_failed_events.map { |e| e.address.to_s }.sort).to eq(expected_servers)
+      end
+    end
+
+    context 'when no other mongos is available' do
+      let(:mongos) do
+        Mongo::Client.new(
+          [SpecConfig.instance.addresses.first],
+          direct_connection: true,
+          database: 'admin'
+        )
+      end
+
+      let(:client) do
+        new_local_client(
+          [
+            SpecConfig.instance.addresses.first
+          ],
+          SpecConfig.instance.test_options.merge(retry_reads: true)
+        )
+      end
+
+      before do
+        mongos.database.command(
+          configureFailPoint: 'failCommand',
+          mode: { times: 1 },
+          data: {
+            failCommands: %w(find),
+            closeConnection: false,
+            errorCode: 6
+          }
+        )
+      end
+
+      after do
+        mongos.database.command(
+          configureFailPoint: 'failCommand',
+          mode: 'off'
+        )
+        mongos.close
+        client.close
+      end
+
+      it 'retries on the same mongos' do
+        client.subscribe(Mongo::Monitoring::COMMAND, subscriber)
+        expect { collection.find.first }.not_to raise_error
+        expect(find_started_events.map { |e| e.address.to_s }.sort).to eq([
+          SpecConfig.instance.addresses.first.to_s,
+          SpecConfig.instance.addresses.first.to_s
+        ])
+        expect(find_failed_events.map { |e| e.address.to_s }.sort).to eq([
+          SpecConfig.instance.addresses.first.to_s
+        ])
+        expect(find_succeeded_events.map { |e| e.address.to_s }.sort).to eq([
+          SpecConfig.instance.addresses.first.to_s
+        ])
+      end
+    end
+  end
 end

data/spec/integration/retryable_writes_errors_spec.rb

@@ -189,4 +189,160 @@ describe 'Retryable writes errors tests' do
       })
     end
   end
+
+  context 'Retries in a sharded cluster' do
+    require_topology :sharded
+    min_server_version '4.2'
+    require_no_auth
+
+    let(:subscriber) { Mrss::EventSubscriber.new }
+
+    let(:insert_started_events) do
+      subscriber.started_events.select { |e| e.command_name == "insert" }
+    end
+
+    let(:insert_failed_events) do
+      subscriber.failed_events.select { |e| e.command_name == "insert" }
+    end
+
+    let(:insert_succeeded_events) do
+      subscriber.succeeded_events.select { |e| e.command_name == "insert" }
+    end
+
+    context 'when another mongos is available' do
+
+      let(:first_mongos) do
+        Mongo::Client.new(
+          [SpecConfig.instance.addresses.first],
+          direct_connection: true,
+          database: 'admin'
+        )
+      end
+
+      let(:second_mongos) do
+        Mongo::Client.new(
+          [SpecConfig.instance.addresses.last],
+          direct_connection: false,
+          database: 'admin'
+        )
+      end
+
+      let(:client) do
+        new_local_client(
+          [
+            SpecConfig.instance.addresses.first,
+            SpecConfig.instance.addresses.last,
+          ],
+          SpecConfig.instance.test_options.merge(retry_writes: true)
+        )
+      end
+
+      let(:expected_servers) do
+        [
+          SpecConfig.instance.addresses.first.to_s,
+          SpecConfig.instance.addresses.last.to_s
+        ].sort
+      end
+
+      before do
+        skip 'This test requires at least two mongos' if SpecConfig.instance.addresses.length < 2
+
+        first_mongos.database.command(
+          configureFailPoint: 'failCommand',
+          mode: { times: 1 },
+          data: {
+            failCommands: %w(insert),
+            closeConnection: false,
+            errorCode: 6,
+            errorLabels: ['RetryableWriteError']
+          }
+        )
+
+        second_mongos.database.command(
+          configureFailPoint: 'failCommand',
+          mode: { times: 1 },
+          data: {
+            failCommands: %w(insert),
+            closeConnection: false,
+            errorCode: 6,
+            errorLabels: ['RetryableWriteError']
+          }
+        )
+      end
+
+      after do
+        [first_mongos, second_mongos].each do |admin_client|
+          admin_client.database.command(
+            configureFailPoint: 'failCommand',
+            mode: 'off'
+          )
+          admin_client.close
+        end
+        client.close
+      end
+
+      it 'retries on different mongos' do
+        client.subscribe(Mongo::Monitoring::COMMAND, subscriber)
+        expect { collection.insert_one(x: 1) }.to raise_error(Mongo::Error::OperationFailure)
+        expect(insert_started_events.map { |e| e.address.to_s }.sort).to eq(expected_servers)
+        expect(insert_failed_events.map { |e| e.address.to_s }.sort).to eq(expected_servers)
+      end
+    end
+
+    context 'when no other mongos is available' do
+      let(:mongos) do
+        Mongo::Client.new(
+          [SpecConfig.instance.addresses.first],
+          direct_connection: true,
+          database: 'admin'
+        )
+      end
+
+      let(:client) do
+        new_local_client(
+          [
+            SpecConfig.instance.addresses.first
+          ],
+          SpecConfig.instance.test_options.merge(retry_writes: true)
+        )
+      end
+
+      before do
+        mongos.database.command(
+          configureFailPoint: 'failCommand',
+          mode: { times: 1 },
+          data: {
+            failCommands: %w(insert),
+            closeConnection: false,
+            errorCode: 6,
+            errorLabels: ['RetryableWriteError']
+          }
+        )
+      end
+
+      after do
+        mongos.database.command(
+          configureFailPoint: 'failCommand',
+          mode: 'off'
+        )
+        mongos.close
+        client.close
+      end
+
+      it 'retries on the same mongos' do
+        client.subscribe(Mongo::Monitoring::COMMAND, subscriber)
+        expect { collection.insert_one(x: 1) }.not_to raise_error
+        expect(insert_started_events.map { |e| e.address.to_s }.sort).to eq([
+          SpecConfig.instance.addresses.first.to_s,
+          SpecConfig.instance.addresses.first.to_s
+        ])
+        expect(insert_failed_events.map { |e| e.address.to_s }.sort).to eq([
+          SpecConfig.instance.addresses.first.to_s
+        ])
+        expect(insert_succeeded_events.map { |e| e.address.to_s }.sort).to eq([
+          SpecConfig.instance.addresses.first.to_s
+        ])
+      end
+    end
+  end
 end

data/spec/integration/sdam_error_handling_spec.rb

@@ -8,6 +8,8 @@ describe 'SDAM error handling' do
 
   clean_slate
 
+  retry_test
+
   after do
     # Close all clients after every test to avoid leaking expectations into
     # subsequent tests because we set global assertions on sockets.

data/spec/lite_spec_helper.rb

@@ -168,16 +168,6 @@ RSpec.configure do |config|
     end
   end
 
-  if SpecConfig.instance.ci? && !%w(1 true yes).include?(ENV['INTERACTIVE']&.downcase)
-    # Tests should take under 10 seconds ideally but it seems
-    # we have some that run for more than 10 seconds in CI.
-    config.around(:each) do |example|
-      TimeoutInterrupt.timeout(example_timeout_seconds, ExampleTimeout) do
-        example.run
-      end
-    end
-  end
-
   if SpecConfig.instance.ci?
     if defined?(Rfc::Rif)
       unless BSON::Environment.jruby?

data/spec/mongo/cluster_spec.rb

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
 require 'spec_helper'
+require 'support/recording_logger'
 
 # let these existing styles stand, rather than going in for a deep refactoring
 # of these specs.
@@ -84,6 +85,41 @@ describe Mongo::Cluster do
         )
       end
     end
+
+    context 'when a non-genuine host is detected' do
+      before { described_class.new(host_names, monitoring, logger: logger, monitoring_io: false) }
+
+      let(:logger) { RecordingLogger.new }
+
+      shared_examples 'an action that logs' do
+        it 'writes a warning to the log' do
+          expect(logger.lines).to include(a_string_matching(expected_log_output))
+        end
+      end
+
+      context 'when CosmosDB is detected' do
+        let(:host_names) { %w[ xyz.cosmos.azure.com ] }
+        let(:expected_log_output) { %r{https://www.mongodb.com/supportability/cosmosdb} }
+
+        it_behaves_like 'an action that logs'
+      end
+
+      context 'when DocumentDB is detected' do
+        let(:expected_log_output) { %r{https://www.mongodb.com/supportability/documentdb} }
+
+        context 'with docdb uri' do
+          let(:host_names) { [ 'xyz.docdb.amazonaws.com' ] }
+
+          it_behaves_like 'an action that logs'
+        end
+
+        context 'with docdb-elastic uri' do
+          let(:host_names) { [ 'xyz.docdb-elastic.amazonaws.com' ] }
+
+          it_behaves_like 'an action that logs'
+        end
+      end
+    end
   end
 
   describe '#==' do

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

@@ -321,7 +321,12 @@ describe Mongo::Collection::View::Aggregation do
           min_server_fcv '4.2'
 
           let(:result) do
-            aggregation.explain['queryPlanner']['collation']['locale']
+            if aggregation.explain.key?('queryPlanner')
+              aggregation.explain['queryPlanner']['collation']['locale']
+            else
+              # 7.2+ sharded cluster
+              aggregation.explain['shards'].first.last['queryPlanner']['collation']['locale']
+            end
           end
 
           it_behaves_like 'applies the collation'

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/operation/insert_spec.rb

@@ -177,7 +177,7 @@ describe Mongo::Operation::Insert do
         end
 
         it 'inserts the documents into the collection' do
-          expect(authorized_collection.find.to_a). to eq(documents)
+          expect(authorized_collection.find.sort(_id: 1).to_a). to eq(documents)
         end
       end
 

data/spec/mongo/retryable/write_worker_spec.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+describe Mongo::Retryable::WriteWorker do
+  describe '#nro_write_with_retry' do
+    context 'when session is nil' do
+      let(:retryable) do
+        authorized_client['write_worker_test']
+      end
+
+      let(:write_concern) do
+        Mongo::WriteConcern.get(w: 0)
+      end
+
+      let(:write_worker) do
+        described_class.new(retryable)
+      end
+
+      let(:context) do
+        instance_double(Mongo::Operation::Context).tap do |context|
+          allow(context).to receive(:session).and_return(nil)
+        end
+      end
+
+      before do
+        # We avoid actual execution of the operation to speed up and simplify
+        # the spec.
+        allow(write_worker).to receive(:legacy_write_with_retry).and_return(nil)
+      end
+
+      it 'does not raise' do
+        expect do
+          write_worker.nro_write_with_retry(write_concern, context: context)
+        end.not_to raise_error
+      end
+    end
+  end
+end