shoulda-matchers 5.1.0 → 6.4.0

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

@@ -3,7 +3,7 @@ module Shoulda
     module ActiveModel
       # The `validate_length_of` matcher tests usage of the
       # `validates_length_of` matcher. Note that this matcher is intended to be
-      # used against string columns and not integer columns.
+      # used against string columns and associations and not integer columns.
       #
       # #### Qualifiers
       #
@@ -36,7 +36,8 @@ module Shoulda
       #
       # Use `is_at_least` to test usage of the `:minimum` option. This asserts
       # that the attribute can take a string which is equal to or longer than
-      # the given length and cannot take a string which is shorter.
+      # the given length and cannot take a string which is shorter. This qualifier
+      # also works for associations.
       #
       #     class User
       #       include ActiveModel::Model
@@ -61,7 +62,8 @@ module Shoulda
       #
       # Use `is_at_most` to test usage of the `:maximum` option. This asserts
       # that the attribute can take a string which is equal to or shorter than
-      # the given length and cannot take a string which is longer.
+      # the given length and cannot take a string which is longer. This qualifier
+      # also works for associations.
       #
       #     class User
       #       include ActiveModel::Model
@@ -84,7 +86,8 @@ module Shoulda
       #
       # Use `is_equal_to` to test usage of the `:is` option. This asserts that
       # the attribute can take a string which is exactly equal to the given
-      # length and cannot take a string which is shorter or longer.
+      # length and cannot take a string which is shorter or longer. This qualifier
+      # also works for associations.
       #
       #     class User
       #       include ActiveModel::Model
@@ -106,7 +109,7 @@ module Shoulda
       # ##### is_at_least + is_at_most
       #
       # Use `is_at_least` and `is_at_most` together to test usage of the `:in`
-      # option.
+      # option. This qualifies also works for associations.
       #
       #     class User
       #       include ActiveModel::Model
@@ -239,7 +242,7 @@ module Shoulda
       #
       # @return [ValidateLengthOfMatcher]
       #
-      # # ##### allow_blank
+      # ##### allow_blank
       #
       # Use `allow_blank` to assert that the attribute allows blank.
       #
@@ -260,6 +263,29 @@ module Shoulda
       #       should validate_length_of(:bio).is_at_least(15).allow_blank
       #     end
       #
+      # ##### as_array
+      #
+      # Use `as_array` if you have an ActiveModel model and the attribute being validated
+      # is designed to store an array. (This is not necessary if you have an ActiveRecord
+      # model with an array column, as the matcher will detect this automatically.)
+      #
+      #     class User
+      #       include ActiveModel::Model
+      #       attribute :arr, array: true
+      #
+      #       validates_length_of :arr, minimum: 15
+      #     end
+      #
+      #     # RSpec
+      #     describe User do
+      #       it { should validate_length_of(:arr).as_array.is_at_least(15) }
+      #     end
+      #
+      #     # Minitest (Shoulda)
+      #     class UserTest < ActiveSupport::TestCase
+      #       should validate_length_of(:arr).as_array.is_at_least(15)
+      #     end
+      #
       def validate_length_of(attr)
         ValidateLengthOfMatcher.new(attr)
       end
@@ -275,6 +301,11 @@ module Shoulda
           @long_message = nil
         end
 
+        def as_array
+          @options[:array] = true
+          self
+        end
+
         def is_at_least(length)
           @options[:minimum] = length
           @short_message ||= :too_short
@@ -451,15 +482,39 @@ module Shoulda
         end
 
         def allows_length_of?(length, message)
-          allows_value_of(string_of_length(length), message)
+          allows_value_of(value_of_length(length), message)
         end
 
         def disallows_length_of?(length, message)
-          disallows_value_of(string_of_length(length), message)
+          disallows_value_of(value_of_length(length), message)
+        end
+
+        def value_of_length(length)
+          if array_column?
+            ['x'] * length
+          elsif collection_association?
+            Array.new(length) { association_reflection.klass.new }
+          else
+            'x' * length
+          end
+        end
+
+        def array_column?
+          @options[:array] || super
+        end
+
+        def collection_association?
+          association? && [:has_many, :has_and_belongs_to_many].include?(
+            association_reflection.macro,
+          )
+        end
+
+        def association?
+          association_reflection.present?
         end
 
-        def string_of_length(length)
-          'x' * length
+        def association_reflection
+          model.try(:reflect_on_association, @attribute)
         end
 
         def translated_short_message

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

@@ -276,6 +276,33 @@ module Shoulda
       #       should validate_numericality_of(:birth_day).odd
       #     end
       #
+      # ##### is_in
+      #
+      # Use `is_in` to test usage of the `:in` option.
+      # This asserts that the attribute can take a number which is contained
+      # in the given range.
+      #
+      #     class Person
+      #       include ActiveModel::Model
+      #       attr_accessor :legal_age
+      #
+      #       validates_numericality_of :birth_month, in: 1..12
+      #     end
+      #
+      #     # RSpec
+      #     RSpec.describe Person, type: :model do
+      #       it do
+      #         should validate_numericality_of(:birth_month).
+      #           is_in(1..12)
+      #       end
+      #     end
+      #
+      #     # Minitest (Shoulda)
+      #     class PersonTest < ActiveSupport::TestCase
+      #       should validate_numericality_of(:birth_month).
+      #         is_in(1..12)
+      #     end
+      #
       # ##### with_message
       #
       # Use `with_message` if you are using a custom validation message.
@@ -330,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
 
@@ -384,60 +393,52 @@ 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))
-          self
-        end
-
-        def with_message(message)
-          @expects_custom_validation_message = true
-          @expected_message = message
+          prepare_submatcher(comparison_matcher_for(value, :!=).for(attribute))
           self
         end
 
-        def expects_custom_validation_message?
-          @expects_custom_validation_message
-        end
-
-        def on(context)
-          @context = context
+        def is_in(range)
+          prepare_submatcher(
+            NumericalityMatchers::RangeMatcher.new(self, attribute, range),
+          )
           self
         end
 
@@ -452,20 +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 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
@@ -494,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)
@@ -543,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)
@@ -577,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(
@@ -596,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
 
@@ -673,8 +659,12 @@ module Shoulda
           end
         end
 
-        def model
-          @subject.class
+        def range_description
+          range_submatcher = @submatchers.detect do |submatcher|
+            submatcher.respond_to? :range_description
+          end
+
+          range_submatcher&.range_description
         end
 
         def non_numeric_value

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

@@ -78,6 +78,27 @@ module Shoulda
       #     should validate_presence_of(:nickname).allow_nil
       #   end
       #
+      # #### allow_blank
+      #
+      # Use `allow_blank` to assert that the attribute allows blank.
+      #
+      #   class Robot
+      #     include ActiveModel::Model
+      #     attr_accessor :nickname
+      #
+      #     validates_presence_of :nickname, allow_blank: true
+      #   end
+      #
+      #   # RSpec
+      #   RSpec.describe Robot, type: :model do
+      #     it { should validate_presence_of(:nickname).allow_blank }
+      #   end
+      #
+      #   # Minitest (Shoulda)
+      #   class RobotTest < ActiveSupport::TestCase
+      #     should validate_presence_of(:nickname).allow_blank
+      #   end
+      #
       # ##### on
       #
       # Use `on` if your validation applies only under a certain context.
@@ -133,6 +154,7 @@ module Shoulda
       # @private
       class ValidatePresenceOfMatcher < ValidationMatcher
         include Qualifiers::AllowNil
+        include Qualifiers::AllowBlank
 
         def initialize(attribute)
           super
@@ -144,7 +166,8 @@ module Shoulda
 
           possibly_ignore_interference_by_writer
 
-          if secure_password_being_validated?
+          if secure_password_being_validated? &&
+             Shoulda::Matchers::RailsShim.active_model_lt_7?
             ignore_interference_by_writer.default_to(when: :blank?)
 
             disallowed_values.all? do |value|
@@ -152,6 +175,7 @@ module Shoulda
             end
           else
             (!expects_to_allow_nil? || allows_value_of(nil)) &&
+              (!expects_to_allow_blank? || allows_value_of('')) &&
               disallowed_values.all? do |value|
                 disallows_original_or_typecast_value?(value)
               end
@@ -171,6 +195,7 @@ module Shoulda
             end
           else
             (expects_to_allow_nil? && disallows_value_of(nil)) ||
+              (expects_to_allow_blank? && disallows_value_of('')) ||
               disallowed_values.any? do |value|
                 allows_original_or_typecast_value?(value)
               end
@@ -208,7 +233,7 @@ validation for you? Instead of using `validate_presence_of`, try
         end
 
         def possibly_ignore_interference_by_writer
-          if secure_password_being_validated?
+          if secure_password_being_validated? && RailsShim.active_model_lt_7?
             ignore_interference_by_writer.default_to(when: :blank?)
           end
         end
@@ -241,11 +266,11 @@ validation for you? Instead of using `validate_presence_of`, try
           else
             values = []
 
-            if attribute_accepts_string_values?
+            if attribute_accepts_string_values? && !expects_to_allow_blank?
               values << ''
             end
 
-            if !expects_to_allow_nil?
+            if !expects_to_allow_nil? && !expects_to_allow_blank?
               values << nil
             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,11 +21,14 @@ 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'
+require 'shoulda/matchers/active_model/numericality_matchers/range_matcher'
+require 'shoulda/matchers/active_model/numericality_matchers/submatchers'
 require 'shoulda/matchers/active_model/errors'
 require 'shoulda/matchers/active_model/have_secure_password_matcher'