mongoid-rspec 4.2.0 → 4.4.0

data/lib/matchers/validations/associated.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Mongoid
   module Matchers
     module Validations

data/lib/matchers/validations/confirmation_of.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Mongoid
   module Matchers
     module Validations

data/lib/matchers/validations/custom_validation_of.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Mongoid
   module Matchers
     module Validations
@@ -11,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 = []
-          options_desc << " with custom validator #{@custom_validator.name}" if @validator
-          "validate field #{@field.inspect}" << options_desc.to_sentence
+          options_desc = +"validate field #{@field.inspect}"
+          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

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Mongoid
   module Matchers
     module Validations
@@ -11,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
@@ -24,21 +34,15 @@ module Mongoid
 
             allowed_values = @not_allowed_values - validator_not_allowed_values
             if allowed_values.empty?
-              @positive_result_message = @positive_result_message << ' not allowing all values mentioned'
+              @positive_result_message << ' not allowing all values mentioned'
             else
-              @negative_result_message = @negative_result_message << " allowing the following the ff. values: #{allowed_values.inspect}"
+              @negative_result_message << " allowing the following the ff. values: #{allowed_values.inspect}"
               result = false
             end
           end
 
           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

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Mongoid
   module Matchers
     module Validations
@@ -21,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"
@@ -43,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"
@@ -53,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

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Mongoid
   module Matchers
     module Validations
@@ -11,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
@@ -33,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

@@ -1,9 +1,24 @@
+# frozen_string_literal: true
+
 module Mongoid
   module Matchers
     module Validations
       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)
@@ -30,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
@@ -104,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

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Mongoid
   module Matchers
     module Validations
@@ -36,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/presence_of.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Mongoid
   module Matchers
     module Validations

data/lib/matchers/validations/uniqueness_of.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Mongoid
   module Matchers
     module Validations
@@ -22,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
@@ -42,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'
@@ -51,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
@@ -61,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

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Mongoid
   module Matchers
     module Validations
@@ -11,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
-            @negative_result_message = "#{@type.inspect} validator on #{@field.inspect}"
-            @positive_result_message = "#{@type.inspect} validator on #{@field.inspect}"
+          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}"
+            @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
@@ -41,10 +41,9 @@ module Mongoid
         alias failure_message_when_negated failure_message_for_should_not
 
         def description
-          desc = "have #{@type.inspect} validator on #{@field.inspect}"
+          desc = +"have #{@type.inspect} validator on #{@field.inspect}"
           desc << " on #{@options[:on]}" if @options[:on]
           desc << " with message #{@expected_message.inspect}" if @expected_message
-
           desc
         end
 
@@ -58,40 +57,60 @@ module Mongoid
           self
         end
 
+        def check_conditions
+          @check_conditions = true
+          self
+        end
+
         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]
 
-          check_condition actual, validator.options[:if]
+          check_condition(actual, validator.options[:if])
         end
 
         def unless_condition_matches?(actual, validator)
+          return true unless @check_conditions
           return true unless validator.options[:unless]
 
-          !check_condition actual, validator.options[:unless]
+          !check_condition(actual, validator.options[:unless])
         end
 
         def check_condition(actual, filter)
-          raise ArgumentError, 'Spec subject must be object instance when testing validators with if/unless condition.' if actual.is_a?(Class)
+          raise ArgumentError, 'Spec subject must be an instance when using .check_conditions' if actual.is_a?(Class)
 
           case filter
           when Symbol
-            actual.send filter
+            actual.send(filter)
           when ::Proc
-            actual.instance_exec(&filter)
+            filter.arity.zero? ? actual.instance_exec(&filter) : filter.call(actual)
+          when Array
+            filter.all? { |f| check_condition(actual, f) }
           else
             raise ArgumentError, "Unexpected filter: #{filter.inspect}"
           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}"
+            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
@@ -108,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

@@ -1,5 +1,7 @@
+# frozen_string_literal: true
+
 module Mongoid
   module RSpec
-    VERSION = '4.2.0'.freeze
+    VERSION = '4.4.0'
   end
 end

data/lib/mongoid/rspec.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 $LOAD_PATH.unshift(File.dirname(__FILE__))
 
 require 'mongoid'
@@ -29,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'

data/lib/mongoid-rspec.rb

@@ -1 +1,3 @@
+# frozen_string_literal: true
+
 require 'mongoid/rspec'