shoulda-matchers 4.1.2 → 4.5.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

@@ -26,7 +26,7 @@ module Shoulda
             attribute.to_sym,
             type,
             model_name,
-            options
+            options,
           )
         end
       end

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

@@ -5,22 +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
-          }
+            :> => {
+              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
@@ -93,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
@@ -114,18 +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]
-            end
+            ERROR_MESSAGES[@operator][:assertions]
           end
 
           def diffs_to_compare
@@ -140,13 +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"
-            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,10 +103,12 @@ 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
@@ -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

@@ -35,7 +35,7 @@ module Shoulda
       #       include ActiveModel::Model
       #       attr_accessor :supported_os
       #
-      #       validates_exclusion_of :supported_os, in: ['Mac', 'Linux']
+      #       validates_exclusion_of :supported_os, in: 5..8
       #     end
       #
       #     # RSpec
@@ -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

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

@@ -268,20 +268,20 @@ module Shoulda
 
       # @private
       class ValidateInclusionOfMatcher < ValidationMatcher
-        BLANK_VALUES = ['', ' ', "\n", "\r", "\t", "\f"]
-        ARBITRARY_OUTSIDE_STRING = 'shoulda-matchers test string'
+        BLANK_VALUES = ['', ' ', "\n", "\r", "\t", "\f"].freeze
+        ARBITRARY_OUTSIDE_STRING = 'shoulda-matchers test string'.freeze
         ARBITRARY_OUTSIDE_INTEGER = 123456789
         ARBITRARY_OUTSIDE_DECIMAL = BigDecimal('0.123456789')
         ARBITRARY_OUTSIDE_DATE = Date.jd(9999999)
         ARBITRARY_OUTSIDE_DATETIME = DateTime.jd(9999999)
         ARBITRARY_OUTSIDE_TIME = Time.at(9999999999)
-        BOOLEAN_ALLOWS_BOOLEAN_MESSAGE = <<EOT
+        BOOLEAN_ALLOWS_BOOLEAN_MESSAGE = <<EOT.freeze
 You are using `validate_inclusion_of` to assert that a boolean column allows
 boolean values and disallows non-boolean ones. Be aware that it is not possible
 to fully test this, as boolean columns will automatically convert non-boolean
 values to boolean ones. Hence, you should consider removing this test.
 EOT
-        BOOLEAN_ALLOWS_NIL_MESSAGE = <<EOT
+        BOOLEAN_ALLOWS_NIL_MESSAGE = <<EOT.freeze
 You are using `validate_inclusion_of` to assert that a boolean column allows nil.
 Be aware that it is not possible to fully test this, as anything other than
 true, false or nil will be converted to false. Hence, you should consider
@@ -311,15 +311,6 @@ EOT
           self
         end
 
-        def allow_blank
-          @options[:allow_blank] = true
-          self
-        end
-
-        def expects_to_allow_blank?
-          @options[:allow_blank]
-        end
-
         def allow_nil
           @options[:allow_nil] = true
           self
@@ -363,11 +354,12 @@ EOT
           else
             description = "validate that :#{@attribute}"
 
-            if @array.many?
-              description << " is either #{inspected_array}"
-            else
-              description << " is #{inspected_array}"
-            end
+            description <<
+              if @array.many?
+                " is either #{inspected_array}"
+              else
+                " is #{inspected_array}"
+              end
 
             description
           end
@@ -423,14 +415,14 @@ EOT
           allows_all_values_in_array? &&
             disallows_all_values_outside_of_array? &&
             allows_nil_value? &&
-            allows_blank_value?
+            allow_blank_matches?
         end
 
         def does_not_match_for_array?
           disallows_any_values_in_array? ||
             allows_any_value_outside_of_array? ||
             disallows_nil_value? ||
-            disallows_blank_value?
+            allow_blank_does_not_match?
         end
 
         def allows_lower_value
@@ -554,10 +546,10 @@ EOT
           values = []
 
           values << case @array
-            when [true]  then false
-            when [false] then true
-            else              raise CouldNotDetermineValueOutsideOfArray
-          end
+                    when [true]  then false
+                    when [false] then true
+                    else              raise CouldNotDetermineValueOutsideOfArray
+                    end
 
           if attribute_allows_nil?
             values << nil
@@ -590,21 +582,21 @@ EOT
 
         def column_type_to_attribute_type(type)
           case type
-            when :float then :integer
-            when :timestamp then :datetime
-            else type
+          when :float then :integer
+          when :timestamp then :datetime
+          else type
           end
         end
 
         def value_to_attribute_type(value)
           case value
-            when true, false then :boolean
-            when BigDecimal then :decimal
-            when Integer then :integer
-            when Date then :date
-            when DateTime then :datetime
-            when Time then :time
-            else :unknown
+          when true, false then :boolean
+          when BigDecimal then :decimal
+          when Integer then :integer
+          when Date then :date
+          when DateTime then :datetime
+          when Time then :time
+          else :unknown
           end
         end
 
@@ -616,20 +608,10 @@ EOT
           @options[:allow_nil] && disallows_value_of(nil)
         end
 
-        def allows_blank_value?
-          @options[:allow_blank] != true ||
-            BLANK_VALUES.all? { |value| allows_value_of(value) }
-        end
-
-        def disallows_blank_value?
-          @options[:allow_blank] &&
-            BLANK_VALUES.any? { |value| disallows_value_of(value) }
-        end
-
         def inspected_array
           Shoulda::Matchers::Util.inspect_values(@array).to_sentence(
-            two_words_connector: " or ",
-            last_word_connector: ", or "
+            two_words_connector: ' or ',
+            last_word_connector: ', or ',
           )
         end
       end