shoulda-matchers 4.4.0 → 5.0.0

data/lib/shoulda/matchers/active_model/allow_value_matcher/attribute_changed_value_error.rb

@@ -31,7 +31,7 @@ need to do something different.
 If you need help, feel free to ask a question on the shoulda-matchers
 issues list:
 
-http://github.com/thoughtbot/shoulda-matchers/issues
+https://github.com/thoughtbot/shoulda-matchers/issues
             MESSAGE
           end
 

data/lib/shoulda/matchers/active_model/allow_value_matcher/attribute_setter.rb

@@ -23,7 +23,7 @@ module Shoulda
             @value_written = args.fetch(:value)
             @ignore_interference_by_writer = args.fetch(
               :ignore_interference_by_writer,
-              Qualifiers::IgnoreInterferenceByWriter.new
+              Qualifiers::IgnoreInterferenceByWriter.new,
             )
             @after_set_callback = args.fetch(:after_set_callback, -> { })
 
@@ -36,9 +36,9 @@ module Shoulda
             description << Shoulda::Matchers::Util.inspect_value(value_written)
 
             if attribute_changed_value?
-              description << " -- which was read back as "
+              description << ' -- which was read back as '
               description << Shoulda::Matchers::Util.inspect_value(value_read)
-              description << " --"
+              description << ' --'
             end
 
             description
@@ -206,7 +206,7 @@ module Shoulda
               model: object.class,
               attribute_name: attribute_name,
               value_written: value_written,
-              value_read: value_read
+              value_read: value_read,
             )
           end
 
@@ -218,7 +218,7 @@ module Shoulda
             AttributeDoesNotExistError.create(
               model: object.class,
               attribute_name: attribute_name,
-              value: value_written
+              value: value_written,
             )
           end
 

data/lib/shoulda/matchers/active_model/allow_value_matcher/attribute_setter_and_validator.rb

@@ -34,7 +34,7 @@ module Shoulda
               attribute_name: attribute_name,
               value: value,
               ignore_interference_by_writer: ignore_interference_by_writer,
-              after_set_callback: after_setting_value_callback
+              after_set_callback: after_setting_value_callback,
             )
           end
 
@@ -48,7 +48,7 @@ module Shoulda
               attribute_to_check_message_against,
               context: context,
               expects_strict: expects_strict?,
-              expected_message: expected_message
+              expected_message: expected_message,
             )
           end
 

data/lib/shoulda/matchers/active_model/allow_value_matcher/attribute_setters.rb

@@ -11,7 +11,7 @@ module Shoulda
               AttributeSetterAndValidator.new(
                 allow_value_matcher,
                 attribute_name,
-                value
+                value,
               )
             end
           end

data/lib/shoulda/matchers/active_model/allow_value_matcher/attribute_setters_and_validators.rb

@@ -11,7 +11,7 @@ module Shoulda
               AttributeSetterAndValidator.new(
                 allow_value_matcher,
                 attribute_name,
-                value
+                value,
               )
             end
           end

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

@@ -46,7 +46,7 @@ module Shoulda
           self
         end
 
-        def with_message(message, options={})
+        def with_message(message, options = {})
           allow_matcher.with_message(message, options)
           self
         end

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

@@ -10,49 +10,51 @@ module Shoulda
       #       include ActiveModel::Model
       #       include ActiveModel::SecurePassword
       #       attr_accessor :password
+      #       attr_accessor :reset_password
       #
       #       has_secure_password
+      #       has_secure_password :reset_password
       #     end
       #
       #     # RSpec
       #     RSpec.describe User, type: :model do
       #       it { should have_secure_password }
+      #       it { should have_secure_password(:reset_password) }
       #     end
       #
       #     # Minitest (Shoulda)
       #     class UserTest < ActiveSupport::TestCase
       #       should have_secure_password
+      #       should have_secure_password(:reset_password)
       #     end
       #
       # @return [HaveSecurePasswordMatcher]
       #
-      def have_secure_password
-        HaveSecurePasswordMatcher.new
+      def have_secure_password(attr = :password)
+        HaveSecurePasswordMatcher.new(attr)
       end
 
       # @private
       class HaveSecurePasswordMatcher
         attr_reader :failure_message
 
-        CORRECT_PASSWORD = "aBcDe12345"
-        INCORRECT_PASSWORD = "password"
-
-        EXPECTED_METHODS = [
-          :authenticate,
-          :password=,
-          :password_confirmation=,
-          :password_digest,
-          :password_digest=,
-        ]
+        CORRECT_PASSWORD = 'aBcDe12345'.freeze
+        INCORRECT_PASSWORD = 'password'.freeze
 
         MESSAGES = {
-          authenticated_incorrect_password: "expected %{subject} to not authenticate an incorrect password",
-          did_not_authenticate_correct_password: "expected %{subject} to authenticate the correct password",
-          method_not_found: "expected %{subject} to respond to %{methods}"
-        }
+          authenticated_incorrect_password: 'expected %{subject} to not'\
+            ' authenticate an incorrect %{attribute}',
+          did_not_authenticate_correct_password: 'expected %{subject} to'\
+            ' authenticate the correct %{attribute}',
+          method_not_found: 'expected %{subject} to respond to %{methods}',
+        }.freeze
+
+        def initialize(attribute)
+          @attribute = attribute.to_sym
+        end
 
         def description
-          "have a secure password"
+          "have a secure password, defined on #{@attribute} attribute"
         end
 
         def matches?(subject)
@@ -60,7 +62,8 @@ module Shoulda
 
           if failure = validate
             key, params = failure
-            @failure_message = MESSAGES[key] % { subject: subject.class }.merge(params)
+            @failure_message =
+              MESSAGES[key] % { subject: subject.class }.merge(params)
           end
 
           failure.nil?
@@ -71,21 +74,44 @@ module Shoulda
         attr_reader :subject
 
         def validate
-          missing_methods = EXPECTED_METHODS.select {|m| !subject.respond_to?(m) }
+          missing_methods = expected_methods.reject do |m|
+            subject.respond_to?(m)
+          end
 
           if missing_methods.present?
             [:method_not_found, { methods: missing_methods.to_sentence }]
           else
-            subject.password = CORRECT_PASSWORD
-            subject.password_confirmation = CORRECT_PASSWORD
+            subject.send("#{@attribute}=", CORRECT_PASSWORD)
+            subject.send("#{@attribute}_confirmation=", CORRECT_PASSWORD)
 
-            if not subject.authenticate(CORRECT_PASSWORD)
-              [:did_not_authenticate_correct_password, {}]
-            elsif subject.authenticate(INCORRECT_PASSWORD)
-              [:authenticated_incorrect_password, {}]
+            if not subject.send(authenticate_method, CORRECT_PASSWORD)
+              [:did_not_authenticate_correct_password,
+               { attribute: @attribute },]
+            elsif subject.send(authenticate_method, INCORRECT_PASSWORD)
+              [:authenticated_incorrect_password, { attribute: @attribute }]
             end
           end
         end
+
+        private
+
+        def expected_methods
+          @_expected_methods ||= %I[
+            #{authenticate_method}
+            #{@attribute}=
+            #{@attribute}_confirmation=
+            #{@attribute}_digest
+            #{@attribute}_digest=
+          ]
+        end
+
+        def authenticate_method
+          if @attribute == :password
+            :authenticate
+          else
+            "authenticate_#{@attribute}".to_sym
+          end
+        end
       end
     end
   end

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

@@ -8,7 +8,7 @@ module Shoulda
         end
 
         def format_validation_errors(errors)
-          list_items = errors.keys.map do |attribute|
+          list_items = errors.to_hash.keys.map do |attribute|
             messages = errors[attribute]
             "* #{attribute}: #{messages}"
           end
@@ -26,7 +26,7 @@ module Shoulda
             attribute.to_sym,
             type,
             model_name,
-            options
+            options,
           )
         end
       end

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

@@ -3,11 +3,6 @@ module Shoulda
     module ActiveModel
       # @private
       module NumericalityMatchers
-        autoload :ComparisonMatcher,  'shoulda/matchers/active_model/numericality_matchers/comparison_matcher'
-        autoload :EvenNumberMatcher,  'shoulda/matchers/active_model/numericality_matchers/even_number_matcher'
-        autoload :NumericTypeMatcher, 'shoulda/matchers/active_model/numericality_matchers/numeric_type_matcher'
-        autoload :OddNumberMatcher,   'shoulda/matchers/active_model/numericality_matchers/odd_number_matcher'
-        autoload :OnlyIntegerMatcher, 'shoulda/matchers/active_model/numericality_matchers/only_integer_matcher'
       end
     end
   end

data/lib/shoulda/matchers/active_model/numericality_matchers/comparison_matcher.rb

@@ -5,23 +5,42 @@ module Shoulda
         # @private
         class ComparisonMatcher < ValidationMatcher
           ERROR_MESSAGES = {
-            :> => :greater_than,
-            :>= => :greater_than_or_equal_to,
-            :< => :less_than,
-            :<= => :less_than_or_equal_to,
-            :== => :equal_to,
-            :!= => :other_than,
-          }
+            :> => {
+              label: :greater_than,
+              assertions: [false, false, true],
+            },
+            :>= => {
+              label: :greater_than_or_equal_to,
+              assertions: [false, true, true],
+            },
+            :< => {
+              label: :less_than,
+              assertions: [true, false, false],
+            },
+            :<= => {
+              label: :less_than_or_equal_to,
+              assertions: [true, true, false],
+            },
+            :== => {
+              label: :equal_to,
+              assertions: [false, true, false],
+            },
+            :!= => {
+              label: :other_than,
+              assertions: [true, false, true],
+            },
+          }.freeze
 
           def initialize(numericality_matcher, value, operator)
             super(nil)
             unless numericality_matcher.respond_to? :diff_to_compare
               raise ArgumentError, 'numericality_matcher is invalid'
             end
+
             @numericality_matcher = numericality_matcher
             @value = value
             @operator = operator
-            @message = ERROR_MESSAGES[operator]
+            @message = ERROR_MESSAGES[operator][:label]
           end
 
           def simple_description
@@ -94,10 +113,9 @@ module Shoulda
           end
 
           def submatchers_and_results
-            @_submatchers_and_results ||=
-              submatchers.map do |matcher|
-                { matcher: matcher, matched: matcher.matches?(@subject) }
-              end
+            @_submatchers_and_results ||= submatchers.map do |matcher|
+              { matcher: matcher, matched: matcher.matches?(@subject) }
+            end
           end
 
           def comparison_combos
@@ -115,20 +133,7 @@ module Shoulda
           end
 
           def assertions
-            case @operator
-            when :>
-              [false, false, true]
-            when :>=
-              [false, true, true]
-            when :==
-              [false, true, false]
-            when :<
-              [true, false, false]
-            when :<=
-              [true, true, false]
-            when :!=
-               [true, false, true]
-            end
+            ERROR_MESSAGES[@operator][:assertions]
           end
 
           def diffs_to_compare
@@ -143,14 +148,7 @@ module Shoulda
           end
 
           def comparison_expectation
-            case @operator
-              when :> then "greater than"
-              when :>= then "greater than or equal to"
-              when :== then "equal to"
-              when :< then "less than"
-              when :<= then "less than or equal to"
-              when :!= then 'other than'
-            end
+            ERROR_MESSAGES[@operator][:label].to_s.tr('_', ' ')
           end
         end
       end

data/lib/shoulda/matchers/active_model/numericality_matchers/numeric_type_matcher.rb

@@ -44,7 +44,7 @@ module Shoulda
 
           attr_reader :attribute
 
-          def wrap_disallow_value_matcher(matcher)
+          def wrap_disallow_value_matcher(_matcher)
             raise NotImplementedError
           end
 

data/lib/shoulda/matchers/active_model/qualifiers/ignoring_interference_by_writer.rb

@@ -6,7 +6,7 @@ module Shoulda
         module IgnoringInterferenceByWriter
           attr_reader :ignore_interference_by_writer
 
-          def initialize(*args)
+          def initialize(*)
             @ignore_interference_by_writer = IgnoreInterferenceByWriter.new
           end
 

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

@@ -103,15 +103,17 @@ module Shoulda
           if reflection
             obj = reflection.klass.new
             if collection?
-              [ obj ]
+              [obj]
             else
               obj
             end
+          elsif array_column?
+            ['an arbitary value']
           else
             case column_type
             when :integer, :float then 1
             when :decimal then BigDecimal(1, 0)
-            when :datetime, :time, :timestamp then Time.now
+            when :datetime, :time, :timestamp then Time.current
             when :date then Date.new
             when :binary then '0'
             else 'an arbitrary value'
@@ -137,6 +139,12 @@ module Shoulda
           @subject.class.respond_to?(:reflect_on_association) &&
             @subject.class.reflect_on_association(@attribute)
         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/validate_confirmation_of_matcher.rb

@@ -148,12 +148,12 @@ module Shoulda
 
         def qualify_matcher(matcher, confirmation_attribute_value)
           matcher.values_to_preset = {
-            confirmation_attribute => confirmation_attribute_value
+            confirmation_attribute => confirmation_attribute_value,
           }
           matcher.with_message(
             @expected_message,
             against: confirmation_attribute,
-            values: { attribute: attribute }
+            values: { attribute: attribute },
           )
         end
       end

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

@@ -146,11 +146,12 @@ module Shoulda
           else
             description = "validate that :#{@attribute}"
 
-            if @array.many?
-              description << " is neither #{inspected_array}"
-            else
-              description << " is not #{inspected_array}"
-            end
+            description <<
+              if @array.many?
+                " is neither #{inspected_array}"
+              else
+                " is not #{inspected_array}"
+              end
 
             description
           end
@@ -238,8 +239,8 @@ module Shoulda
 
         def inspected_array
           Shoulda::Matchers::Util.inspect_values(@array).to_sentence(
-            two_words_connector: " nor ",
-            last_word_connector: ", nor "
+            two_words_connector: ' nor ',
+            last_word_connector: ', nor ',
           )
         end
       end