mongo 2.19.1 → 2.21.0

data/spec/integration/find_options_spec.rb

@@ -0,0 +1,227 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+describe 'Find operation options' do
+  require_mri
+  require_no_auth
+  min_server_fcv '4.4'
+
+  let(:subscriber) { Mrss::EventSubscriber.new }
+
+  let(:seeds) do
+    [ SpecConfig.instance.addresses.first ]
+  end
+
+  let(:client_options) do
+    {}
+  end
+
+  let(:collection_options) do
+    {}
+  end
+
+  let(:client) do
+    ClientRegistry.instance.new_local_client(
+      seeds,
+      SpecConfig.instance.test_options
+        .merge(database: SpecConfig.instance.test_db)
+        .merge(client_options)
+    ).tap do |client|
+      client.subscribe(Mongo::Monitoring::COMMAND, subscriber)
+    end
+  end
+
+  let(:collection) do
+    client['find_options', collection_options]
+  end
+
+  let(:find_command) do
+    subscriber.started_events.find { |cmd| cmd.command_name == 'find' }
+  end
+
+  let(:should_create_collection) { true }
+
+  before do
+    client['find_options'].drop
+    collection.create if should_create_collection
+    collection.insert_many([ { a: 1 }, { a: 2 }, { a: 3 } ])
+  end
+
+  describe 'collation' do
+    let(:client_options) do
+      {}
+    end
+
+    let(:collation) do
+      { 'locale' => 'en_US' }
+    end
+
+    context 'when defined on the collection' do
+      let(:collection_options) do
+        { collation: collation }
+      end
+
+      it 'uses the collation defined on the collection' do
+        collection.find.to_a
+        expect(find_command.command['collation']).to be_nil
+      end
+    end
+
+    context 'when defined on the operation' do
+      let(:collection_options) do
+        {}
+      end
+
+      it 'uses the collation defined on the collection' do
+        collection.find({}, collation: collation).to_a
+        expect(find_command.command['collation']).to eq(collation)
+      end
+    end
+
+    context 'when defined on both collection and operation' do
+      let(:collection_options) do
+        { 'locale' => 'de_AT' }
+      end
+
+      let(:should_create_collection) { false }
+
+      it 'uses the collation defined on the collection' do
+        collection.find({}, collation: collation).to_a
+        expect(find_command.command['collation']).to eq(collation)
+      end
+    end
+  end
+
+  describe 'read concern' do
+    context 'when defined on the client' do
+      let(:client_options) do
+        { read_concern: { level: :local } }
+      end
+
+      let(:collection_options) do
+        {}
+      end
+
+      it 'uses the read concern defined on the client' do
+        collection.find.to_a
+        expect(find_command.command['readConcern']).to eq('level' => 'local')
+      end
+
+      context 'when defined on the collection' do
+        let(:collection_options) do
+          { read_concern: { level: :majority } }
+        end
+
+        it 'uses the read concern defined on the collection' do
+          collection.find.to_a
+          expect(find_command.command['readConcern']).to eq('level' => 'majority')
+        end
+
+        context 'when defined on the operation' do
+          let(:operation_read_concern) do
+            { level: :available }
+          end
+
+          it 'uses the read concern defined on the operation' do
+            collection.find({}, read_concern: operation_read_concern).to_a
+            expect(find_command.command['readConcern']).to eq('level' => 'available')
+          end
+        end
+      end
+
+      context 'when defined on the operation' do
+        let(:collection_options) do
+          {}
+        end
+
+        let(:operation_read_concern) do
+          { level: :available }
+        end
+
+        it 'uses the read concern defined on the operation' do
+          collection.find({}, read_concern: operation_read_concern).to_a
+          expect(find_command.command['readConcern']).to eq('level' => 'available')
+        end
+      end
+    end
+
+    context 'when defined on the collection' do
+      let(:client_options) do
+        {}
+      end
+
+      let(:collection_options) do
+        { read_concern: { level: :majority } }
+      end
+
+      it 'uses the read concern defined on the collection' do
+        collection.find.to_a
+        expect(find_command.command['readConcern']).to eq('level' => 'majority')
+      end
+
+      context 'when defined on the operation' do
+        let(:operation_read_concern) do
+          { level: :available }
+        end
+
+        it 'uses the read concern defined on the operation' do
+          collection.find({}, read_concern: operation_read_concern).to_a
+          expect(find_command.command['readConcern']).to eq('level' => 'available')
+        end
+      end
+    end
+  end
+
+  describe 'read preference' do
+    require_topology :replica_set
+
+    context 'when defined on the client' do
+      let(:client_options) do
+        { read: { mode: :secondary } }
+      end
+
+      let(:collection_options) do
+        {}
+      end
+
+      it 'uses the read preference defined on the client' do
+        collection.find.to_a
+        expect(find_command.command['$readPreference']).to eq('mode' => 'secondary')
+      end
+
+      context 'when defined on the collection' do
+        let(:collection_options) do
+          { read: { mode: :secondary_preferred } }
+        end
+
+        it 'uses the read concern defined on the collection' do
+          collection.find.to_a
+          expect(find_command.command['$readPreference']).to eq('mode' => 'secondaryPreferred')
+        end
+      end
+    end
+  end
+
+  describe 'cursor type' do
+    let(:collection_options) do
+      { capped: true, size: 1000 }
+    end
+
+    context 'when cursor type is :tailable' do
+      it 'sets the cursor type to tailable' do
+        collection.find({}, cursor_type: :tailable).first
+        expect(find_command.command['tailable']).to be true
+        expect(find_command.command['awaitData']).to be_falsey
+      end
+    end
+
+    context 'when cursor type is :tailable_await' do
+      it 'sets the cursor type to tailable' do
+        collection.find({}, cursor_type: :tailable_await).first
+        expect(find_command.command['tailable']).to be true
+        expect(find_command.command['awaitData']).to be true
+      end
+    end
+  end
+end

data/spec/integration/operation_failure_code_spec.rb

@@ -17,7 +17,7 @@ describe 'OperationFailure code' do
         collection.insert_one(_id: 1)
         collection.insert_one(_id: 1)
         fail('Should have raised')
-      rescue Mongo::Error::OperationFailure => e
+      rescue Mongo::Error::OperationFailure::Family => e
         expect(e.code).to eq(11000)
         # 4.0 and 4.2 sharded clusters set code name.
         # 4.0 and 4.2 replica sets and standalones do not,

data/spec/integration/operation_failure_message_spec.rb

@@ -22,7 +22,7 @@ describe 'OperationFailure message' do
           begin
             client.command(bogus_command: nil)
             fail('Should have raised')
-          rescue Mongo::Error::OperationFailure => e
+          rescue Mongo::Error::OperationFailure::Family => e
             e.code_name.should == 'CommandNotFound'
             e.message.should =~ %r,\A\[59:CommandNotFound\]: no such (?:command|cmd): '?bogus_command'?,
           end
@@ -36,7 +36,7 @@ describe 'OperationFailure message' do
           begin
             client.command(bogus_command: nil)
             fail('Should have raised')
-          rescue Mongo::Error::OperationFailure => e
+          rescue Mongo::Error::OperationFailure::Family => e
             e.code_name.should be nil
             e.message.should =~ %r,\A\[59\]: no such (?:command|cmd): '?bogus_command'?,
           end
@@ -53,7 +53,7 @@ describe 'OperationFailure message' do
           collection.insert_one(_id: 1)
           collection.insert_one(_id: 1)
           fail('Should have raised')
-        rescue Mongo::Error::OperationFailure => e
+        rescue Mongo::Error::OperationFailure::Family => e
           e.code_name.should be nil
           e.message.should =~ %r,\A\[11000\]: (?:insertDocument :: caused by :: 11000 )?E11000 duplicate key error (?:collection|index):,
         end

data/spec/integration/retryable_errors_spec.rb

@@ -83,7 +83,7 @@ describe 'Failing retryable operations' do
 
         begin
           collection.find(a: 1).to_a
-        rescue Mongo::Error::OperationFailure => exception
+        rescue Mongo::Error::OperationFailure::Family => exception
         else
           fail('Expected operation to fail')
         end
@@ -128,7 +128,7 @@ describe 'Failing retryable operations' do
 
         begin
           collection.insert_one(a: 1)
-        rescue Mongo::Error::OperationFailure => exception
+        rescue Mongo::Error::OperationFailure::Family => exception
         else
           fail('Expected operation to fail')
         end

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