mongoid 6.4.8 → 7.5.4

data/spec/spec_helper.rb

@@ -1,29 +1,25 @@
-$LOAD_PATH.unshift(File.dirname(__FILE__))
-$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), "..", "lib"))
+# frozen_string_literal: true
 
-MODELS = File.join(File.dirname(__FILE__), "app/models")
+require 'lite_spec_helper'
+
+MODELS = File.join(File.dirname(__FILE__), "support/models")
 $LOAD_PATH.unshift(MODELS)
 
 require "action_controller"
-require "mongoid"
-require "rspec"
-
-# These environment variables can be set if wanting to test against a database
-# that is not on the local machine.
-ENV["MONGOID_SPEC_HOST"] ||= "127.0.0.1"
-ENV["MONGOID_SPEC_PORT"] ||= "27017"
-
-# These are used when creating any connection in the test suite.
-HOST = ENV["MONGOID_SPEC_HOST"]
-PORT = ENV["MONGOID_SPEC_PORT"].to_i
+require 'rspec/retry'
 
-Mongo::Logger.logger.level = Logger::INFO
-# Mongoid.logger.level = Logger::DEBUG
+if SpecConfig.instance.client_debug?
+  Mongoid.logger.level = Logger::DEBUG
+  Mongo::Logger.logger.level = Logger::DEBUG
+else
+  Mongoid.logger.level = Logger::INFO
+  Mongo::Logger.logger.level = Logger::INFO
+end
 
 # When testing locally we use the database named mongoid_test. However when
-# tests are running in parallel on Travis we need to use different database
-# names for each process running since we do not have transactions and want a
-# clean slate before each spec run.
+# tests are running in parallel in a CI environment we need to use different
+# 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"
 end
@@ -32,21 +28,34 @@ def database_id_alt
   "mongoid_test_alt"
 end
 
+begin
+  require 'mrss/cluster_config'
+  require 'support/client_registry'
+  require 'mrss/constraints'
+  require 'mrss/event_subscriber'
+rescue LoadError => exc
+  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}
+  MSG
+end
+
+ClusterConfig = Mrss::ClusterConfig
+
 require 'support/authorization'
 require 'support/expectations'
+require 'support/helpers'
 require 'support/macros'
-require 'support/spec_config'
-require 'support/cluster_config'
 require 'support/constraints'
-require 'support/session_registry'
 
-# Give MongoDB time to start up on the travis ci environment.
-if (ENV['CI'] == 'travis' || ENV['CI'] == 'evergreen')
+# Give MongoDB servers time to start up in CI environments
+if SpecConfig.instance.ci?
   starting = true
-  client = Mongo::Client.new(['127.0.0.1:27017'])
+  client = Mongo::Client.new(SpecConfig.instance.addresses)
   while starting
     begin
-      client.command(Mongo::Server::Monitor::Connection::ISMASTER)
+      client.command(ping: 1)
       break
     rescue Mongo::Error::OperationFailure => e
       sleep(2)
@@ -59,9 +68,10 @@ CONFIG = {
   clients: {
     default: {
       database: database_id,
-      hosts: [ "#{HOST}:#{PORT}" ],
+      hosts: SpecConfig.instance.addresses,
       options: {
-        server_selection_timeout: 0.5,
+        server_selection_timeout: 3.42,
+        wait_queue_timeout: 1,
         max_pool_size: 5,
         heartbeat_frequency: 180,
         user: MONGOID_ROOT_USER.name,
@@ -71,38 +81,21 @@ CONFIG = {
     }
   },
   options: {
-    belongs_to_required_by_default: false
+    belongs_to_required_by_default: false,
+    log_level: if SpecConfig.instance.client_debug?
+      :debug
+    else
+      :info
+    end,
   }
 }
 
-def non_legacy_server?
-  Mongoid::Clients.default.cluster.servers.first.features.write_command_enabled?
-end
-
-def testing_replica_set?
-  Mongoid::Clients.default.cluster.replica_set?
-end
-
-def collation_supported?
-  Mongoid::Clients.default.cluster.next_primary.features.collation_enabled?
-end
-alias :decimal128_supported? :collation_supported?
-
-def testing_locally?
-  !(ENV['CI'] == 'travis')
-end
-
-def array_filters_supported?
-  Mongoid::Clients.default.cluster.next_primary.features.array_filters_enabled?
-end
-alias :sessions_supported? :array_filters_supported?
-
 # 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/app/models.
+# 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")
   autoload name.camelize.to_sym, name
@@ -131,58 +124,60 @@ end
 
 I18n.config.enforce_available_locales = false
 
-RSpec.configure do |config|
-  config.expect_with(:rspec) do |c|
-    c.syntax = [:should, :expect]
-  end
+# 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)
+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
+ensure
+  client.close
+end
 
+RSpec.configure do |config|
   config.raise_errors_for_deprecations!
+  config.include(Helpers)
   config.include(Mongoid::Expectations)
+  config.extend(Mrss::Constraints)
   config.extend(Constraints)
+  config.extend(Mongoid::Macros)
 
   config.before(:suite) do
-    client = Mongo::Client.new(["#{HOST}:#{PORT}"])
-    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 Exception => e
-    end
+    Mongoid.purge!
   end
 
   # Drop all collections and clear the identity map before each spec.
   config.before(:each) do
-    Mongoid.purge!
+    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
   end
 end
 
 # A subscriber to be used with the Ruby driver for testing.
-#
-# @since 6.4.0
 class EventSubscriber
 
   # The started events.
-  #
-  # @since 6.4.0
   attr_reader :started_events
 
   # The succeeded events.
-  #
-  # @since 6.4.0
   attr_reader :succeeded_events
 
   # The failed events.
-  #
-  # @since 6.4.0
   attr_reader :failed_events
 
   # Create the test event subscriber.
   #
   # @example Create the subscriber
   #   EventSubscriber.new
-  #
-  # @since 6.4.0
   def initialize
     @started_events = []
     @succeeded_events = []
@@ -192,8 +187,6 @@ class EventSubscriber
   # Cache the succeeded event.
   #
   # @param [ Event ] event The event.
-  #
-  # @since 6.4.0
   def succeeded(event)
     @succeeded_events.push(event)
   end
@@ -201,8 +194,6 @@ class EventSubscriber
   # Cache the started event.
   #
   # @param [ Event ] event The event.
-  #
-  # @since 6.4.0
   def started(event)
     @started_events.push(event)
   end
@@ -210,15 +201,11 @@ class EventSubscriber
   # Cache the failed event.
   #
   # @param [ Event ] event The event.
-  #
-  # @since 6.4.0
   def failed(event)
     @failed_events.push(event)
   end
 
   # Clear all cached events.
-  #
-  # @since 6.4.0
   def clear_events!
     @started_events = []
     @succeeded_events = []

data/spec/support/authorization.rb

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

data/spec/support/client_registry.rb

@@ -0,0 +1,9 @@
+require 'singleton'
+
+class ClientRegistry
+  include Singleton
+
+  def global_client(name)
+    Mongoid.default_client
+  end
+end

data/spec/support/constraints.rb

@@ -1,100 +1,52 @@
+# frozen_string_literal: true
+
 module Constraints
   RAILS_VERSION = ActiveSupport.version.to_s.split('.')[0..1].join('.').freeze
 
-  def min_rails_version(version)
-    unless version =~ /^\d+\.\d+$/
-      raise ArgumentError, "Version can only be major.minor: #{version}"
-    end
-
-    before do
-      if version > RAILS_VERSION
-        skip "Rails version #{version} or higher required, we have #{RAILS_VERSION}"
+  def min_driver_version(version)
+    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
     end
   end
 
-  def max_rails_version(version)
-    unless version =~ /^\d+\.\d+$/
-      raise ArgumentError, "Version can only be major.minor: #{version}"
-    end
-
-    before do
-      if version < RAILS_VERSION
-        skip "Rails version #{version} or lower required, we have #{RAILS_VERSION}"
+  def max_driver_version(version)
+    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
     end
   end
 
-  def min_server_version(version)
-    unless version =~ /^\d+\.\d+$/
-      raise ArgumentError, "Version can only be major.minor: #{version}"
-    end
-
-    before do
-      if version > ClusterConfig.instance.server_version
-        skip "Server version #{version} or higher required, we have #{ClusterConfig.instance.server_version}"
-      end
-    end
+  def driver_version(precision)
+    Mongo::VERSION.split('.')[0...precision].map(&:to_i)
   end
 
-  def max_server_version(version)
-    unless version =~ /^\d+\.\d+$/
+  def min_rails_version(version)
+    unless version =~ /\A\d+\.\d+\z/
       raise ArgumentError, "Version can only be major.minor: #{version}"
     end
 
-    before do
-      if version < ClusterConfig.instance.short_server_version
-        skip "Server version #{version} or lower required, we have #{ClusterConfig.instance.server_version}"
-      end
-    end
-  end
-
-  def require_topology(*topologies)
-    topologies = topologies.map { |t| t.to_s }
-    invalid_topologies = topologies - %w(single replica_set sharded)
-    unless invalid_topologies.empty?
-      raise ArgumentError, "Invalid topologies requested: #{invalid_topologies.join(', ')}"
-    end
-    before do
-      topology = Mongoid.default_client.cluster.topology.class.name.sub(/.*::/, '')
-      topology = topology.gsub(/([A-Z])/) { |match| '_' + match.downcase }.sub(/^_/, '')
-      if topology =~ /^replica_set/
-        topology = 'replica_set'
-      end
-      unless topologies.include?(topology)
-        skip "Topology #{topologies.join(' or ')} required, we have #{topology}"
-      end
-    end
-  end
-
-  def max_example_run_time(timeout)
-    around do |example|
-      TimeoutInterrupt.timeout(timeout) do
-        example.run
+    before(:all) do
+      if version > RAILS_VERSION
+        skip "Rails version #{version} or higher required, we have #{RAILS_VERSION}"
       end
     end
   end
 
-  def require_transaction_support
-    min_server_version '4.0'
-    require_topology :replica_set
-  end
-
-  def require_scram_sha_256_support
-    before do
-      $mongo_server_features ||= begin
-        scanned_client_server!.features
-      end
-      unless $mongo_server_features.scram_sha_256_enabled?
-        skip "SCRAM SHA 256 is not enabled on the server"
-      end
+  def max_rails_version(version)
+    unless version =~ /\A\d+\.\d+\z/
+      raise ArgumentError, "Version can only be major.minor: #{version}"
     end
-  end
 
-  def require_ssl
-    before do
-      unless SpecConfig.instance.ssl?
-        skip "SSL not enabled"
+    before(:all) do
+      if version < RAILS_VERSION
+        skip "Rails version #{version} or lower required, we have #{RAILS_VERSION}"
       end
     end
   end

data/spec/support/expectations.rb

@@ -1,10 +1,28 @@
+# frozen_string_literal: true
+
 module Mongoid
   module Expectations
 
+    def connection_class
+      if defined?(Mongo::Server::ConnectionBase)
+        Mongo::Server::ConnectionBase
+      else
+        # Pre-2.8 drivers
+        Mongo::Server::Connection
+      end
+    end
+
     def expect_query(number)
-      # There are both start and complete events for each query.
-      expect(Mongo::Logger.logger).to receive(:debug?).exactly(number * 2).times.and_call_original
-      yield
+      rv = nil
+      RSpec::Mocks.with_temporary_scope do
+        if number > 0
+          expect_any_instance_of(connection_class).to receive(:command_started).exactly(number).times.and_call_original
+        else
+          expect_any_instance_of(connection_class).not_to receive(:command_started)
+        end
+        rv = yield
+      end
+      rv
     end
 
     def expect_no_queries(&block)

data/spec/support/helpers.rb

@@ -0,0 +1,11 @@
+module Helpers
+  # Reloads the specified model class.
+  #
+  # @param [ String | Symbol ] name Class name to reload.
+  def reload_model(name)
+    Object.class_eval do
+      remove_const(name)
+    end
+    load "spec/support/models/#{name.to_s.underscore}.rb"
+  end
+end

data/spec/support/macros.rb

@@ -16,5 +16,36 @@ module Mongoid
         end
       end
     end
+
+    def config_override(key, value)
+      around do |example|
+        existing = Mongoid.send(key)
+
+        Mongoid.send("#{key}=", value)
+
+        example.run
+
+        Mongoid.send("#{key}=", existing)
+      end
+    end
+
+    def with_config_values(key, *values, &block)
+      values.each do |value|
+        context "when #{key} is #{value}" do
+          config_override key, value
+
+          class_exec(value, &block)
+        end
+      end
+    end
+
+    def restore_config_clients
+      around do |example|
+        # Duplicate the config because some tests mutate it.
+        old_config = Mongoid::Config.clients.dup
+        example.run
+        Mongoid::Config.send(:clients=, old_config)
+      end
+    end
   end
 end

data/spec/support/models/account.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+class Account
+  include Mongoid::Document
+
+  field :_id, type: String, overwrite: true, default: ->{ name.try(:parameterize) }
+
+  field :number, type: String
+  field :balance, type: Integer
+  field :nickname, type: String
+  field :name, type: String
+  field :balanced, type: Mongoid::Boolean, default: ->{ balance? ? true : false }
+
+  field :overridden, type: String
+
+  embeds_many :memberships
+  belongs_to :creator, class_name: "User", foreign_key: :creator_id
+  belongs_to :person
+  has_many :alerts, autosave: false
+  has_and_belongs_to_many :agents
+  has_one :comment, validate: false
+
+  validates_presence_of :name
+  validates_presence_of :nickname, on: :upsert
+  validates_length_of :name, maximum: 10, on: :create
+
+  def overridden
+    self[:overridden] = "not recommended"
+  end
+
+  # MONGOID-3365
+  field :period_started_at, type: Time
+  has_many :consumption_periods, dependent: :destroy, validate: false
+
+  def current_consumption
+    consumption_periods.find_or_create_by(started_at: period_started_at)
+  end
+end

data/spec/support/models/acolyte.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+class Acolyte
+  include Mongoid::Document
+  include Mongoid::Attributes::Dynamic
+  field :status
+  field :name
+
+  embeds_many :versions, as: :memorable
+  belongs_to :church
+
+  default_scope ->{ asc(:name) }
+  scope :active, ->{ where(status: "active") }
+  scope :named, ->{ where(:name.exists => true) }
+
+  def callback_test?
+    name == "callback-test"
+  end
+end

data/spec/support/models/actor.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+class Actor
+  include Mongoid::Document
+  field :name
+  field :after_custom_count, type: Integer, default: 0
+  has_and_belongs_to_many :tags
+  embeds_many :things, validate: false, cascade_callbacks: true
+  accepts_nested_attributes_for :things, allow_destroy: true
+
+  define_model_callbacks :custom
+
+  def do_something
+    run_callbacks(:custom) do
+      self.name = "custom"
+    end
+  end
+end
+
+require "support/models/actress"

data/spec/support/models/actress.rb

@@ -0,0 +1,4 @@
+# frozen_string_literal: true
+
+class Actress < Actor
+end

data/spec/support/models/address.rb

@@ -0,0 +1,85 @@
+# frozen_string_literal: true
+
+class Address
+  include Mongoid::Document
+
+  field :_id, type: String, overwrite: true, default: ->{ street.try(:parameterize) }
+
+  attr_accessor :mode
+
+  field :address_type
+  field :number, type: Integer
+  field :no, type: Integer
+  field :h, as: :house, type: Integer
+  field :street
+  field :city
+  field :state
+  field :post_code
+  field :parent_title
+  field :services, type: Array
+  field :aliases, as: :a, type: Array
+  field :test, type: Array
+  field :latlng, type: Array
+  field :map, type: Hash
+  field :move_in, type: DateTime
+  field :end_date, type: Date
+  field :s, type: String, as: :suite
+  field :name, localize: true
+
+  embeds_many :locations, validate: false
+  embeds_one :code, validate: false
+  embeds_one :target, as: :targetable, validate: false
+
+  embedded_in :addressable, polymorphic: true do
+    def extension
+      "Testing"
+    end
+    def doctor?
+      title == "Dr"
+    end
+  end
+
+  accepts_nested_attributes_for :code, :target
+  accepts_nested_attributes_for :locations, allow_destroy: true
+
+  belongs_to :account
+  belongs_to :band
+
+  scope :without_postcode, ->{ where(postcode: nil) }
+  scope :ordered, ->{ order_by(state: 1) }
+  scope :without_postcode_ordered, ->{ without_postcode.ordered }
+  scope :rodeo, ->{ where(street: "Rodeo Dr") } do
+    def mansion?
+      all? { |address| address.street == "Rodeo Dr" }
+    end
+  end
+
+  validates_presence_of :street, on: :update
+  validates_format_of :street, with: /\D/, allow_nil: true
+
+  def set_parent=(set = false)
+    self.parent_title = addressable.title if set
+  end
+
+  def <=>(other)
+    street <=> other.street
+  end
+
+  class << self
+    def california
+      where(state: "CA")
+    end
+
+    def homes
+      where(address_type: "Home")
+    end
+
+    def streets
+      all.map(&:street)
+    end
+
+    def city_and_state(city:, state:)
+      where(city: city, state: state)
+    end
+  end
+end

data/spec/support/models/address_component.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+class AddressComponent
+  include Mongoid::Document
+  field :street, type: String
+  embedded_in :person
+end

data/spec/support/models/address_number.rb

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+class AddressNumber
+  include Mongoid::Document
+  field :country_code, type: Integer, default: 1
+  field :number
+  embedded_in :slave
+end

data/spec/support/models/agency.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+class Agency
+  include Mongoid::Document
+  include Mongoid::Timestamps::Updated
+  has_many :agents, validate: false
+end