mongo 2.19.2 → 2.20.0

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/search_indexes_prose_spec.rb

@@ -0,0 +1,168 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+class SearchIndexHelper
+  attr_reader :client, :collection_name
+
+  def initialize(client)
+    @client = client
+
+    # https://github.com/mongodb/specifications/blob/master/source/index-management/tests/README.rst#id4
+    # "...each test uses a randomly generated collection name.  Drivers may
+    # generate this collection name however they like, but a suggested
+    # implementation is a hex representation of an ObjectId..."
+    @collection_name = BSON::ObjectId.new.to_s
+  end
+
+  # `soft_create` means to create the collection object without forcing it to
+  # be created in the database.
+  def collection(soft_create: false)
+    @collection ||= client.database[collection_name].tap do |collection|
+      collection.create unless soft_create
+    end
+  end
+
+  # Wait for all of the indexes with the given names to be ready; then return
+  # the list of index definitions corresponding to those names.
+  def wait_for(*names, &condition)
+    timeboxed_wait do
+      result = collection.search_indexes
+      return filter_results(result, names) if names.all? { |name| ready?(result, name, &condition) }
+    end
+  end
+
+  # Wait until all of the indexes with the given names are absent from the
+  # search index list.
+  def wait_for_absense_of(*names)
+    names.each do |name|
+      timeboxed_wait do
+        break if collection.search_indexes(name: name).empty?
+      end
+    end
+  end
+
+  private
+
+  def timeboxed_wait(step: 5, max: 300)
+    start = Mongo::Utils.monotonic_time
+
+    loop do
+      yield
+
+      sleep step
+      raise Timeout::Error, 'wait took too long' if Mongo::Utils.monotonic_time - start > max
+    end
+  end
+
+  # Returns true if the list of search indexes includes one with the given name,
+  # which is ready to be queried.
+  def ready?(list, name, &condition)
+    condition ||= ->(index) { index['queryable'] }
+    list.any? { |index| index['name'] == name && condition[index] }
+  end
+
+  def filter_results(result, names)
+    result.select { |index| names.include?(index['name']) }
+  end
+end
+
+describe 'Mongo::Collection#search_indexes prose tests' do
+  # https://github.com/mongodb/specifications/blob/master/source/index-management/tests/README.rst#id5
+  # "These tests must run against an Atlas cluster with a 7.0+ server."
+  require_atlas
+
+  let(:client) do
+    Mongo::Client.new(
+      ENV['ATLAS_URI'],
+      database: SpecConfig.instance.test_db,
+      ssl: true,
+      ssl_verify: true
+    )
+  end
+
+  let(:helper) { SearchIndexHelper.new(client) }
+
+  let(:name) { 'test-search-index' }
+  let(:definition) { { 'mappings' => { 'dynamic' => false } } }
+  let(:create_index) { helper.collection.search_indexes.create_one(definition, name: name) }
+
+  # Case 1: Driver can successfully create and list search indexes
+  context 'when creating and listing search indexes' do
+    let(:index) { helper.wait_for(name).first }
+
+    it 'succeeds' do
+      expect(create_index).to be == name
+      expect(index['latestDefinition']).to be == definition
+    end
+  end
+
+  # Case 2: Driver can successfully create multiple indexes in batch
+  context 'when creating multiple indexes in batch' do
+    let(:specs) do
+      [
+        { 'name' => 'test-search-index-1', 'definition' => definition },
+        { 'name' => 'test-search-index-2', 'definition' => definition }
+      ]
+    end
+
+    let(:names) { specs.map { |spec| spec['name'] } }
+    let(:create_indexes) { helper.collection.search_indexes.create_many(specs) }
+
+    let(:indexes) { helper.wait_for(*names) }
+
+    let(:index1) { indexes[0] }
+    let(:index2) { indexes[1] }
+
+    it 'succeeds' do
+      expect(create_indexes).to be == names
+      expect(index1['latestDefinition']).to be == specs[0]['definition']
+      expect(index2['latestDefinition']).to be == specs[1]['definition']
+    end
+  end
+
+  # Case 3: Driver can successfully drop search indexes
+  context 'when dropping search indexes' do
+    it 'succeeds' do
+      expect(create_index).to be == name
+      helper.wait_for(name)
+
+      helper.collection.search_indexes.drop_one(name: name)
+
+      expect { helper.wait_for_absense_of(name) }.not_to raise_error
+    end
+  end
+
+  # Case 4: Driver can update a search index
+  context 'when updating search indexes' do
+    let(:new_definition) { { 'mappings' => { 'dynamic' => true } } }
+
+    let(:index) do
+      helper
+        .wait_for(name) { |idx| idx['queryable'] && idx['status'] == 'READY' }
+        .first
+    end
+
+    # rubocop:disable RSpec/ExampleLength
+    it 'succeeds' do
+      expect(create_index).to be == name
+      helper.wait_for(name)
+
+      expect do
+        helper.collection.search_indexes.update_one(new_definition, name: name)
+      end.not_to raise_error
+
+      expect(index['latestDefinition']).to be == new_definition
+    end
+    # rubocop:enable RSpec/ExampleLength
+  end
+
+  # Case 5: dropSearchIndex suppresses namespace not found errors
+  context 'when dropping a non-existent search index' do
+    it 'ignores `namespace not found` errors' do
+      collection = helper.collection(soft_create: true)
+      expect { collection.search_indexes.drop_one(name: name) }
+        .not_to raise_error
+    end
+  end
+end

data/spec/lite_spec_helper.rb

@@ -106,6 +106,31 @@ Mrss.patch_mongo_for_session_registry
 
 class ExampleTimeout < StandardError; end
 
+STANDARD_TIMEOUTS = {
+  stress: 210,
+  jruby: 90,
+  default: 45,
+}.freeze
+
+def timeout_type
+  if ENV['EXAMPLE_TIMEOUT'].to_i > 0
+    :custom
+  elsif %w(1 true yes).include?(ENV['STRESS']&.downcase)
+    :stress
+  elsif BSON::Environment.jruby?
+    :jruby
+  else
+    :default
+  end
+end
+
+def example_timeout_seconds
+  STANDARD_TIMEOUTS.fetch(
+    timeout_type,
+    (ENV['EXAMPLE_TIMEOUT'] || STANDARD_TIMEOUTS[:default]).to_i
+  )
+end
+
 RSpec.configure do |config|
   config.extend(CommonShortcuts::ClassMethods)
   config.include(CommonShortcuts::InstanceMethods)
@@ -123,6 +148,12 @@ RSpec.configure do |config|
     end
   end
 
+  def require_atlas
+    before do
+      skip 'Set ATLAS_URI in environment to run atlas tests' if ENV['ATLAS_URI'].nil?
+    end
+  end
+
   if SpecConfig.instance.ci?
     SdamFormatterIntegration.subscribe
     config.add_formatter(JsonExtFormatter, File.join(File.dirname(__FILE__), '../tmp/rspec.json'))
@@ -141,16 +172,7 @@ RSpec.configure do |config|
     # 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|
-      timeout = if %w(1 true yes).include?(ENV['STRESS']&.downcase)
-        210
-      else
-        if BSON::Environment.jruby?
-          90
-        else
-          45
-        end
-      end
-      TimeoutInterrupt.timeout(timeout, ExampleTimeout) do
+      TimeoutInterrupt.timeout(example_timeout_seconds, ExampleTimeout) do
         example.run
       end
     end

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

@@ -2491,7 +2491,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

data/spec/mongo/server/app_metadata/environment_spec.rb

@@ -1,8 +1,52 @@
 # frozen_string_literal: true
+# rubocop:todo all
 
 require 'spec_helper'
+require 'fileutils'
+
+MOCKED_DOCKERENV_PATH = File.expand_path(File.join(Dir.pwd, '.dockerenv-mocked'))
+
+module ContainerChecking
+  def mock_dockerenv_path
+    before do
+      allow_any_instance_of(Mongo::Server::AppMetadata::Environment)
+        .to receive(:dockerenv_path)
+        .and_return(MOCKED_DOCKERENV_PATH)
+    end
+  end
+
+  def with_docker
+    mock_dockerenv_path
+
+    around do |example|
+      File.write(MOCKED_DOCKERENV_PATH, 'placeholder')
+      example.run
+    ensure
+      File.delete(MOCKED_DOCKERENV_PATH)
+    end
+  end
+
+  def without_docker
+    mock_dockerenv_path
+
+    around do |example|
+      FileUtils.rm_f(MOCKED_DOCKERENV_PATH)
+      example.run
+    end
+  end
+
+  def with_kubernetes
+    local_env 'KUBERNETES_SERVICE_HOST' => 'kubernetes.default.svc.cluster.local'
+  end
+
+  def without_kubernetes
+    local_env 'KUBERNETES_SERVICE_HOST' => nil
+  end
+end
 
 describe Mongo::Server::AppMetadata::Environment do
+  extend ContainerChecking
+
   let(:env) { described_class.new }
 
   shared_examples_for 'running in a FaaS environment' do
@@ -17,6 +61,36 @@ describe Mongo::Server::AppMetadata::Environment do
     end
   end
 
+  shared_examples_for 'not running in a Docker container' do
+    it 'does not detect Docker' do
+      expect(env.container || {}).not_to include :runtime
+    end
+  end
+
+  shared_examples_for 'not running under Kubernetes' do
+    it 'does not detect Kubernetes' do
+      expect(env.container || {}).not_to include :orchestrator
+    end
+  end
+
+  shared_examples_for 'running under Kubernetes' do
+    it 'detects that Kubernetes is present' do
+      expect(env.container[:orchestrator]).to be == 'kubernetes'
+    end
+  end
+
+  shared_examples_for 'running in a Docker container' do
+    it 'detects that Docker is present' do
+      expect(env.container[:runtime]).to be == 'docker'
+    end
+  end
+
+  shared_examples_for 'running under Kerbenetes' do
+    it 'detects that kubernetes is present' do
+      expect(env.container['orchestrator']).to be == 'kubernetes'
+    end
+  end
+
   context 'when run outside of a FaaS environment' do
     it_behaves_like 'running outside a FaaS environment'
   end
@@ -204,6 +278,67 @@ describe Mongo::Server::AppMetadata::Environment do
           timeout_sec: 60, region: 'us-central1',
         }
       end
+
+      context 'when a container is present' do
+        with_kubernetes
+        with_docker
+
+        it 'includes a container key' do
+          expect(env.to_h[:container]).to be == {
+            runtime: 'docker',
+            orchestrator: 'kubernetes'
+          }
+        end
+      end
+
+      context 'when no container is present' do
+        without_kubernetes
+        without_docker
+
+        it 'does not include a container key' do
+          expect(env.to_h).not_to include(:container)
+        end
+      end
+    end
+  end
+
+  # have a specific test for this, since the tests that check
+  # for Docker use a mocked value for the .dockerenv path.
+  it 'should look for dockerenv in root directory' do
+    expect(described_class::DOCKERENV_PATH).to be == '/.dockerenv'
+  end
+
+  context 'when no container is present' do
+    without_kubernetes
+    without_docker
+
+    it_behaves_like 'not running in a Docker container'
+    it_behaves_like 'not running under Kubernetes'
+  end
+
+  context 'when container is present' do
+    context 'when kubernetes is present' do
+      without_docker
+      with_kubernetes
+
+      it_behaves_like 'not running in a Docker container'
+      it_behaves_like 'running under Kubernetes'
+    end
+
+    context 'when docker is present' do
+      with_docker
+      without_kubernetes
+
+      it_behaves_like 'running in a Docker container'
+      it_behaves_like 'not running under Kubernetes'
+    end
+
+    context 'when both kubernetes and docker are present' do
+      with_docker
+      with_kubernetes
+
+      it_behaves_like 'running in a Docker container'
+      it_behaves_like 'running under Kubernetes'
     end
   end
 end