shoulda-matchers 4.4.1 → 4.5.0

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

@@ -89,23 +89,24 @@ module Shoulda
           @subject = subject
           if attr_mass_assignable?
             if whitelisting?
-              @failure_message_when_negated = "#{@attribute} was made accessible"
+              @failure_message_when_negated = "#{@attribute} was made "\
+                'accessible'
+            elsif protected_attributes.empty?
+              @failure_message_when_negated = 'no attributes were protected'
             else
-              if protected_attributes.empty?
-                @failure_message_when_negated = 'no attributes were protected'
-              else
-                @failure_message_when_negated = "#{class_name} is protecting " <<
-                  "#{protected_attributes.to_a.to_sentence}, " <<
-                  "but not #{@attribute}."
-              end
+              @failure_message_when_negated =
+                "#{class_name} is protecting " <<
+                "#{protected_attributes.to_a.to_sentence}, " <<
+                "but not #{@attribute}."
             end
             true
           else
-            if whitelisting?
-              @failure_message = "Expected #{@attribute} to be accessible"
-            else
-              @failure_message = "Did not expect #{@attribute} to be protected"
-            end
+            @failure_message =
+              if whitelisting?
+                "Expected #{@attribute} to be accessible"
+              else
+                "Did not expect #{@attribute} to be protected"
+              end
             false
           end
         end
@@ -131,15 +132,16 @@ module Shoulda
         end
 
         def protected_attributes
-          @protected_attributes ||= (@subject.class.protected_attributes || [])
+          @_protected_attributes ||= (@subject.class.protected_attributes || [])
         end
 
         def accessible_attributes
-          @accessible_attributes ||= (@subject.class.accessible_attributes || [])
+          @_accessible_attributes ||=
+            (@subject.class.accessible_attributes || [])
         end
 
         def whitelisting?
-          authorizer.kind_of?(::ActiveModel::MassAssignmentSecurity::WhiteList)
+          authorizer.is_a?(::ActiveModel::MassAssignmentSecurity::WhiteList)
         end
 
         def attr_mass_assignable?

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

@@ -18,14 +18,14 @@ module Shoulda
       #
       #     # RSpec
       #     RSpec.describe UserProfile, type: :model do
-      #       it { should allow_value('http://foo.com').for(:website_url) }
-      #       it { should allow_value('http://bar.com').for(:website_url) }
+      #       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
@@ -36,7 +36,7 @@ module Shoulda
       #     # RSpec
       #     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
       #
@@ -48,7 +48,7 @@ module Shoulda
       #
       #     # 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('foo', 'buz').
@@ -313,7 +313,7 @@ module Shoulda
           :attribute_to_check_message_against,
           :attribute_to_set,
           :context,
-          :instance
+          :instance,
         )
 
         attr_writer(
@@ -423,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.'
@@ -492,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)
@@ -531,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
@@ -597,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
 
@@ -619,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
 
@@ -639,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/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