shoulda-matchers 5.3.0 → 6.1.0

data/lib/shoulda/matchers/active_model/validate_numericality_of_matcher.rb

@@ -357,51 +357,33 @@ module Shoulda
       end
 
       # @private
-      class ValidateNumericalityOfMatcher
+      class ValidateNumericalityOfMatcher < ValidationMatcher
         NUMERIC_NAME = 'number'.freeze
         DEFAULT_DIFF_TO_COMPARE = 1
 
-        include Qualifiers::IgnoringInterferenceByWriter
-
         attr_reader :diff_to_compare
 
         def initialize(attribute)
           super
-          @attribute = attribute
           @submatchers = []
           @diff_to_compare = DEFAULT_DIFF_TO_COMPARE
-          @expects_custom_validation_message = false
           @expects_to_allow_nil = false
-          @expects_strict = false
           @allowed_type_adjective = nil
           @allowed_type_name = 'number'
-          @context = nil
-          @expected_message = nil
-        end
-
-        def strict
-          @expects_strict = true
-          self
-        end
 
-        def expects_strict?
-          @expects_strict
+          add_disallow_non_numeric_value_matcher
         end
 
         def only_integer
           prepare_submatcher(
-            NumericalityMatchers::OnlyIntegerMatcher.new(self, @attribute),
+            NumericalityMatchers::OnlyIntegerMatcher.new(self, attribute),
           )
           self
         end
 
         def allow_nil
           @expects_to_allow_nil = true
-          prepare_submatcher(
-            AllowValueMatcher.new(nil).
-              for(@attribute).
-              with_message(:not_a_number),
-          )
+          prepare_submatcher(allow_value_matcher(nil, :not_a_number))
           self
         end
 
@@ -411,70 +393,55 @@ module Shoulda
 
         def odd
           prepare_submatcher(
-            NumericalityMatchers::OddNumberMatcher.new(self, @attribute),
+            NumericalityMatchers::OddNumberMatcher.new(self, attribute),
           )
           self
         end
 
         def even
           prepare_submatcher(
-            NumericalityMatchers::EvenNumberMatcher.new(self, @attribute),
+            NumericalityMatchers::EvenNumberMatcher.new(self, attribute),
           )
           self
         end
 
         def is_greater_than(value)
-          prepare_submatcher(comparison_matcher_for(value, :>).for(@attribute))
+          prepare_submatcher(comparison_matcher_for(value, :>).for(attribute))
           self
         end
 
         def is_greater_than_or_equal_to(value)
-          prepare_submatcher(comparison_matcher_for(value, :>=).for(@attribute))
+          prepare_submatcher(comparison_matcher_for(value, :>=).for(attribute))
           self
         end
 
         def is_equal_to(value)
-          prepare_submatcher(comparison_matcher_for(value, :==).for(@attribute))
+          prepare_submatcher(comparison_matcher_for(value, :==).for(attribute))
           self
         end
 
         def is_less_than(value)
-          prepare_submatcher(comparison_matcher_for(value, :<).for(@attribute))
+          prepare_submatcher(comparison_matcher_for(value, :<).for(attribute))
           self
         end
 
         def is_less_than_or_equal_to(value)
-          prepare_submatcher(comparison_matcher_for(value, :<=).for(@attribute))
+          prepare_submatcher(comparison_matcher_for(value, :<=).for(attribute))
           self
         end
 
         def is_other_than(value)
-          prepare_submatcher(comparison_matcher_for(value, :!=).for(@attribute))
+          prepare_submatcher(comparison_matcher_for(value, :!=).for(attribute))
           self
         end
 
         def is_in(range)
           prepare_submatcher(
-            NumericalityMatchers::RangeMatcher.new(self, @attribute, range),
+            NumericalityMatchers::RangeMatcher.new(self, attribute, range),
           )
           self
         end
 
-        def with_message(message)
-          @expects_custom_validation_message = true
-          @expected_message = message
-          self
-        end
-
-        def expects_custom_validation_message?
-          @expects_custom_validation_message
-        end
-
-        def on(context)
-          @context = context
-          self
-        end
-
         def matches?(subject)
           matches_or_does_not_match?(subject)
           first_submatcher_that_fails_to_match.nil?
@@ -486,24 +453,18 @@ module Shoulda
         end
 
         def simple_description
-          description = ''
+          String.new.tap do |description|
+            description << "validate that :#{attribute} looks like "
+            description << Shoulda::Matchers::Util.a_or_an(full_allowed_type)
 
-          description << "validate that :#{@attribute} looks like "
-          description << Shoulda::Matchers::Util.a_or_an(full_allowed_type)
-
-          if range_description.present?
-            description << " #{range_description}"
-          end
+            if range_description.present?
+              description << " #{range_description}"
+            end
 
-          if comparison_descriptions.present?
-            description << " #{comparison_descriptions}"
+            if comparison_descriptions.present?
+              description << " #{comparison_descriptions}"
+            end
           end
-
-          description
-        end
-
-        def description
-          ValidationMatcher::BuildDescription.call(self, simple_description)
         end
 
         def failure_message
@@ -532,44 +493,29 @@ module Shoulda
           @subject = subject
           @number_of_submatchers = @submatchers.size
 
-          add_disallow_value_matcher
           qualify_submatchers
         end
 
-        def overall_failure_message
-          Shoulda::Matchers.word_wrap(
-            "Expected #{model.name} to #{description}, but this could not "\
-            'be proved.',
-          )
-        end
-
-        def overall_failure_message_when_negated
-          Shoulda::Matchers.word_wrap(
-            "Expected #{model.name} not to #{description}, but this could not "\
-            'be proved.',
-          )
-        end
-
         def attribute_is_active_record_column?
-          columns_hash.key?(@attribute.to_s)
+          columns_hash.key?(attribute.to_s)
         end
 
         def column_type
-          columns_hash[@attribute.to_s].type
+          columns_hash[attribute.to_s].type
         end
 
         def columns_hash
-          if @subject.class.respond_to?(:columns_hash)
-            @subject.class.columns_hash
+          if subject.class.respond_to?(:columns_hash)
+            subject.class.columns_hash
           else
             {}
           end
         end
 
-        def add_disallow_value_matcher
+        def add_disallow_non_numeric_value_matcher
           disallow_value_matcher = DisallowValueMatcher.
             new(non_numeric_value).
-            for(@attribute).
+            for(attribute).
             with_message(:not_a_number)
 
           add_submatcher(disallow_value_matcher)
@@ -581,9 +527,9 @@ module Shoulda
         end
 
         def comparison_matcher_for(value, operator)
-          NumericalityMatchers::ComparisonMatcher.
+          ComparisonMatcher.
             new(self, value, operator).
-            for(@attribute)
+            for(attribute)
         end
 
         def add_submatcher(submatcher)
@@ -615,8 +561,8 @@ module Shoulda
               submatcher.with_message(@expected_message)
             end
 
-            if @context
-              submatcher.on(@context)
+            if context
+              submatcher.on(context)
             end
 
             submatcher.ignoring_interference_by_writer(
@@ -634,23 +580,25 @@ module Shoulda
         end
 
         def has_been_qualified?
-          @submatchers.any? do |submatcher|
-            Shoulda::Matchers::RailsShim.parent_of(submatcher.class) ==
-              NumericalityMatchers
-          end
+          @submatchers.any? { |submatcher| submatcher_qualified?(submatcher) }
+        end
+
+        def submatcher_qualified?(submatcher)
+          Shoulda::Matchers::RailsShim.parent_of(submatcher.class) ==
+            NumericalityMatchers || submatcher.instance_of?(ComparisonMatcher)
         end
 
         def first_submatcher_that_fails_to_match
           @_first_submatcher_that_fails_to_match ||=
             @submatchers.detect do |submatcher|
-              !submatcher.matches?(@subject)
+              !submatcher.matches?(subject)
             end
         end
 
         def first_submatcher_that_fails_to_not_match
           @_first_submatcher_that_fails_to_not_match ||=
             @submatchers.detect do |submatcher|
-              !submatcher.does_not_match?(@subject)
+              !submatcher.does_not_match?(subject)
             end
         end
 
@@ -719,10 +667,6 @@ module Shoulda
           range_submatcher&.range_description
         end
 
-        def model
-          @subject.class
-        end
-
         def non_numeric_value
           'abcd'
         end

data/lib/shoulda/matchers/active_model/validation_matcher/build_description.rb

@@ -42,13 +42,12 @@ module Shoulda
             description_clauses = []
 
             if matcher.try(:expects_strict?)
-              description_clauses << 'raising a validation exception'
-
-              if matcher.try(:expects_custom_validation_message?)
-                description_clauses.last << ' with a custom message'
-              end
-
-              description_clauses.last << ' on failure'
+              description_clauses <<
+                if matcher.try(:expects_custom_validation_message?)
+                  'raising a validation exception with a custom message on failure'
+                else
+                  'raising a validation exception on failure'
+                end
             elsif matcher.try(:expects_custom_validation_message?)
               description_clauses <<
                 'producing a custom validation error on failure'

data/lib/shoulda/matchers/active_model/validation_matcher.rb

@@ -186,6 +186,12 @@ module Shoulda
         def blank_values
           ['', ' ', "\n", "\r", "\t", "\f"]
         end
+
+        def array_column?
+          @subject.class.respond_to?(:columns_hash) &&
+            @subject.class.columns_hash[@attribute.to_s].respond_to?(:array) &&
+            @subject.class.columns_hash[@attribute.to_s].array
+        end
       end
     end
   end

data/lib/shoulda/matchers/active_model/validator.rb

@@ -25,6 +25,10 @@ module Shoulda
           messages.any?
         end
 
+        def has_any_errors?
+          record.errors.any?
+        end
+
         def captured_validation_exception?
           @captured_validation_exception
         end

data/lib/shoulda/matchers/active_model.rb

@@ -21,8 +21,9 @@ require 'shoulda/matchers/active_model/validate_presence_of_matcher'
 require 'shoulda/matchers/active_model/validate_acceptance_of_matcher'
 require 'shoulda/matchers/active_model/validate_confirmation_of_matcher'
 require 'shoulda/matchers/active_model/validate_numericality_of_matcher'
+require 'shoulda/matchers/active_model/validate_comparison_of_matcher'
+require 'shoulda/matchers/active_model/comparison_matcher'
 require 'shoulda/matchers/active_model/numericality_matchers/numeric_type_matcher'
-require 'shoulda/matchers/active_model/numericality_matchers/comparison_matcher'
 require 'shoulda/matchers/active_model/numericality_matchers/odd_number_matcher'
 require 'shoulda/matchers/active_model/numericality_matchers/even_number_matcher'
 require 'shoulda/matchers/active_model/numericality_matchers/only_integer_matcher'

data/lib/shoulda/matchers/active_record/association_matcher.rb

@@ -1093,6 +1093,11 @@ module Shoulda
           self
         end
 
+        def with_query_constraints(query_constraints)
+          @options[:query_constraints] = query_constraints
+          self
+        end
+
         def required(required = true)
           remove_submatcher(AssociationMatchers::OptionalMatcher)
           add_submatcher(
@@ -1157,6 +1162,7 @@ module Shoulda
             (polymorphic? || class_exists?) &&
             foreign_key_exists? &&
             primary_key_exists? &&
+            query_constraints_exists? &&
             class_name_correct? &&
             join_table_correct? &&
             autosave_correct? &&
@@ -1258,7 +1264,7 @@ module Shoulda
           false
         end
 
-        def macro_supports_primary_key?
+        def macro_is_not_through?
           macro == :belongs_to ||
             ([:has_many, :has_one].include?(macro) && !through?)
         end
@@ -1268,7 +1274,25 @@ module Shoulda
         end
 
         def primary_key_exists?
-          !macro_supports_primary_key? || primary_key_correct?(model_class)
+          !macro_is_not_through? || primary_key_correct?(model_class)
+        end
+
+        def query_constraints_exists?
+          !macro_is_not_through? || query_constraints_correct?
+        end
+
+        def query_constraints_correct?
+          if options.key?(:query_constraints)
+            if option_verifier.correct_for_string?(:query_constraints, options[:query_constraints])
+              true
+            else
+              @missing = "#{model_class} should have \:query_constraints"\
+              " options set to #{options[:query_constraints]}"
+              false
+            end
+          else
+            true
+          end
         end
 
         def belongs_foreign_key_missing?
@@ -1299,10 +1323,7 @@ module Shoulda
         end
 
         def join_table_correct?
-          if (
-            macro != :has_and_belongs_to_many ||
-            join_table_matcher.matches?(@subject)
-          )
+          if macro != :has_and_belongs_to_many || join_table_matcher.matches?(@subject)
             true
           else
             @missing = join_table_matcher.failure_message
@@ -1457,11 +1478,10 @@ module Shoulda
         end
 
         def foreign_key_reflection
-          if (
-            [:has_one, :has_many].include?(macro) &&
-            reflection.options.include?(:inverse_of) &&
-            reflection.options[:inverse_of] != false
-          )
+          if [:has_one, :has_many].include?(macro) &&
+             reflection.options.include?(:inverse_of) &&
+             reflection.options[:inverse_of] != false
+
             associated_class.reflect_on_association(
               reflection.options[:inverse_of],
             )

data/lib/shoulda/matchers/active_record/association_matchers/optional_matcher.rb

@@ -22,44 +22,48 @@ module Shoulda
             if submatcher_passes?(subject)
               true
             else
-              @missing_option = 'and for the record '
+              @missing_option = build_missing_option
 
-              missing_option <<
+              false
+            end
+          end
+
+          private
+
+          attr_reader :attribute_name, :optional, :submatcher
+
+          def submatcher_passes?(subject)
+            if optional
+              submatcher.matches?(subject)
+            else
+              submatcher.does_not_match?(subject)
+            end
+          end
+
+          def build_missing_option
+            String.new('and for the record ').tap do |missing_option_string|
+              missing_option_string <<
                 if optional
                   'not to '
                 else
                   'to '
                 end
 
-              missing_option << (
+              missing_option_string << (
                 'fail validation if '\
                 ":#{attribute_name} is unset; i.e., either the association "\
                 'should have been defined with `optional: '\
                 "#{optional.inspect}`, or there "
               )
 
-              missing_option <<
+              missing_option_string <<
                 if optional
                   'should not '
                 else
                   'should '
                 end
 
-              missing_option << "be a presence validation on :#{attribute_name}"
-
-              false
-            end
-          end
-
-          private
-
-          attr_reader :attribute_name, :optional, :submatcher
-
-          def submatcher_passes?(subject)
-            if optional
-              submatcher.matches?(subject)
-            else
-              submatcher.does_not_match?(subject)
+              missing_option_string << "be a presence validation on :#{attribute_name}"
             end
           end
         end

data/lib/shoulda/matchers/active_record/association_matchers/required_matcher.rb

@@ -23,50 +23,54 @@ module Shoulda
             if submatcher_passes?(subject)
               true
             else
-              @missing_option = 'and for the record '
+              @missing_option = build_missing_option
 
-              missing_option <<
+              false
+            end
+          end
+
+          private
+
+          attr_reader :attribute_name, :required, :submatcher
+
+          def submatcher_passes?(subject)
+            if required
+              submatcher.matches?(subject)
+            else
+              submatcher.does_not_match?(subject)
+            end
+          end
+
+          def validation_message_key
+            :required
+          end
+
+          def build_missing_option
+            String.new('and for the record ').tap do |missing_option_string|
+              missing_option_string <<
                 if required
                   'to '
                 else
                   'not to '
                 end
 
-              missing_option << (
+              missing_option_string << (
                 'fail validation if '\
                 ":#{attribute_name} is unset; i.e., either the association "\
                 'should have been defined with `required: '\
                 "#{required.inspect}`, or there "
               )
 
-              missing_option <<
+              missing_option_string <<
                 if required
                   'should '
                 else
                   'should not '
                 end
 
-              missing_option << "be a presence validation on :#{attribute_name}"
-
-              false
+              missing_option_string << "be a presence validation on :#{attribute_name}"
             end
           end
-
-          private
-
-          attr_reader :attribute_name, :required, :submatcher
-
-          def submatcher_passes?(subject)
-            if required
-              submatcher.matches?(subject)
-            else
-              submatcher.does_not_match?(subject)
-            end
-          end
-
-          def validation_message_key
-            :required
-          end
         end
       end
     end

data/lib/shoulda/matchers/active_record/define_enum_for_matcher.rb

@@ -227,14 +227,6 @@ module Shoulda
           self
         end
 
-        def with(expected_enum_values)
-          Shoulda::Matchers.warn_about_deprecated_method(
-            'The `with` qualifier on `define_enum_for`',
-            '`with_values`',
-          )
-          with_values(expected_enum_values)
-        end
-
         def with_prefix(expected_prefix = true)
           options[:prefix] = expected_prefix
           self