mongo 2.19.1 → 2.19.3

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/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/runners/unified/search_index_operations.rb

@@ -0,0 +1,63 @@
+# frozen_string_literal: true
+
+module Unified
+  # The definitions of available search index operations, as used by the
+  # unified tests.
+  module SearchIndexOperations
+    def create_search_index(op)
+      collection = entities.get(:collection, op.use!('object'))
+
+      use_arguments(op) do |args|
+        model = args.use('model')
+        name = model.use('name')
+        definition = model.use('definition')
+        collection.search_indexes.create_one(definition, name: name)
+      end
+    end
+
+    def create_search_indexes(op)
+      collection = entities.get(:collection, op.use!('object'))
+
+      use_arguments(op) do |args|
+        models = args.use('models')
+        collection.search_indexes.create_many(models)
+      end
+    end
+
+    def drop_search_index(op)
+      collection = entities.get(:collection, op.use!('object'))
+
+      use_arguments(op) do |args|
+        collection.search_indexes.drop_one(
+          id: args.use('id'),
+          name: args.use('name')
+        )
+      end
+    end
+
+    def list_search_indexes(op)
+      collection = entities.get(:collection, op.use!('object'))
+
+      use_arguments(op) do |args|
+        agg_opts = args.use('aggregationOptions') || {}
+        collection.search_indexes(
+          id: args.use('id'),
+          name: args.use('name'),
+          aggregate: ::Utils.underscore_hash(agg_opts)
+        ).to_a
+      end
+    end
+
+    def update_search_index(op)
+      collection = entities.get(:collection, op.use!('object'))
+
+      use_arguments(op) do |args|
+        collection.search_indexes.update_one(
+          args.use('definition'),
+          id: args.use('id'),
+          name: args.use('name')
+        )
+      end
+    end
+  end
+end

data/spec/runners/unified/test.rb

@@ -9,6 +9,7 @@ require 'runners/unified/ddl_operations'
 require 'runners/unified/change_stream_operations'
 require 'runners/unified/support_operations'
 require 'runners/unified/thread_operations'
+require 'runners/unified/search_index_operations'
 require 'runners/unified/assertions'
 require 'support/utils'
 require 'support/crypt'
@@ -23,6 +24,7 @@ module Unified
     include ChangeStreamOperations
     include SupportOperations
     include ThreadOperations
+    include SearchIndexOperations
     include Assertions
     include RSpec::Core::Pending
 
@@ -120,7 +122,7 @@ module Unified
             # the other set members, in standalone deployments because
             # there is only one server, but changes behavior in
             # sharded clusters compared to how the test suite is configured.
-            opts[:single_address] = true
+            options[:single_address] = true
           end
 
           if store_events = spec.use('storeEventsAsEntities')

data/spec/spec_helper.rb

@@ -20,7 +20,7 @@ RSpec.configure do |config|
   config.extend(Constraints)
 
   config.before(:all) do
-    if ClusterConfig.instance.fcv_ish >= '3.6' && !SpecConfig.instance.serverless? # Serverless instances do not support killAllSessions command.
+    if SpecConfig.instance.kill_all_server_sessions?
       kill_all_server_sessions
     end
   end

data/spec/spec_tests/data/index_management/createSearchIndex.yml

@@ -0,0 +1,62 @@
+description: "createSearchIndex"
+schemaVersion: "1.4"
+createEntities:
+  - client:
+      id: &client0 client0
+      useMultipleMongoses: false
+      observeEvents:
+        - commandStartedEvent
+  - database:
+      id: &database0 database0
+      client: *client0
+      databaseName: *database0
+  - collection:
+      id: &collection0 collection0
+      database: *database0
+      collectionName: *collection0
+
+runOnRequirements:
+  - minServerVersion: "7.0.0"
+    topologies: [ replicaset, load-balanced, sharded ]
+    serverless: forbid
+
+tests:
+  - description: "no name provided for an index definition"
+    operations:
+      - name: createSearchIndex
+        object: *collection0
+        arguments:
+          model: { definition: &definition { mappings: { dynamic: true } } }
+        expectError:
+          # This test always errors in a non-Atlas environment.  The test functions as a unit test  by asserting
+          # that the driver constructs and sends the correct command.
+          isError: true
+          errorContains: Search index commands are only supported with Atlas
+    expectEvents:
+      - client: *client0
+        events:
+          - commandStartedEvent:
+              command:
+                createSearchIndexes: *collection0
+                indexes: [ { definition: *definition } ]
+                $db: *database0
+
+  - description: "name provided for an index definition"
+    operations:
+      - name: createSearchIndex
+        object: *collection0
+        arguments: 
+          model: { definition: &definition { mappings: { dynamic: true } } , name: 'test index' }
+        expectError:
+          # This test always errors in a non-Atlas environment.  The test functions as a unit test  by asserting
+          # that the driver constructs and sends the correct command.
+          isError: true
+          errorContains: Search index commands are only supported with Atlas
+    expectEvents:
+      - client: *client0
+        events:
+          - commandStartedEvent:
+              command:
+                createSearchIndexes: *collection0
+                indexes: [ { definition: *definition, name: 'test index' } ]
+                $db: *database0

data/spec/spec_tests/data/index_management/createSearchIndexes.yml

@@ -0,0 +1,83 @@
+description: "createSearchIndexes"
+schemaVersion: "1.4"
+createEntities:
+  - client:
+      id: &client0 client0
+      useMultipleMongoses: false
+      observeEvents:
+        - commandStartedEvent
+  - database:
+      id: &database0 database0
+      client: *client0
+      databaseName: *database0
+  - collection:
+      id: &collection0 collection0
+      database: *database0
+      collectionName: *collection0
+
+runOnRequirements:
+  - minServerVersion: "7.0.0"
+    topologies: [ replicaset, load-balanced, sharded ]
+    serverless: forbid
+
+tests:
+  - description: "empty index definition array"
+    operations:
+      - name: createSearchIndexes
+        object: *collection0
+        arguments: 
+          models: []
+        expectError:
+          # This test always errors in a non-Atlas environment.  The test functions as a unit test  by asserting
+          # that the driver constructs and sends the correct command.
+          isError: true
+          errorContains: Search index commands are only supported with Atlas
+    expectEvents:
+      - client: *client0
+        events:
+          - commandStartedEvent:
+              command:
+                createSearchIndexes: *collection0
+                indexes: []
+                $db: *database0
+
+
+  - description: "no name provided for an index definition"
+    operations:
+      - name: createSearchIndexes
+        object: *collection0
+        arguments:
+          models: [ { definition: &definition { mappings: { dynamic: true } } } ]
+        expectError:
+          # This test always errors in a non-Atlas environment.  The test functions as a unit test  by asserting
+          # that the driver constructs and sends the correct command.
+          isError: true
+          errorContains: Search index commands are only supported with Atlas
+    expectEvents:
+      - client: *client0
+        events:
+          - commandStartedEvent:
+              command:
+                createSearchIndexes: *collection0
+                indexes: [ { definition: *definition } ]
+                $db: *database0
+
+  - description: "name provided for an index definition"
+    operations:
+      - name: createSearchIndexes
+        object: *collection0
+        arguments: 
+          models: [ { definition: &definition { mappings: { dynamic: true } } , name: 'test index' } ]
+        expectError:
+          # This test always errors in a non-Atlas environment.  The test functions as a unit test  by asserting
+          # that the driver constructs and sends the correct command.
+          isError: true
+          errorContains: Search index commands are only supported with Atlas
+    expectEvents:
+      - client: *client0
+        events:
+          - commandStartedEvent:
+              command:
+                createSearchIndexes: *collection0
+                indexes: [ { definition: *definition, name: 'test index' } ]
+                $db: *database0