mongoid-rspec 4.3.0 → 4.4.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 0ff9e91940ac839c482f01b93f825a4f30ed64dcf3f4210053a5cac6a490cbbc
-  data.tar.gz: 73b94988e7950e2097427412e1c4af87a1413cf891085a53a71924bbae9466ca
+  metadata.gz: 2ac3e47b3e606516f4ca239dad1405872db4cd012443a11a9e3c332d47555c27
+  data.tar.gz: 8b4d8baff373f7b2c6bc7e194a5a21192c08bdfda17e40693e300f9fd48a111b
 SHA512:
-  metadata.gz: 14504bfe14678c3c4df1eb85438438ab5b705f22ad36bc209bfd15d1bbeb4cc59ab09c0e8227682f8960f8db6cadc7c8731e8ab617d7f1d075e98f06a1085bdc
-  data.tar.gz: 4ae265834c188a9236e6c697345f70c5e16fc27c250076c72486030ae3ebc3cb62f1da00df5fefbf5bfd8dabb4e8dd29c26d80d26a1638e9a7e58d8824c2aa03
+  metadata.gz: 51157b3c68734d119c2880e7d071f52f244322bf517bfd8cab697d0e2f2e0662877b455acf704923dbed3f24034ab341c4c84ad6a9443230370052f805c6db0e
+  data.tar.gz: 0ed7c718a2862d4a1bb5abfd03e430dff67b1589612abbf50b2f449dd0584ecaff99b42b8e204e6281eab65f1b404b1bbf710da65550bd4fb369ef157395b241

data/README.md

@@ -44,6 +44,33 @@ RSpec.configure do |config|
 end
 ```
 
+### Using Mongoid and ActiveRecord with shoulda-matchers
+
+Both libraries define matcher names such as `validate_length_of` and `belong_to`, but their chain methods and implementations differ. In an application with both Mongoid and ActiveRecord models, include Mongoid matchers only for a custom `:mongoid_model` type instead of all `:model` examples. Keep Shoulda's ActiveModel and ActiveRecord matchers scoped to `:model`:
+
+```ruby
+require 'mongoid-rspec'
+require 'shoulda/matchers'
+
+RSpec.configure do |config|
+  config.include Mongoid::Matchers, type: :mongoid_model
+  config.include Shoulda::Matchers::ActiveModel, type: :model
+  config.include Shoulda::Matchers::ActiveRecord, type: :model
+end
+
+RSpec.describe MongoidAddress, type: :mongoid_model do
+  it { is_expected.to validate_length_of(:name).with_maximum(255) }
+  it { is_expected.to belong_to(:city).as_inverse_of(:addresses) }
+end
+
+RSpec.describe ActiveRecordAddress, type: :model do
+  it { is_expected.to validate_length_of(:name).is_at_most(255) }
+  it { is_expected.to belong_to(:city).inverse_of(:addresses) }
+end
+```
+
+Replace the existing unscoped or `type: :model` inclusion of `Mongoid::Matchers`; do not keep it alongside the scoped configuration. Explicitly tag Mongoid example groups with `type: :mongoid_model`, including those under `spec/models`, where rspec-rails would otherwise infer `:model`. Do not include Shoulda's model matcher modules globally or directly in those Mongoid groups. This avoids depending on module inclusion order and preserves each library's existing matcher API.
+
 ### Other
 
 Add to your `spec_helper.rb` file.
@@ -207,8 +234,74 @@ RSpec.describe Article, type: :model do
 end
 ```
 
+### execute_mongodb_command
+
+Use `execute_mongodb_command` with a block expectation to verify that code issues a MongoDB command. Without an argument, the matcher passes when any command is issued on the block's thread. An expected command matches the entire application command document exactly, not just a subset or query selector; nested String and Symbol keys are normalized to Strings. Driver-added top-level `$db`, `lsid`, and `$clusterTime` fields are excluded from comparison, while all other command fields and values must match. The matcher ignores unrelated background-thread activity and raises `NotImplementedError` when the driver does not expose command monitoring, including the legacy driver used with Mongoid 4.
+
+```ruby
+RSpec.describe FooService do
+  it 'uses the cached result without querying MongoDB' do
+    expect { FooService.recent_foos }.not_to execute_mongodb_command
+  end
+end
+
+RSpec.describe Article do
+  it 'executes the expected MongoDB command' do
+    expected_command = {
+      find: 'articles',
+      filter: { 'title.en' => 'cached' },
+      limit: 10,
+      sort: { created_at: -1 }
+    }
+
+    expect do
+      Article.where(title: 'cached').desc(:created_at).limit(10).to_a
+    end.to execute_mongodb_command(expected_command)
+  end
+end
+```
+
+### be_covered_query
+
+Check that MongoDB's winning plan uses an index without fetching documents:
+
+```ruby
+class Article
+  index({ title: 1, _id: 1 })
+end
+
+RSpec.describe Article do
+  it { expect(Article.where(title: 'Example').only(:title)).to be_covered_query }
+end
+```
+
+Mongoid includes `_id` in an inclusive projection by default, so the index must cover it as well. The matcher examines all stages in the winning plan, including nested shard plans, and rejects plans containing `FETCH` or `COLLSCAN`. A covered plan does not guarantee that a query is fast; this matcher checks plan coverage, not execution time.
+
+Use `.using_index('title_1__id_1')` or `.using_indexes('first_index', 'second_index')` to additionally require the exact set of index names used by the winning plan. Index names accept nonempty strings or symbols; order and repeated uses across shards do not matter. Rejected plans are ignored, and the query must still be covered.
+
+```ruby
+expect(Article.where(title: 'Example').only(:title)).to be_covered_query.using_index('title_1__id_1')
+```
+
 ### Field Matchers
 
+Chain `.readonly` to check fields declared with Mongoid's `attr_readonly`. This checks the declaration, not whether a new document currently allows writes. Like other field matcher options, it applies to every requested field and accepts class or instance subjects.
+
+```ruby
+class Article
+  include Mongoid::Document
+
+  field :slug, type: String
+  field :external_id, type: String
+  attr_readonly :slug, :external_id
+end
+
+RSpec.describe Article do
+  it { is_expected.to have_field(:slug).of_type(String).readonly }
+  it { is_expected.to have_fields(:slug, :external_id).readonly }
+end
+```
+
 ```ruby
 RSpec.describe Article do
   it { is_expected.to have_field(:published).of_type(Mongoid::Boolean).with_default_value_of(false) }
@@ -226,6 +319,31 @@ end
 
 ### Association Matchers
 
+Use `with_primary_key` to check an association's primary key, including the default `_id`. Like `with_foreign_key`, it accepts a symbol or string and can be chained with other association options:
+
+```ruby
+class Author
+  include Mongoid::Document
+
+  field :code, type: String
+  has_many :posts, primary_key: :code, foreign_key: :author_code
+end
+
+class Post
+  include Mongoid::Document
+
+  belongs_to :author, primary_key: :code, foreign_key: :author_code
+end
+
+RSpec.describe Author do
+  it { is_expected.to have_many(:posts).with_primary_key(:code).with_foreign_key(:author_code) }
+end
+
+RSpec.describe Post do
+  it { is_expected.to belong_to(:author).with_primary_key('code') }
+end
+```
+
 ```ruby
 RSpec.describe User do
   it { is_expected.to have_many(:articles).with_foreign_key(:author_id).ordered_by(:title) }
@@ -247,6 +365,8 @@ RSpec.describe User do
 
   it { is_expected.to have_and_belong_to_many(:children) }
   it { is_expected.to have_and_belong_to_many(:children).of_type(User) }
+  # nonconflicting alternative when using shoulda-matchers
+  it { is_expected.to have_and_belong_to_many_related(:children).of_type(User) }
 end
 
 RSpec.describe Profile do
@@ -300,6 +420,10 @@ end
 
 ### Validation Matchers
 
+`validate_length_of` searches all applicable length validators for one matching the requested options. For example, a maximum-length validator added by `has_secure_password` does not hide a separately declared minimum-length validator. Chained length, message, and `to_allow` options must match a single validator; options from separate validators are not combined.
+
+Use `validate_length_of(:name).within(1..100).to_allow(nil: true)` to check `allow_nil: true`, or `.to_allow(blank: true)` to check `allow_blank: true`. Both options can be combined, and the full keys `allow_nil` and `allow_blank` are also accepted. Values must be `true` or `false`; `false` requires an explicitly configured `false` (an omitted option does not match). Omitting `to_allow` leaves these options unchecked. Empty hashes, unknown keys, non-boolean values, and duplicate aliases are rejected with `ArgumentError`.
+
 ```ruby
 RSpec.describe Site do
   it { is_expected.to validate_presence_of(:name) }
@@ -396,6 +520,8 @@ end
 
 You're encouraged to contribute to this library. See [CONTRIBUTING](CONTRIBUTING.md) for details.
 
+`bundle exec rake` runs the unit suite without third-party integration dependencies. Each integration has its own Appraisal bundle and directory under `spec/integration/`. For example, run `BUNDLE_GEMFILE=gemfiles/shoulda_matchers.gemfile bundle install`, then `BUNDLE_GEMFILE=gemfiles/shoulda_matchers.gemfile bundle exec rspec spec/integration/shoulda_matchers`. To add an integration, define its dependencies in Appraisals, generate its gemfile, add its specs under a matching directory, and add its name to the integration matrix in `.github/workflows/rspec.yml`. CI runs each listed integration in a separate process and bundle.
+
 ## Copyright and License
 
 Copyright (c) 2009-2018 Evan Sagge and Contributors.

data/Rakefile

@@ -8,11 +8,11 @@ Bundler::GemHelper.install_tasks
 require 'rspec/core/rake_task'
 
 RSpec::Core::RakeTask.new(:spec) do |spec|
-  spec.pattern = './spec/**/*_spec.rb'
+  spec.pattern = './spec/unit/**/*_spec.rb'
 end
 
 RSpec::Core::RakeTask.new(:rcov) do |spec|
-  spec.pattern = './spec/**/*_spec.rb'
+  spec.pattern = './spec/unit/**/*_spec.rb'
   spec.rcov = true
 end
 

data/lib/matchers/associations.rb

@@ -115,6 +115,12 @@ module Mongoid
           self
         end
 
+        def with_primary_key(primary_key)
+          @association[:primary_key] = primary_key.to_s
+          @expectation_message << " using primary key #{@association[:primary_key].inspect}"
+          self
+        end
+
         def with_counter_cache
           @association[:counter_cache] = true
           @expectation_message << " which specifies counter_cache as #{@association[:counter_cache]}"
@@ -271,6 +277,15 @@ module Mongoid
             end
           end
 
+          if @association[:primary_key]
+            if metadata.primary_key != @association[:primary_key]
+              @negative_result_message = "#{@positive_result_message} with primary key #{metadata.primary_key.inspect}"
+              return false
+            else
+              @positive_result_message = "#{@positive_result_message} with primary key #{metadata.primary_key.inspect}"
+            end
+          end
+
           if @association[:counter_cache]
             if metadata.counter_cached? != true
               @negative_result_message = "#{@positive_result_message} which did not set counter_cache"
@@ -371,9 +386,10 @@ module Mongoid
       end
       alias have_many have_many_related
 
-      def have_and_belong_to_many(association_name)
+      def have_and_belong_to_many_related(association_name)
         HaveAssociationMatcher.new(association_name, HAS_AND_BELONGS_TO_MANY)
       end
+      alias have_and_belong_to_many have_and_belong_to_many_related
 
       def belong_to_related(association_name)
         HaveAssociationMatcher.new(association_name, BELONGS_TO)

data/lib/matchers/be_covered_query.rb

@@ -0,0 +1,75 @@
+# frozen_string_literal: true
+
+module Mongoid
+  module Matchers
+    def be_covered_query
+      BeCoveredQuery.new
+    end
+
+    class BeCoveredQuery
+      PLAN_CHILD_KEYS = %w[inputStage inputStages outerStage innerStage queryPlan winningPlan shards].freeze
+
+      def using_index(name)
+        using_indexes(name)
+      end
+
+      def using_indexes(*names)
+        raise ArgumentError, 'index names must be nonempty strings or symbols' unless names.any? && names.all? { |name| (name.is_a?(String) || name.is_a?(Symbol)) && !name.to_s.empty? }
+
+        @expected_indexes = names.map(&:to_s).uniq.sort
+        self
+      end
+
+      def matches?(actual)
+        @stages = []
+        @indexes = []
+        return false unless actual.respond_to?(:explain)
+
+        explain = actual.explain
+        planner = value_for(explain, :queryPlanner)
+        winning_plan = value_for(planner, :winningPlan)
+        return false unless winning_plan
+
+        collect_plan(winning_plan)
+        covered = @stages.include?('IXSCAN') && (@stages & %w[FETCH COLLSCAN]).empty?
+        covered && (!@expected_indexes || ((@indexes.uniq - @expected_indexes).empty? && (@expected_indexes - @indexes).empty?))
+      end
+
+      def description
+        desc = +'be a covered query'
+        desc << " using indexes #{@expected_indexes.inspect}" if @expected_indexes
+        desc
+      end
+
+      def failure_message
+        detail = @stages.empty? ? 'no winning plan was found' : "winning plan stages were #{@stages.inspect}"
+        detail += " and indexes were #{@indexes.uniq.inspect}" if @expected_indexes && @stages.any?
+        "Expected query to #{description}, but #{detail}"
+      end
+
+      def failure_message_when_negated
+        "Expected query not to #{description}"
+      end
+
+      private
+
+      def value_for(hash, key)
+        return unless hash.respond_to?(:[])
+
+        hash[key.to_s] || hash[key.to_sym]
+      end
+
+      def collect_plan(plan)
+        case plan
+        when Hash
+          stage = value_for(plan, :stage)
+          @stages << stage.to_s if stage
+          @indexes << value_for(plan, :indexName) if stage.to_s == 'IXSCAN'
+          PLAN_CHILD_KEYS.each { |key| collect_plan(value_for(plan, key)) }
+        when Array
+          plan.each { |value| collect_plan(value) }
+        end
+      end
+    end
+  end
+end

data/lib/matchers/execute_mongodb_command.rb

@@ -0,0 +1,127 @@
+# frozen_string_literal: true
+
+module Mongoid
+  module Matchers
+    def execute_mongodb_command(*expected_commands)
+      raise ArgumentError, 'execute_mongodb_command accepts at most one command' if expected_commands.length > 1
+
+      if expected_commands.empty?
+        ExecuteMongodbCommand.new
+      else
+        ExecuteMongodbCommand.new(expected_commands.first)
+      end
+    end
+
+    class ExecuteMongodbCommand
+      DRIVER_METADATA_KEYS = %w[$db lsid $clusterTime].freeze
+      UNSPECIFIED = Object.new.freeze
+
+      def initialize(expected_command = UNSPECIFIED)
+        @expected_command = expected_command.equal?(UNSPECIFIED) ? nil : normalize_command(expected_command)
+      end
+
+      def supports_block_expectations?
+        true
+      end
+
+      def matches?(block)
+        raise ArgumentError, 'execute_mongodb_command expects a block' unless block
+        raise NotImplementedError, 'execute_mongodb_command requires MongoDB driver command monitoring' unless
+          defined?(Mongo::Monitoring::Global) && defined?(Mongo::Monitoring::COMMAND)
+        raise NotImplementedError, 'execute_mongodb_command requires the Mongoid client registry' unless
+          defined?(Mongoid::Clients) && Mongoid::Clients.respond_to?(:clients)
+
+        @command_executed = false
+        topic = Mongo::Monitoring::COMMAND
+        global_monitor = Mongo::Monitoring::Global
+        subscriber = CommandSubscriber.new(Thread.current, @expected_command, method(:normalize_command)) do
+          @command_executed = true
+        end
+        clients = mongoid_clients
+        subscribed = false
+
+        begin
+          clients.each { |client| client.subscribe(topic, subscriber) }
+          global_monitor.subscribe(topic, subscriber)
+          subscribed = true
+          block.call
+        ensure
+          current_clients = mongoid_clients
+          global_monitor.unsubscribe(topic, subscriber) if subscribed
+          (clients + current_clients).uniq.each { |client| client.unsubscribe(topic, subscriber) }
+        end
+
+        @command_executed
+      end
+
+      def failure_message
+        message = +'Expected block to execute a MongoDB command'
+        message << " matching #{@expected_command.inspect}" if @expected_command
+        message
+      end
+
+      def failure_message_when_negated
+        message = +'Expected block not to execute a MongoDB command'
+        message << " matching #{@expected_command.inspect}" if @expected_command
+        message
+      end
+
+      private
+
+      def normalize_command(command)
+        raise ArgumentError, 'expected MongoDB command must be a non-empty Hash' unless command.is_a?(Hash) && !command.empty?
+
+        normalize_document(command, top_level: true)
+      end
+
+      def normalize_document(document, top_level: false)
+        document.each_with_object({}) do |(key, value), normalized|
+          normalized_key = normalize_key(key)
+          next if top_level && DRIVER_METADATA_KEYS.include?(normalized_key)
+          raise ArgumentError, "duplicate MongoDB command key after normalization: #{normalized_key.inspect}" if normalized.key?(normalized_key)
+
+          normalized[normalized_key] = normalize_value(value)
+        end
+      end
+
+      def normalize_key(key)
+        return key if key.is_a?(String)
+        return key.to_s if key.is_a?(Symbol)
+
+        raise ArgumentError, "MongoDB command keys must be Strings or Symbols, got #{key.class}"
+      end
+
+      def normalize_value(value)
+        case value
+        when Hash then normalize_document(value)
+        when Array then value.map { |item| normalize_value(item) }
+        else value
+        end
+      end
+
+      def mongoid_clients
+        Mongoid::Clients.clients.values
+      end
+
+      class CommandSubscriber
+        def initialize(thread, expected_command, normalizer, &on_command)
+          @thread = thread
+          @expected_command = expected_command
+          @normalizer = normalizer
+          @on_command = on_command
+        end
+
+        def started(event)
+          return unless Thread.current.equal?(@thread)
+
+          command = @normalizer.call(event.command)
+          @on_command.call if @expected_command.nil? || command == @expected_command
+        end
+
+        def succeeded(_event); end
+
+        def failed(_event); end
+      end
+    end
+  end
+end

data/lib/matchers/have_field.rb

@@ -12,6 +12,11 @@ module Mongoid
         self
       end
 
+      def readonly
+        @readonly = true
+        self
+      end
+
       def of_type(type)
         @type = type
         self
@@ -49,6 +54,10 @@ module Mongoid
               error << " with alias #{@klass.fields[attr].options[:as]}"
             end
 
+            if @readonly && !@klass.readonly_attributes.include?(attr)
+              error << ' that is not readonly'
+            end
+
             @errors.push("field #{attr.inspect}#{error}") unless error.blank?
 
             if @localized
@@ -80,6 +89,7 @@ module Mongoid
         desc << " of type #{@type.inspect}" if @type
         desc << " with alias #{@field_alias}" if @field_alias
         desc << " with default value of #{@default.inspect}" unless @default.nil?
+        desc << ' marked readonly' if @readonly
         desc
       end
     end

data/lib/matchers/validations/custom_validation_of.rb

@@ -13,23 +13,23 @@ module Mongoid
           self
         end
 
-        def matches?(actual)
-          return false unless (@result = super(actual))
-          check_custom_validator if @custom_validator
-
-          @result
-        end
-
         def description
           options_desc = +"validate field #{@field.inspect}"
-          options_desc << " with custom validator #{@custom_validator.name}" if @validator
+          options_desc << " with custom validator #{@custom_validator.name}" if @custom_validator
           options_desc
         end
 
         private
 
-        def check_custom_validator
-          if @validator.is_a? @custom_validator
+        def check_validator(actual, validator)
+          return false unless (@result = super)
+          check_custom_validator(validator) if @custom_validator
+
+          @result
+        end
+
+        def check_custom_validator(validator)
+          if validator.is_a? @custom_validator
             @positive_result_message << " with custom validator of type #{@custom_validator.name}"
           else
             @negative_result_message << " with custom validator not of type #{@custom_validator.name}"

data/lib/matchers/validations/exclusion_of.rb

@@ -13,11 +13,19 @@ module Mongoid
           self
         end
 
-        def matches?(actual)
-          return false unless (result = super(actual))
+        def description
+          options_desc = []
+          options_desc << " not allowing the ff. values: #{@not_allowed_values}" if @not_allowed_values
+          super << options_desc.to_sentence
+        end
+
+        private
+
+        def check_validator(actual, validator)
+          return false unless (result = super)
 
           if @not_allowed_values
-            raw_validator_not_allowed_values = @validator.options[:in]
+            raw_validator_not_allowed_values = validator.options[:in]
 
             validator_not_allowed_values = case raw_validator_not_allowed_values
                                            when Range then raw_validator_not_allowed_values.to_a
@@ -35,12 +43,6 @@ module Mongoid
 
           result
         end
-
-        def description
-          options_desc = []
-          options_desc << " not allowing the ff. values: #{@not_allowed_values}" if @not_allowed_values
-          super << options_desc.to_sentence
-        end
       end
 
       def validate_exclusion_of(field)

data/lib/matchers/validations/format_of.rb

@@ -23,20 +23,30 @@ module Mongoid
           self
         end
 
-        def matches?(actual)
-          return false unless result = super(actual)
+        def description
+          options_desc = []
+          options_desc << " with format #{@format.inspect}" if @format
+          options_desc << " allowing the value #{@valid_value.inspect}" if @valid_value
+          options_desc << " not allowing the value #{@invalid_value.inspect}" if @invalid_value
+          super << options_desc.to_sentence
+        end
+
+        private
+
+        def check_validator(actual, validator)
+          return false unless result = super
 
           if @format
-            if @validator.options[:with] == @format
-              @positive_result_message = @positive_result_message << " with format #{@validator.options[:format].inspect}"
+            if validator.options[:with] == @format
+              @positive_result_message = @positive_result_message << " with format #{validator.options[:format].inspect}"
             else
-              @negative_result_message = @negative_result_message << " with format #{@validator.options[:format].inspect}"
+              @negative_result_message = @negative_result_message << " with format #{validator.options[:format].inspect}"
               result = false
             end
           end
 
           if @valid_value
-            if @validator.options[:with] =~ @valid_value
+            if validator.options[:with] =~ @valid_value
               @positive_result_message = @positive_result_message << " with #{@valid_value.inspect} as a valid value"
             else
               @negative_result_message = @negative_result_message << " with #{@valid_value.inspect} as an invalid value"
@@ -45,7 +55,7 @@ module Mongoid
           end
 
           if @invalid_value
-            if @invalid_value !~ @validator.options[:with]
+            if @invalid_value !~ validator.options[:with]
               @positive_result_message = @positive_result_message << " with #{@invalid_value.inspect} as an invalid value"
             else
               @negative_result_message = @negative_result_message << " with #{@invalid_value.inspect} as a valid value"
@@ -55,14 +65,6 @@ module Mongoid
 
           result
         end
-
-        def description
-          options_desc = []
-          options_desc << " with format #{@format.inspect}" if @format
-          options_desc << " allowing the value #{@valid_value.inspect}" if @valid_value
-          options_desc << " not allowing the value #{@invalid_value.inspect}" if @invalid_value
-          super << options_desc.to_sentence
-        end
       end
 
       def validate_format_of(field)

data/lib/matchers/validations/inclusion_of.rb

@@ -13,11 +13,19 @@ module Mongoid
           self
         end
 
-        def matches?(actual)
-          return false unless result = super(actual)
+        def description
+          options_desc = []
+          options_desc << " allowing these values: #{@allowed_values}" if @allowed_values
+          super << options_desc.to_sentence
+        end
+
+        private
+
+        def check_validator(actual, validator)
+          return false unless result = super
 
           if @allowed_values
-            raw_validator_allowed_values = @validator.options[:in]
+            raw_validator_allowed_values = validator.options[:in]
 
             validator_allowed_values = case raw_validator_allowed_values
                                        when Range then raw_validator_allowed_values.to_a
@@ -35,12 +43,6 @@ module Mongoid
 
           result
         end
-
-        def description
-          options_desc = []
-          options_desc << " allowing these values: #{@allowed_values}" if @allowed_values
-          super << options_desc.to_sentence
-        end
       end
 
       def validate_inclusion_of(field)

data/lib/matchers/validations/length_of.rb

@@ -6,6 +6,19 @@ module Mongoid
       class ValidateLengthOfMatcher < HaveValidationMatcher
         def initialize(name)
           super(name, :length)
+          @allowed_options = {}
+        end
+
+        def to_allow(options)
+          aliases = { nil: :allow_nil, blank: :allow_blank, allow_nil: :allow_nil, allow_blank: :allow_blank }
+          unless options.is_a?(Hash) && options.any? &&
+                 options.all? { |key, value| aliases.key?(key) && (value.equal?(true) || value.equal?(false)) } &&
+                 options.keys.map { |key| aliases[key] }.uniq.size == options.size
+            raise ArgumentError, 'validate_length_of#to_allow requires a non-empty Hash of nil, blank, allow_nil, or allow_blank keys with boolean values and no duplicate aliases'
+          end
+
+          options.each { |key, value| @allowed_options[aliases[key]] = value }
+          self
         end
 
         def with_maximum(value)
@@ -32,72 +45,102 @@ module Mongoid
         end
         alias is as_exactly
 
-        def matches?(actual)
-          return false unless @result = super(actual)
-
-          check_maximum if @maximum
-          check_minimum if @minimum
-          check_range if @within
-          check_exact if @is
-
-          @result
-        end
-
         def description
           options_desc = []
           options_desc << "with minimum of #{@minimum}" if @minimum
           options_desc << "with maximum of #{@maximum}" if @maximum
           options_desc << "within the range of #{@within}" if @within
           options_desc << "as exactly #{@is}" if @is
+          @allowed_options.each { |key, value| options_desc << "with #{key} #{value.inspect}" }
           super << " #{options_desc.to_sentence}"
         end
 
         private
 
-        def check_maximum
-          if actual_max.nil?
+        def check_validator(actual, validator)
+          return false unless @result = super
+
+          check_maximum(validator) if @maximum
+          check_minimum(validator) if @minimum
+          check_range(validator) if @within
+          check_exact(validator) if @is
+          check_allowed_options(validator)
+
+          @result
+        end
+
+        def select_validator(validators)
+          validators.detect do |validator|
+            (!@minimum || actual_min(validator) == @minimum) &&
+              (!@maximum || actual_max(validator) == @maximum) &&
+              (!@within || @within.minmax == [actual_min(validator), actual_max(validator)]) &&
+              (!@is || validator.options[:is] == @is) &&
+              (!@expected_message || validator.options[:message] == @expected_message) &&
+              @allowed_options.all? { |key, value| validator.options[key] == value }
+          end || super
+        end
+
+        def check_allowed_options(validator)
+          @allowed_options.each do |key, value|
+            actual_value = validator.options[key]
+            if actual_value == value
+              @positive_result_message << " with #{key} #{value.inspect}"
+            else
+              @negative_result_message << " with #{key} #{actual_value.inspect}"
+              @result = false
+            end
+          end
+        end
+
+        def check_maximum(validator)
+          maximum = actual_max(validator)
+          if maximum.nil?
             @negative_result_message << ' with no maximum'
             @result = false
-          elsif actual_max == @maximum
+          elsif maximum == @maximum
             @positive_result_message << " with maximum of #{@maximum}"
           else
-            @negative_result_message << " with maximum of #{actual_max}"
+            @negative_result_message << " with maximum of #{maximum}"
             @result = false
           end
         end
 
-        def check_minimum
-          if actual_min.nil?
+        def check_minimum(validator)
+          minimum = actual_min(validator)
+          if minimum.nil?
             @negative_result_message << ' with no minimum'
             @result = false
-          elsif actual_min == @minimum
+          elsif minimum == @minimum
             @positive_result_message << " with minimum of #{@minimum}"
           else
-            @negative_result_message << " with minimum of #{actual_min}"
+            @negative_result_message << " with minimum of #{minimum}"
             @result = false
           end
         end
 
-        def check_range
+        def check_range(validator)
           min, max = @within.minmax
-          if !actual_min.nil? && actual_max.nil?
-            @negative_result_message << " with no minimum but with maximum of #{actual_max}"
+          minimum = actual_min(validator)
+          maximum = actual_max(validator)
+          if !minimum.nil? && maximum.nil?
+            @negative_result_message << " with no minimum but with maximum of #{maximum}"
             @result = false
-          elsif actual_min.nil? && !actual_max.nil?
-            @negative_result_message << " with minimum_of #{actual_min} but no maximum"
+          elsif minimum.nil? && !maximum.nil?
+            @negative_result_message << " with minimum_of #{minimum} but no maximum"
             @result = false
-          elsif actual_min.nil? && actual_max.nil?
+          elsif minimum.nil? && maximum.nil?
             @negative_result_message << ' with no minimum and maximum'
             @result = false
-          elsif actual_min == min && actual_max == max
+          elsif minimum == min && maximum == max
             @positive_result_message << " within the range of #{@within.inspect}"
           else
-            @negative_result_message << " within the range of #{(actual_min..actual_max).inspect}"
+            @negative_result_message << " within the range of #{(minimum..maximum).inspect}"
             @result = false
           end
         end
 
-        def check_exact
+        def check_exact(validator)
+          actual_is = validator.options[:is]
           if actual_is == @is
             @positive_result_message << " as exactly #{@is}"
           else
@@ -106,16 +149,12 @@ module Mongoid
           end
         end
 
-        def actual_is
-          actual_is = @validator.options[:is]
-        end
-
-        def actual_min
-          @validator.options[:minimum] || (@validator.options[:in] || @validator.options[:within]).try(&:min)
+        def actual_min(validator)
+          validator.options[:minimum] || (validator.options[:in] || validator.options[:within]).try(&:min)
         end
 
-        def actual_max
-          @validator.options[:maximum] || (@validator.options[:in] || @validator.options[:within]).try(&:max)
+        def actual_max(validator)
+          validator.options[:maximum] || (validator.options[:in] || validator.options[:within]).try(&:max)
         end
       end
 

data/lib/matchers/validations/numericality_of.rb

@@ -38,24 +38,24 @@ module Mongoid
           self
         end
 
-        def matches?(actual)
-          return false unless result = super(actual)
+        def description
+          super << options_message(@options)
+        end
+
+        protected
+
+        def check_validator(actual, validator)
+          return false unless result = super
 
           @options.each do |comparator, expected_value|
-            result &= (@validator.options[comparator] == expected_value)
+            result &= (validator.options[comparator] == expected_value)
           end
 
-          @positive_result_message <<= options_message(@validator.options)
-          @negative_result_message <<= options_message(@validator.options)
+          @positive_result_message <<= options_message(validator.options)
+          @negative_result_message <<= options_message(validator.options)
           result
         end
 
-        def description
-          super << options_message(@options)
-        end
-
-        protected
-
         def options_message(options)
           type_msg = []
           comp_msg = []

data/lib/matchers/validations/uniqueness_of.rb

@@ -24,16 +24,6 @@ module Mongoid
           self
         end
 
-        def matches?(actual)
-          return false unless @result = super(actual)
-
-          check_scope if @scope
-          check_allow_blank if @allow_blank
-          check_case_sensitivity if @case_insensitive
-
-          @result
-        end
-
         def description
           options_desc = []
           options_desc << " scoped to #{@scope.inspect}" if @scope
@@ -44,8 +34,18 @@ module Mongoid
 
         private
 
-        def check_allow_blank
-          if @validator.options[:allow_blank] == @allow_blank
+        def check_validator(actual, validator)
+          return false unless @result = super
+
+          check_scope(validator) if @scope
+          check_allow_blank(validator) if @allow_blank
+          check_case_sensitivity(validator) if @case_insensitive
+
+          @result
+        end
+
+        def check_allow_blank(validator)
+          if validator.options[:allow_blank] == @allow_blank
             @positive_result_message << ' with blank values allowed'
           else
             @negative_result_message << ' with no blank values allowed'
@@ -53,9 +53,9 @@ module Mongoid
           end
         end
 
-        def check_scope
-          message = " scope to #{@validator.options[:scope]}"
-          if [@validator.options[:scope]].flatten.map(&:to_sym) == @scope
+        def check_scope(validator)
+          message = " scope to #{validator.options[:scope]}"
+          if [validator.options[:scope]].flatten.map(&:to_sym) == @scope
             @positive_result_message << message
           else
             @negative_result_message << message
@@ -63,8 +63,8 @@ module Mongoid
           end
         end
 
-        def check_case_sensitivity
-          if @validator.options[:case_sensitive] == false
+        def check_case_sensitivity(validator)
+          if validator.options[:case_sensitive] == false
             @positive_result_message << ' with case insensitive values'
           else
             @negative_result_message << ' without case insensitive values'

data/lib/matchers/validations.rb

@@ -13,22 +13,20 @@ module Mongoid
         def matches?(actual)
           @klass = actual.is_a?(Class) ? actual : actual.class
 
-          @validator = @klass.validators_on(@field).detect do |v|
+          validators = @klass.validators_on(@field).lazy.select do |v|
             (v.kind.to_s == @type) && (!v.options[:on] || on_options_matches?(v)) &&
               if_condition_matches?(actual, v) && unless_condition_matches?(actual, v)
           end
+          validator = select_validator(validators)
 
-          if @validator
+          if validator
             @negative_result_message = +"#{@type.inspect} validator on #{@field.inspect}"
             @positive_result_message = +"#{@type.inspect} validator on #{@field.inspect}"
           else
             @negative_result_message = +"no #{@type.inspect} validator on #{@field.inspect}"
             return false
           end
-          @result = true
-          check_on if @options[:on]
-          check_expected_message if @expected_message
-          @result
+          check_validator(actual, validator)
         end
 
         def failure_message_for_should
@@ -66,6 +64,17 @@ module Mongoid
 
         private
 
+        def check_validator(_actual, validator)
+          @result = true
+          check_on(validator) if @options[:on]
+          check_expected_message(validator) if @expected_message
+          @result
+        end
+
+        def select_validator(validators)
+          validators.first
+        end
+
         def if_condition_matches?(actual, validator)
           return true unless @check_conditions
           return true unless validator.options[:if]
@@ -95,13 +104,13 @@ module Mongoid
           end
         end
 
-        def check_on
-          validator_on_methods = [@validator.options[:on]].flatten
+        def check_on(validator)
+          validator_on_methods = [validator.options[:on]].flatten
 
           if validator_on_methods.any?
             message = +" on methods: #{validator_on_methods}"
 
-            if on_options_covered_by?(@validator)
+            if on_options_covered_by?(validator)
               @positive_result_message << message
             else
               @negative_result_message << message
@@ -118,8 +127,8 @@ module Mongoid
           ([@options[:on]].flatten - [validator.options[:on]].flatten).empty?
         end
 
-        def check_expected_message
-          actual_message = @validator.options[:message]
+        def check_expected_message(validator)
+          actual_message = validator.options[:message]
           if actual_message.nil?
             @negative_result_message << ' with no custom message'
             @result = false

data/lib/mongoid/rspec/version.rb

@@ -2,6 +2,6 @@
 
 module Mongoid
   module RSpec
-    VERSION = '4.3.0'
+    VERSION = '4.4.0'
   end
 end

data/lib/mongoid/rspec.rb

@@ -31,7 +31,9 @@ require 'matchers/validations/absence_of'
 require 'matchers/be_mongoid_document'
 require 'matchers/be_dynamic_document'
 require 'matchers/be_stored_in'
+require 'matchers/be_covered_query'
 require 'matchers/have_field'
+require 'matchers/execute_mongodb_command'
 require 'matchers/indexes/have_index_for'
 if Mongoid::Compatibility::Version.mongoid3?
   require 'matchers/indexes/v3/have_index_for'

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: mongoid-rspec
 version: !ruby/object:Gem::Version
-  version: 4.3.0
+  version: 4.4.0
 platform: ruby
 authors:
 - Evan Sagge
@@ -142,9 +142,11 @@ files:
 - lib/matchers/accept_nested_attributes.rb
 - lib/matchers/allow_mass_assignment.rb
 - lib/matchers/associations.rb
+- lib/matchers/be_covered_query.rb
 - lib/matchers/be_dynamic_document.rb
 - lib/matchers/be_mongoid_document.rb
 - lib/matchers/be_stored_in.rb
+- lib/matchers/execute_mongodb_command.rb
 - lib/matchers/have_field.rb
 - lib/matchers/have_timestamps.rb
 - lib/matchers/indexes/have_index_for.rb