shoulda-matchers 5.2.0 → 6.0.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
@@ -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
 
@@ -454,9 +455,13 @@ module Shoulda
         def simple_description
           description = ''
 
-          description << "validate that :#{@attribute} looks like "
+          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}"
           end
@@ -464,10 +469,6 @@ module Shoulda
           description
         end
 
-        def description
-          ValidationMatcher::BuildDescription.call(self, simple_description)
-        end
-
         def failure_message
           overall_failure_message.dup.tap do |message|
             message << "\n"
@@ -494,44 +495,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 +529,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 +563,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 +582,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 +661,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/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'
 

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

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

@@ -48,6 +48,30 @@ module Shoulda
       #       should have_db_column(:camera_aperture).of_type(:decimal)
       #     end
       #
+      # ##### of_sql_type
+      #
+      # Use `of_sql_type` to assert that a column is defined as a certain sql_type.
+      #
+      #     class CreatePhones < ActiveRecord::Migration
+      #       def change
+      #         create_table :phones do |t|
+      #           t.string :camera_aperture, limit: 36
+      #         end
+      #       end
+      #     end
+      #
+      #     # RSpec
+      #     RSpec.describe Phone, type: :model do
+      #       it do
+      #         should have_db_column(:camera_aperture).of_sql_type('varchar(36)')
+      #       end
+      #     end
+      #
+      #     # Minitest (Shoulda)
+      #     class PhoneTest < ActiveSupport::TestCase
+      #       should have_db_column(:camera_aperture).of_sql_type('varchar(36)')
+      #     end
+      #
       # ##### with_options
       #
       # Use `with_options` to assert that a column has been defined with
@@ -96,6 +120,11 @@ module Shoulda
           self
         end
 
+        def of_sql_type(sql_column_type)
+          @options[:sql_column_type] = sql_column_type
+          self
+        end
+
         def with_options(opts = {})
           validate_options(opts)
           OPTIONS.each do |attribute|
@@ -110,6 +139,7 @@ module Shoulda
           @subject = subject
           column_exists? &&
             correct_column_type? &&
+            correct_sql_column_type? &&
             correct_precision? &&
             correct_limit? &&
             correct_default? &&
@@ -129,12 +159,9 @@ module Shoulda
 
         def description
           desc = "have db column named #{@column}"
-          if @options.key?(:column_type)
-            desc << " of type #{@options[:column_type]}"
-          end
-          if @options.key?(:precision)
-            desc << " of precision #{@options[:precision]}"
-          end
+          desc << " of type #{@options[:column_type]}" if @options.key?(:column_type)
+          desc << " of sql_type #{@options[:sql_column_type]}" if @options.key?(:sql_column_type)
+          desc << " of precision #{@options[:precision]}" if @options.key?(:precision)
           desc << " of limit #{@options[:limit]}" if @options.key?(:limit)
           desc << " of default #{@options[:default]}" if @options.key?(:default)
           desc << " of null #{@options[:null]}" if @options.key?(:null)
@@ -178,6 +205,19 @@ module Shoulda
           end
         end
 
+        def correct_sql_column_type?
+          return true unless @options.key?(:sql_column_type)
+
+          if matched_column.sql_type.to_s == @options[:sql_column_type].to_s
+            true
+          else
+            @missing =
+              "#{model_class} has a db column named #{@column} " <<
+              "of sql type #{matched_column.sql_type}, not #{@options[:sql_column_type]}."
+            false
+          end
+        end
+
         def correct_precision?
           return true unless @options.key?(:precision)
 

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

@@ -197,17 +197,28 @@ module Shoulda
         def matched_index
           @_matched_index ||=
             if expected_columns.one?
-              actual_indexes.detect do |index|
+              sorted_indexes.detect do |index|
                 Array.wrap(index.columns) == expected_columns
               end
             else
-              actual_indexes.detect do |index|
+              sorted_indexes.detect do |index|
                 index.columns == expected_columns
               end
             end
         end
 
-        def actual_indexes
+        def sorted_indexes
+          if qualifiers.include?(:unique)
+            # return indexes with unique matching the qualifier first
+            unsorted_indexes.sort_by do |index|
+              index.unique == qualifiers[:unique] ? 0 : 1
+            end
+          else
+            unsorted_indexes
+          end
+        end
+
+        def unsorted_indexes
           model.connection.indexes(table_name)
         end
 

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

@@ -2,7 +2,7 @@ module Shoulda
   module Matchers
     module ActiveRecord
       # The `have_implicit_order_column` matcher tests that the model has `implicit_order_column`
-      # assigned to one of the table columns. (Rails 6+ only)
+      # assigned to one of the table columns.
       #
       #     class Product < ApplicationRecord
       #       self.implicit_order_column = :created_at
@@ -20,10 +20,8 @@ module Shoulda
       #
       # @return [HaveImplicitOrderColumnMatcher]
       #
-      if RailsShim.active_record_gte_6?
-        def have_implicit_order_column(column_name)
-          HaveImplicitOrderColumnMatcher.new(column_name)
-        end
+      def have_implicit_order_column(column_name)
+        HaveImplicitOrderColumnMatcher.new(column_name)
       end
 
       # @private