shoulda-matchers 3.1.0 → 5.2.0

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

@@ -17,15 +17,15 @@ module Shoulda
       # You can use `allow_value` to test one value at a time:
       #
       #     # RSpec
-      #     describe UserProfile do
-      #       it { should allow_value('http://foo.com').for(:website_url) }
-      #       it { should allow_value('http://bar.com').for(:website_url) }
+      #     RSpec.describe UserProfile, type: :model do
+      #       it { should allow_value('https://foo.com').for(:website_url) }
+      #       it { should allow_value('https://bar.com').for(:website_url) }
       #     end
       #
       #     # Minitest (Shoulda)
       #     class UserProfileTest < ActiveSupport::TestCase
-      #       should allow_value('http://foo.com').for(:website_url)
-      #       should allow_value('http://bar.com').for(:website_url)
+      #       should allow_value('https://foo.com').for(:website_url)
+      #       should allow_value('https://bar.com').for(:website_url)
       #     end
       #
       # You can also test multiple values in one go, if you like. In the
@@ -34,24 +34,24 @@ module Shoulda
       # that none of the values cause the record to be valid:
       #
       #     # RSpec
-      #     describe UserProfile do
+      #     RSpec.describe UserProfile, type: :model do
       #       it do
-      #         should allow_values('http://foo.com', 'http://bar.com').
+      #         should allow_values('https://foo.com', 'https://bar.com').
       #           for(:website_url)
       #       end
       #
       #       it do
-      #         should_not allow_values('http://foo.com', 'buz').
+      #         should_not allow_values('foo', 'buz').
       #           for(:website_url)
       #       end
       #     end
       #
       #     # Minitest (Shoulda)
       #     class UserProfileTest < ActiveSupport::TestCase
-      #       should allow_values('http://foo.com', 'http://bar.com/baz').
+      #       should allow_values('https://foo.com', 'https://bar.com/baz').
       #         for(:website_url)
       #
-      #       should_not allow_values('http://foo.com', 'buz').
+      #       should_not allow_values('foo', 'buz').
       #         for(:website_url)
       #     end
       #
@@ -82,7 +82,7 @@ module Shoulda
       #           end
       #         end
       #
-      #         describe Foo do
+      #         RSpec.describe Foo, type: :model do
       #           it do
       #             foo = Foo.new
       #             foo.bar = "baz"
@@ -105,7 +105,7 @@ module Shoulda
       #           end
       #         end
       #
-      #         describe Foo do
+      #         RSpec.describe Foo, type: :model do
       #           it do
       #             foo = Foo.new
       #             # This will raise an AttributeChangedValueError since `foo.bar` is now "123"
@@ -116,7 +116,7 @@ module Shoulda
       # * You're passing a value to `allow_value` that the model typecasts into
       #   another value:
       #
-      #         describe Foo do
+      #         RSpec.describe Foo, type: :model do
       #           # Assume that `attr` is a string
       #           # This will raise an AttributeChangedValueError since `attr` typecasts `[]` to `"[]"`
       #           it { should_not allow_value([]).for(:attr) }
@@ -154,7 +154,7 @@ module Shoulda
       #     end
       #
       #     # RSpec
-      #     describe UserProfile do
+      #     RSpec.describe UserProfile, type: :model do
       #       it do
       #         should allow_value('2013-01-01').
       #           for(:birthday_as_string).
@@ -183,7 +183,7 @@ module Shoulda
       #     end
       #
       #     # RSpec
-      #     describe UserProfile do
+      #     RSpec.describe UserProfile, type: :model do
       #       it do
       #         should allow_value('open', 'closed').
       #           for(:state).
@@ -210,7 +210,7 @@ module Shoulda
       #     end
       #
       #     # RSpec
-      #     describe UserProfile do
+      #     RSpec.describe UserProfile, type: :model do
       #       it do
       #         should allow_value('open', 'closed').
       #           for(:state).
@@ -246,7 +246,7 @@ module Shoulda
       #     end
       #
       #     # RSpec
-      #     describe UserProfile do
+      #     RSpec.describe UserProfile, type: :model do
       #       it do
       #         should allow_value('Broncos', 'Titans').
       #           for(:sports_team).
@@ -276,7 +276,7 @@ module Shoulda
       #     end
       #
       #     # RSpec
-      #     describe Address do
+      #     RSpec.describe Address, type: :model do
       #       it do
       #         should_not allow_value([]).
       #           for(:zip_code).
@@ -313,7 +313,7 @@ module Shoulda
           :attribute_to_check_message_against,
           :attribute_to_set,
           :context,
-          :instance
+          :instance,
         )
 
         attr_writer(
@@ -332,6 +332,7 @@ module Shoulda
           @context = nil
           @values_to_preset = {}
           @failure_message_preface = nil
+          @attribute_changed_value_message = nil
         end
 
         def for(attribute_name)
@@ -422,55 +423,56 @@ module Shoulda
           end
 
           if include_attribute_changed_value_message?
-            message << "\n\n" + attribute_changed_value_message.call
+            message << "\n\n#{attribute_changed_value_message.call}"
           end
 
           Shoulda::Matchers.word_wrap(message)
         end
 
-        def failure_message_when_negated
+        def failure_message_when_negated # rubocop:disable Metrics/MethodLength
           attribute_setter = result.attribute_setter
 
           if attribute_setter.unsuccessfully_checked?
             message = attribute_setter.failure_message
           else
             validator = result.validator
-            message = failure_message_preface.call + ' invalid'
+            message = "#{failure_message_preface.call} invalid"
 
             if validator.type_of_message_matched?
               if validator.has_messages?
                 message << ' and to'
 
-                if validator.captured_validation_exception?
+                if validator.captured_validation_exception? # rubocop:disable Metrics/BlockNesting
                   message << ' raise a validation exception with message'
                 else
                   message << ' produce'
 
-                  if expected_message.is_a?(Regexp)
-                    message << ' a'
-                  else
-                    message << ' the'
-                  end
+                  message <<
+                    if expected_message.is_a?(Regexp) # rubocop:disable Metrics/BlockNesting
+                      ' a'
+                    else
+                      ' the'
+                    end
 
                   message << ' validation error'
                 end
 
-                if expected_message.is_a?(Regexp)
+                if expected_message.is_a?(Regexp) # rubocop:disable Metrics/BlockNesting
                   message << ' matching '
                   message << Shoulda::Matchers::Util.inspect_value(
-                    expected_message
+                    expected_message,
                   )
                 else
                   message << " #{expected_message.inspect}"
                 end
 
-                unless validator.captured_validation_exception?
+                unless validator.captured_validation_exception? # rubocop:disable Metrics/BlockNesting
                   message << " on :#{attribute_to_check_message_against}"
                 end
 
                 message << '. The record was indeed invalid, but'
 
-                if validator.captured_validation_exception?
+                if validator.captured_validation_exception? # rubocop:disable Metrics/BlockNesting
                   message << ' the exception message was '
                   message << validator.validation_exception_message.inspect
                   message << ' instead.'
@@ -491,7 +493,7 @@ module Shoulda
           end
 
           if include_attribute_changed_value_message?
-            message << "\n\n" + attribute_changed_value_message.call
+            message << "\n\n#{attribute_changed_value_message.call}"
           end
 
           Shoulda::Matchers.word_wrap(message)
@@ -530,7 +532,8 @@ module Shoulda
 
         def run(strategy)
           attribute_setters_for_values_to_preset.first_failing ||
-            attribute_setters_and_validators_for_values_to_set.public_send(strategy)
+            attribute_setters_and_validators_for_values_to_set.
+              public_send(strategy)
         end
 
         def failure_message_preface
@@ -596,14 +599,14 @@ pass, or do something else entirely.
           @_attribute_setters_and_validators_for_values_to_set ||=
             AttributeSettersAndValidators.new(
               self,
-              values_to_set.map { |value| [attribute_to_set, value] }
+              values_to_set.map { |value| [attribute_to_set, value] },
             )
         end
 
         def inspected_values_to_set
           Shoulda::Matchers::Util.inspect_values(values_to_set).to_sentence(
-            two_words_connector: " or ",
-            last_word_connector: ", or"
+            two_words_connector: ' or ',
+            last_word_connector: ', or ',
           )
         end
 
@@ -618,7 +621,7 @@ pass, or do something else entirely.
         def default_attribute_message
           default_error_message(
             options[:expected_message],
-            default_attribute_message_values
+            default_attribute_message_values,
           )
         end
 
@@ -638,7 +641,7 @@ pass, or do something else entirely.
 
         def human_attribute_name
           instance.class.human_attribute_name(
-            attribute_to_check_message_against
+            attribute_to_check_message_against,
           )
         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
-      #     describe User do
+      #     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/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

@@ -17,6 +17,7 @@ module Shoulda
             :ignore_interference_by_writer,
             :ignoring_interference_by_writer,
             :matches?,
+            :does_not_match?,
             :on,
             :strict,
             :with_message,
@@ -43,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/allow_blank.rb

@@ -0,0 +1,26 @@
+module Shoulda
+  module Matchers
+    module ActiveModel
+      module Qualifiers
+        # @private
+        module AllowBlank
+          def initialize(*args)
+            super
+            @expects_to_allow_blank = false
+          end
+
+          def allow_blank
+            @expects_to_allow_blank = true
+            self
+          end
+
+          protected
+
+          def expects_to_allow_blank?
+            @expects_to_allow_blank
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,26 @@
+module Shoulda
+  module Matchers
+    module ActiveModel
+      module Qualifiers
+        # @private
+        module AllowNil
+          def initialize(*args)
+            super
+            @expects_to_allow_nil = false
+          end
+
+          def allow_nil
+            @expects_to_allow_nil = true
+            self
+          end
+
+          protected
+
+          def expects_to_allow_nil?
+            @expects_to_allow_nil
+          end
+        end
+      end
+    end
+  end
+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/qualifiers.rb

@@ -8,5 +8,7 @@ module Shoulda
   end
 end
 
+require_relative 'qualifiers/allow_nil'
+require_relative 'qualifiers/allow_blank'
 require_relative 'qualifiers/ignore_interference_by_writer'
 require_relative 'qualifiers/ignoring_interference_by_writer'