mongoid 9.0.12 → 9.1.0

data/spec/spec_helper.rb

@@ -1,12 +1,11 @@
 # frozen_string_literal: true
-# rubocop:todo all
 
 require 'lite_spec_helper'
 
-MODELS = File.join(File.dirname(__FILE__), "support/models")
+MODELS = File.join(File.dirname(__FILE__), 'support/models')
 $LOAD_PATH.unshift(MODELS)
 
-require "action_controller"
+require 'action_controller'
 require 'rspec/retry'
 
 if SpecConfig.instance.client_debug?
@@ -22,11 +21,32 @@ end
 # database names for each process running since we do not have transactions
 # and want a clean slate before each spec run.
 def database_id
-  "mongoid_test"
+  'mongoid_test'
 end
 
 def database_id_alt
-  "mongoid_test_alt"
+  'mongoid_test_alt'
+end
+
+# Helper for dynamically creating a new one-off document class, without having to
+# create a new constant. This helps avoid namespace pollution in specs and
+# the need to awkwardly remove constants in an after block.
+#
+# Example:
+#   let(:model_class) do
+#     test_model do
+#       field :name, type: String
+#     end
+#   end
+#
+#   let(:model) { model_class.new(name: 'Test') }
+#
+def test_model(name: 'TestModel', &block)
+  Class.new.tap do |klass|
+    klass.define_singleton_method(:name) { name.to_s }
+    klass.include Mongoid::Document
+    klass.class_eval(&block) if block_given?
+  end
 end
 
 begin
@@ -34,11 +54,11 @@ begin
   require 'support/client_registry'
   require 'mrss/constraints'
   require 'mrss/event_subscriber'
-rescue LoadError => exc
+rescue LoadError => e
   raise LoadError.new <<~MSG.strip
     The test suite requires shared tooling to be installed.
     Please refer to spec/README.md for instructions.
-    #{exc.class}: #{exc}
+    #{e.class}: #{e}
   MSG
 end
 
@@ -51,7 +71,7 @@ require 'support/macros'
 require 'support/constraints'
 require 'support/crypt'
 
-use_ssl = %w[ ssl 1 true ].include?(ENV['SSL'])
+use_ssl = %w[ ssl 1 true ].include?(ENV.fetch('SSL', nil))
 ssl_options = { ssl: use_ssl }.freeze
 
 # Give MongoDB servers time to start up in CI environments
@@ -62,7 +82,7 @@ if SpecConfig.instance.ci?
     begin
       client.command(ping: 1)
       break
-    rescue Mongo::Error::OperationFailure => e
+    rescue Mongo::Error::OperationFailure
       sleep(2)
       client.cluster.scan!
     end
@@ -88,21 +108,28 @@ CONFIG = {
   options: {
     belongs_to_required_by_default: false,
     log_level: if SpecConfig.instance.client_debug?
-      :debug
-    else
-      :info
-    end,
+                 :debug
+               else
+                 :info
+               end
   }
 }
 
+if SpecConfig.instance.uri.uri_options[:load_balanced]
+  # If the URI specifies load balancing, we need to set the load_balanced option
+  # in the client configuration.
+  CONFIG[:clients][:default][:options][:load_balanced] = true
+  CONFIG[:clients][:default][:options][:connect] = :load_balanced
+end
+
 # Set the database that the spec suite connects to.
 Mongoid.configure do |config|
   config.load_configuration(CONFIG)
 end
 
 # Autoload every model for the test suite that sits in spec/support/models.
-Dir[ File.join(MODELS, "*.rb") ].sort.each do |file|
-  name = File.basename(file, ".rb")
+Dir[File.join(MODELS, '*.rb')].sort.each do |file|
+  name = File.basename(file, '.rb')
   autoload name.camelize.to_sym, name
 end
 
@@ -113,28 +140,29 @@ module Mongoid
 end
 
 ActiveSupport::Inflector.inflections do |inflect|
-  inflect.irregular("canvas", "canvases")
-  inflect.singular("address_components", "address_component")
+  inflect.irregular('canvas', 'canvases')
+  inflect.singular('address_components', 'address_component')
 end
 
 Time.zone = 'UTC'
 
 I18n.config.enforce_available_locales = false
 
-if %w(yes true 1).include?((ENV['TEST_I18N_FALLBACKS'] || '').downcase)
-  require "i18n/backend/fallbacks"
-end
+require 'i18n/backend/fallbacks' if %w[yes true 1].include?((ENV['TEST_I18N_FALLBACKS'] || '').downcase)
 
 unless SpecConfig.instance.atlas?
+  uri_options = SpecConfig.instance.uri.uri_options.merge(server_selection_timeout: 3.03)
+  uri_options[:connect] = :load_balanced if uri_options[:load_balanced]
+
   # The user must be created before any of the tests are loaded, until
   # https://jira.mongodb.org/browse/MONGOID-4827 is implemented.
-  client = Mongo::Client.new(SpecConfig.instance.addresses, server_selection_timeout: 3.03)
+  client = Mongo::Client.new(SpecConfig.instance.addresses, uri_options)
   begin
     # Create the root user administrator as the first user to be added to the
     # database. This user will need to be authenticated in order to add any
     # more users to any other databases.
     client.database.users.create(MONGOID_ROOT_USER)
-  rescue Mongo::Error::OperationFailure => e
+  rescue Mongo::Error::OperationFailure
   ensure
     client.close
   end
@@ -153,21 +181,16 @@ RSpec.configure do |config|
   end
 
   # Drop all collections and clear the identity map before each spec.
-  config.before(:each) do
+  config.before do
     cluster = Mongoid.default_client.cluster
-    # Older drivers do not have a #connected? method
-    if cluster.respond_to?(:connected?) && !cluster.connected?
-      Mongoid.default_client.reconnect
-    end
-    Mongoid.default_client.collections.each do |coll|
-      coll.delete_many
-    end
+    Mongoid.default_client.reconnect if cluster.load_balanced? || !cluster.connected?
+
+    Mongoid.default_client.collections.each(&:drop)
   end
 end
 
 # A subscriber to be used with the Ruby driver for testing.
 class EventSubscriber
-
   # The started events.
   attr_reader :started_events
 

data/spec/support/authorization.rb

@@ -1,5 +1,4 @@
 # frozen_string_literal: true
-# rubocop:todo all
 
 # Set up a root user so we can set up authentication on a database level.
 MONGOID_ROOT_USER = Mongo::Auth::User.new(

data/spec/support/client_registry.rb

@@ -1,10 +1,9 @@
-# rubocop:todo all
 require 'singleton'
 
 class ClientRegistry
   include Singleton
 
-  def global_client(name)
+  def global_client(_name)
     Mongoid.default_client
   end
 end

data/spec/support/constraints.rb

@@ -1,5 +1,4 @@
 # frozen_string_literal: true
-# rubocop:todo all
 
 module Constraints
   RAILS_VERSION = ActiveSupport.version.to_s.split('.')[0..1].join('.').freeze
@@ -8,9 +7,7 @@ module Constraints
     required_version = version.split('.').map(&:to_i)
     actual_version = driver_version(required_version.length)
     before(:all) do
-      if (actual_version <=> required_version) < 0
-        skip "Driver version #{version} or higher is required"
-      end
+      skip "Driver version #{version} or higher is required" if (actual_version <=> required_version) < 0
     end
   end
 
@@ -18,9 +15,7 @@ module Constraints
     required_version = version.split('.').map(&:to_i)
     actual_version = driver_version(required_version.length)
     before(:all) do
-      if (actual_version <=> required_version) > 0
-        skip "Driver version #{version} or lower is required"
-      end
+      skip "Driver version #{version} or lower is required" if (actual_version <=> required_version) > 0
     end
   end
 
@@ -32,9 +27,7 @@ module Constraints
     required_version = version.split('.').map(&:to_i)
     actual_version = bson_version(required_version.length)
     before(:all) do
-      if (actual_version <=> required_version) < 0
-        skip "bson-ruby version #{version} or higher is required"
-      end
+      skip "bson-ruby version #{version} or higher is required" if (actual_version <=> required_version) < 0
     end
   end
 
@@ -42,9 +35,7 @@ module Constraints
     required_version = version.split('.').map(&:to_i)
     actual_version = bson_version(required_version.length)
     before(:all) do
-      if (actual_version <=> required_version) > 0
-        skip "bson-ruby version #{version} or lower is required"
-      end
+      skip "bson-ruby version #{version} or lower is required" if (actual_version <=> required_version) > 0
     end
   end
 
@@ -53,26 +44,18 @@ module Constraints
   end
 
   def min_rails_version(version)
-    unless version =~ /\A\d+\.\d+\z/
-      raise ArgumentError, "Version can only be major.minor: #{version}"
-    end
+    raise ArgumentError, "Version can only be major.minor: #{version}" unless /\A\d+\.\d+\z/.match?(version)
 
     before(:all) do
-      if version > RAILS_VERSION
-        skip "Rails version #{version} or higher required, we have #{RAILS_VERSION}"
-      end
+      skip "Rails version #{version} or higher required, we have #{RAILS_VERSION}" if version > RAILS_VERSION
     end
   end
 
   def max_rails_version(version)
-    unless version =~ /\A\d+\.\d+\z/
-      raise ArgumentError, "Version can only be major.minor: #{version}"
-    end
+    raise ArgumentError, "Version can only be major.minor: #{version}" unless /\A\d+\.\d+\z/.match?(version)
 
     before(:all) do
-      if version < RAILS_VERSION
-        skip "Rails version #{version} or lower required, we have #{RAILS_VERSION}"
-      end
+      skip "Rails version #{version} or lower required, we have #{RAILS_VERSION}" if version < RAILS_VERSION
     end
   end
 end

data/spec/support/crypt/models.rb

@@ -1,12 +1,11 @@
-# rubocop:todo all
 module Crypt
   class Patient
     include Mongoid::Document
 
-    encrypt_with key_id: "grolrnFVSSW9Gq04Q87R9Q=="
+    encrypt_with key_id: 'grolrnFVSSW9Gq04Q87R9Q=='
 
     field :code, type: String
-    field :medical_records, type: Array, encrypt: { deterministic: false}
+    field :medical_records, type: Array, encrypt: { deterministic: false }
     field :blood_type, type: String, encrypt: {
       deterministic: false,
       key_name_field: :blood_type_key_name
@@ -14,25 +13,25 @@ module Crypt
     field :ssn, type: Integer, encrypt: { deterministic: true }
     field :blood_type_key_name, type: String
 
-    embeds_one :insurance, class_name: "Crypt::Insurance"
+    embeds_one :insurance, class_name: 'Crypt::Insurance'
   end
 
   class Insurance
     include Mongoid::Document
 
     field :policy_number, type: Integer, encrypt: { deterministic: true }
-    embedded_in :patient, class_name: "Crypt::Patient"
+    embedded_in :patient, class_name: 'Crypt::Patient'
   end
 
   class User
     include Mongoid::Document
 
     field :name, type: String, encrypt: {
-      key_id: "grolrnFVSSW9Gq04Q87R9Q==",
+      key_id: 'grolrnFVSSW9Gq04Q87R9Q==',
       deterministic: false
     }
     field :email, type: String, encrypt: {
-      key_id: "S34mE/HhSFSym3yErpER6Q==",
+      key_id: 'S34mE/HhSFSym3yErpER6Q==',
       deterministic: true
     }
   end
@@ -42,166 +41,9 @@ module Crypt
 
     store_in database: 'vehicles'
 
-    encrypt_with key_id: "grolrnFVSSW9Gq04Q87R9Q==", deterministic: true
-
-    field :vin, type: String, encrypt: true
-    field :make, type: String
-  end
-
-  # An encrypted model whose database name is a callable resolving to a
-  # constant. The callable form of :database is supported by store_in, but the
-  # encryption schema map is keyed by namespace and built once, so this model's
-  # namespace is not known when the map is generated.
-  class DynamicCar
-    include Mongoid::Document
-
-    store_in database: -> { 'vehicles_dynamic' }
-
     encrypt_with key_id: 'grolrnFVSSW9Gq04Q87R9Q==', deterministic: true
 
     field :vin, type: String, encrypt: true
-  end
-
-  # An encrypted model using the documented multi-tenant idiom, where the
-  # database name is only known once a tenant is selected. There is no correct
-  # value to resolve at client construction time.
-  class TenantCar
-    include Mongoid::Document
-
-    # The fallback keeps this model usable by tasks that iterate every model,
-    # such as Mongoid::Tasks::Database.create_collections. Mongoid raises
-    # NoMethodError when a callable :database resolves to nil.
-    store_in database: -> { Thread.current[:tenant_database] || 'vehicles_no_tenant' }
-
-    encrypt_with key_id: 'grolrnFVSSW9Gq04Q87R9Q==', deterministic: true
-
-    field :vin, type: String, encrypt: true
-  end
-
-  # An encrypted model that is embedded by more than one parent, and more than
-  # once by the same parent.
-  class Token
-    include Mongoid::Document
-
-    field :value, type: String, encrypt: { deterministic: true }
-
-    embedded_in :tokenized, polymorphic: true
-  end
-
-  # A parent whose encrypted data lives entirely in an embedded model: it has
-  # no encrypted field of its own and no encrypt_with.
-  class Wallet
-    include Mongoid::Document
-
-    embeds_one :token, class_name: 'Crypt::Token', as: :tokenized
-  end
-
-  # Two parents embedding the same encrypted model.
-  class Vault
-    include Mongoid::Document
-
-    encrypt_with key_id: 'grolrnFVSSW9Gq04Q87R9Q=='
-
-    embeds_one :token, class_name: 'Crypt::Token', as: :tokenized
-  end
-
-  class Chest
-    include Mongoid::Document
-
-    encrypt_with key_id: 'grolrnFVSSW9Gq04Q87R9Q=='
-
-    embeds_one :token, class_name: 'Crypt::Token', as: :tokenized
-  end
-
-  # A parent embedding the same encrypted model through two relations.
-  class Ledger
-    include Mongoid::Document
-
-    encrypt_with key_id: 'grolrnFVSSW9Gq04Q87R9Q=='
-
-    embeds_one :primary_token, class_name: 'Crypt::Token', as: :tokenized
-    embeds_one :backup_token, class_name: 'Crypt::Token', as: :tokenized
-  end
-
-  # Three levels of nesting, where the middle level has no encrypted field of
-  # its own.
-  class Owner
-    include Mongoid::Document
-
-    encrypt_with key_id: 'grolrnFVSSW9Gq04Q87R9Q=='
-
-    embeds_one :account, class_name: 'Crypt::Account'
-  end
-
-  class Account
-    include Mongoid::Document
-
-    embedded_in :owner, class_name: 'Crypt::Owner'
-    embeds_one :credential, class_name: 'Crypt::Credential'
-  end
-
-  class Credential
-    include Mongoid::Document
-
-    field :secret, type: String, encrypt: { deterministic: true }
-
-    embedded_in :account, class_name: 'Crypt::Account'
-  end
-
-  # A model that embeds itself. The walk over embedded relations has to stop
-  # here, or generating the map never terminates.
-  class Comment
-    include Mongoid::Document
-
-    field :body, type: String, encrypt: { deterministic: true }
-
-    embedded_in :commentable, polymorphic: true
-    embeds_one :reply, class_name: 'Crypt::Comment', as: :commentable
-  end
-
-  class Article
-    include Mongoid::Document
-
-    encrypt_with key_id: 'grolrnFVSSW9Gq04Q87R9Q=='
-
-    embeds_one :comment, class_name: 'Crypt::Comment', as: :commentable
-  end
-
-  # A parent with no encrypted field of its own: the encrypted field lives on
-  # the embedded model. Used by the integration specs, so the embedded model
-  # carries a key id.
-  class Folder
-    include Mongoid::Document
-
-    embeds_one :note, class_name: 'Crypt::Note'
-  end
-
-  class Note
-    include Mongoid::Document
-
-    encrypt_with key_id: 'grolrnFVSSW9Gq04Q87R9Q==', deterministic: true
-
-    field :text, type: String, encrypt: true
-
-    embedded_in :folder, class_name: 'Crypt::Folder'
-  end
-
-  # A model naming an embedded class that is never defined. The association
-  # cannot be used, so nothing is ever embedded through it, but every model in
-  # the application is walked when the schema map is generated.
-  class Drawer
-    include Mongoid::Document
-
-    embeds_one :missing_note, class_name: 'Crypt::MissingNote'
-  end
-
-  # The same, on a model that is encrypted itself, so the walk descends into
-  # its relations.
-  class Cabinet
-    include Mongoid::Document
-
-    field :label, type: String, encrypt: { deterministic: true }
-
-    embeds_one :missing_note, class_name: 'Crypt::MissingNote'
+    field :make, type: String
   end
 end

data/spec/support/crypt.rb

@@ -1,30 +1,27 @@
 # frozen_string_literal: true
-# rubocop:todo all
 
 module Mongoid
   # This module includes helpers for testing encryption.
   module Crypt
-
     shared_context 'with encryption' do
       let(:mongocryptd_port) do
         if ENV['MONGO_RUBY_DRIVER_MONGOCRYPTD_PORT'] &&
-          !ENV['MONGO_RUBY_DRIVER_MONGOCRYPTD_PORT'].empty?
-        then
+           !ENV['MONGO_RUBY_DRIVER_MONGOCRYPTD_PORT'].empty?
           ENV['MONGO_RUBY_DRIVER_MONGOCRYPTD_PORT'].to_i
         else
-          27020
+          27_020
         end
       end
 
       let(:extra_options) do
         {
-          mongocryptd_spawn_args: ["--port=#{mongocryptd_port}"],
-          mongocryptd_uri: "mongodb://localhost:#{mongocryptd_port}",
+          mongocryptd_spawn_args: [ "--port=#{mongocryptd_port}" ],
+          mongocryptd_uri: "mongodb://localhost:#{mongocryptd_port}"
         }
       end
 
       let(:crypt_shared_lib_path) do
-        ENV['MONGO_RUBY_DRIVER_CRYPT_SHARED_LIB_PATH']
+        ENV.fetch('MONGO_RUBY_DRIVER_CRYPT_SHARED_LIB_PATH', nil)
       end
 
       let(:key_vault_client) do
@@ -71,7 +68,7 @@ module Mongoid
         if (data_key = client_encryption.get_key_by_alt_name(key_alt_name))
           Base64.encode64(data_key['_id'].data)
         else
-          key_id = client_encryption.create_data_key('local', key_alt_names: [key_alt_name])
+          key_id = client_encryption.create_data_key('local', key_alt_names: [ key_alt_name ])
           Base64.encode64(key_id.data).strip
         end
       end

data/spec/support/expectations.rb

@@ -4,7 +4,25 @@ module Mongoid
   module Expectations
     # Previously this method used RSpec::Mocks with .exactly.times(n).and_call_original,
     # which stopped working reliably in Ruby 3.3. Now we directly wrap the target method.
-    def expect_query(number)
+    def expect_query(number, &test_block)
+      count_queries_and_verify(number, test_block) do |query_count|
+        expect(query_count).to eq(number)
+      end
+    end
+
+    def expect_less_than_queries(maximum, &test_block)
+      count_queries_and_verify(maximum, test_block) do |query_count|
+        expect(query_count).to be < maximum
+      end
+    end
+
+    def expect_no_queries(&test_block)
+      expect_query(0, &test_block)
+    end
+
+    private
+
+    def count_queries_and_verify(number, test_block)
       if %i[ sharded load-balanced ].include?(ClusterConfig.instance.topology) && number > 0
         skip 'This spec requires replica set or standalone topology'
       end
@@ -19,17 +37,13 @@ module Mongoid
           original_method.bind_call(self, *args, **kwargs)
         end
 
-        result = yield
-        expect(query_count).to eq(number)
+        result = test_block.call
+        yield query_count
         result
       ensure
         klass.remove_method(:command_started)
         klass.define_method(:command_started, original_method)
       end
     end
-
-    def expect_no_queries(&block)
-      expect_query(0, &block)
-    end
   end
 end

data/spec/support/feature_sandbox.rb

@@ -1,5 +1,4 @@
 # frozen_string_literal: true
-# rubocop:todo all
 
 # A helper utility for allowing features to be loaded and constants defined
 # inside a sandbox, where they can be unloaded and undefined when finished.
@@ -60,9 +59,7 @@ module FeatureSandbox
   def unload_constants(parent, list)
     list.each do |name|
       obj = parent.const_get(name)
-      if obj.is_a?(Module) && obj.constants(false).any?
-        unload_constants(obj, obj.constants(false))
-      end
+      unload_constants(obj, obj.constants(false)) if obj.is_a?(Module) && obj.constants(false).any?
 
       Mongoid.deregister_model(obj) if obj.is_a?(Mongoid::Document)
 

data/spec/support/helpers.rb

@@ -1,4 +1,3 @@
-# rubocop:todo all
 module Helpers
   # Reloads the specified model class.
   #