shoulda-matchers 3.1.0 → 5.2.0

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

@@ -12,7 +12,7 @@ module Shoulda
       #     end
       #
       #     # RSpec
-      #     describe Robot do
+      #     RSpec.describe Robot, type: :model do
       #       it { should validate_presence_of(:arms) }
       #     end
       #
@@ -36,7 +36,7 @@ module Shoulda
       #       validates_presence_of :password
       #     end
       #
-      #     describe User do
+      #     RSpec.describe User, type: :model do
       #       subject { User.new(password: '123456') }
       #
       #       it { should validate_presence_of(:password) }
@@ -57,6 +57,48 @@ module Shoulda
       #
       # #### Qualifiers
       #
+      # ##### allow_nil
+      #
+      # Use `allow_nil` if your model has an optional attribute.
+      #
+      #   class Robot
+      #     include ActiveModel::Model
+      #     attr_accessor :nickname
+      #
+      #     validates_presence_of :nickname, allow_nil: true
+      #   end
+      #
+      #   # RSpec
+      #   RSpec.describe Robot, type: :model do
+      #     it { should validate_presence_of(:nickname).allow_nil }
+      #   end
+      #
+      #   # Minitest (Shoulda)
+      #   class RobotTest < ActiveSupport::TestCase
+      #     should validate_presence_of(:nickname).allow_nil
+      #   end
+      #
+      # #### allow_blank
+      #
+      # Use `allow_blank` to assert that the attribute allows blank.
+      #
+      #   class Robot
+      #     include ActiveModel::Model
+      #     attr_accessor :nickname
+      #
+      #     validates_presence_of :nickname, allow_blank: true
+      #   end
+      #
+      #   # RSpec
+      #   RSpec.describe Robot, type: :model do
+      #     it { should validate_presence_of(:nickname).allow_blank }
+      #   end
+      #
+      #   # Minitest (Shoulda)
+      #   class RobotTest < ActiveSupport::TestCase
+      #     should validate_presence_of(:nickname).allow_blank
+      #   end
+      #
       # ##### on
       #
       # Use `on` if your validation applies only under a certain context.
@@ -69,7 +111,7 @@ module Shoulda
       #     end
       #
       #     # RSpec
-      #     describe Robot do
+      #     RSpec.describe Robot, type: :model do
       #       it { should validate_presence_of(:arms).on(:create) }
       #     end
       #
@@ -90,7 +132,7 @@ module Shoulda
       #     end
       #
       #     # RSpec
-      #     describe Robot do
+      #     RSpec.describe Robot, type: :model do
       #       it do
       #         should validate_presence_of(:legs).
       #           with_message('Robot has no legs')
@@ -111,6 +153,9 @@ module Shoulda
 
       # @private
       class ValidatePresenceOfMatcher < ValidationMatcher
+        include Qualifiers::AllowNil
+        include Qualifiers::AllowBlank
+
         def initialize(attribute)
           super
           @expected_message = :blank
@@ -119,11 +164,41 @@ module Shoulda
         def matches?(subject)
           super(subject)
 
+          possibly_ignore_interference_by_writer
+
+          if secure_password_being_validated? &&
+             Shoulda::Matchers::RailsShim.active_model_lt_7?
+            ignore_interference_by_writer.default_to(when: :blank?)
+
+            disallowed_values.all? do |value|
+              disallows_and_double_checks_value_of!(value)
+            end
+          else
+            (!expects_to_allow_nil? || allows_value_of(nil)) &&
+              (!expects_to_allow_blank? || allows_value_of('')) &&
+              disallowed_values.all? do |value|
+                disallows_original_or_typecast_value?(value)
+              end
+          end
+        end
+
+        def does_not_match?(subject)
+          super(subject)
+
+          possibly_ignore_interference_by_writer
+
           if secure_password_being_validated?
             ignore_interference_by_writer.default_to(when: :blank?)
-            disallows_and_double_checks_value_of!(blank_value, @expected_message)
+
+            disallowed_values.any? do |value|
+              allows_and_double_checks_value_of!(value)
+            end
           else
-            disallows_original_or_typecast_value?(blank_value, @expected_message)
+            (expects_to_allow_nil? && disallows_value_of(nil)) ||
+              (expects_to_allow_blank? && disallows_value_of('')) ||
+              disallowed_values.any? do |value|
+                allows_original_or_typecast_value?(value)
+              end
           end
         end
 
@@ -131,43 +206,195 @@ module Shoulda
           "validate that :#{@attribute} cannot be empty/falsy"
         end
 
+        def failure_message
+          message = super
+
+          if should_add_footnote_about_belongs_to?
+            message << "\n\n"
+            message << Shoulda::Matchers.word_wrap(<<-MESSAGE.strip, indent: 2)
+You're getting this error because #{reason_for_existing_presence_validation}.
+*This* presence validation doesn't use "can't be blank", the usual validation
+message, but "must exist" instead.
+
+With that said, did you know that the `belong_to` matcher can test this
+validation for you? Instead of using `validate_presence_of`, try
+#{suggestions_for_belongs_to}
+            MESSAGE
+          end
+
+          message
+        end
+
         private
 
         def secure_password_being_validated?
-          defined?(::ActiveModel::SecurePassword) &&
-            @subject.class.ancestors.include?(::ActiveModel::SecurePassword::InstanceMethodsOnActivation) &&
-            @attribute == :password
+          Shoulda::Matchers::RailsShim.digestible_attributes_in(@subject).
+            include?(@attribute)
         end
 
-        def disallows_and_double_checks_value_of!(value, message)
-          disallows_value_of(value, message)
+        def possibly_ignore_interference_by_writer
+          if secure_password_being_validated? && RailsShim.active_model_lt_7?
+            ignore_interference_by_writer.default_to(when: :blank?)
+          end
+        end
+
+        def allows_and_double_checks_value_of!(value)
+          allows_value_of(value, @expected_message)
+        rescue ActiveModel::AllowValueMatcher::AttributeChangedValueError
+          raise ActiveModel::CouldNotSetPasswordError.create(model)
+        end
+
+        def allows_original_or_typecast_value?(value)
+          allows_value_of(value, @expected_message)
+        end
+
+        def disallows_and_double_checks_value_of!(value)
+          disallows_value_of(value, @expected_message)
         rescue ActiveModel::AllowValueMatcher::AttributeChangedValueError
-          raise ActiveModel::CouldNotSetPasswordError.create(@subject.class)
+          raise ActiveModel::CouldNotSetPasswordError.create(model)
+        end
+
+        def disallows_original_or_typecast_value?(value)
+          disallows_value_of(value, @expected_message)
+        end
+
+        def disallowed_values
+          if collection_association?
+            [Array.new]
+          elsif attachment?
+            [nil]
+          else
+            values = []
+
+            if attribute_accepts_string_values? && !expects_to_allow_blank?
+              values << ''
+            end
+
+            if !expects_to_allow_nil? && !expects_to_allow_blank?
+              values << nil
+            end
+
+            values
+          end
         end
 
-        def disallows_original_or_typecast_value?(value, message)
-          disallows_value_of(blank_value, @expected_message)
+        def should_add_footnote_about_belongs_to?
+          belongs_to_association_being_validated? &&
+            presence_validation_exists_on_attribute?
         end
 
-        def blank_value
-          if collection?
-            []
+        def reason_for_existing_presence_validation
+          if belongs_to_association_configured_to_be_required?
+            "you've instructed your `belongs_to` association to add a "\
+              'presence validation to the attribute'
           else
-            nil
+            # assume ::ActiveRecord::Base.belongs_to_required_by_default == true
+            'ActiveRecord is configured to add a presence validation to all '\
+              '`belongs_to` associations, and this includes yours'
           end
         end
 
-        def collection?
-          if reflection
-            [:has_many, :has_and_belongs_to_many].include?(reflection.macro)
+        def suggestions_for_belongs_to
+          if belongs_to_association_configured_to_be_required?
+            <<~MESSAGE
+              one of the following instead, depending on your use case:
+
+                    #{example_of_belongs_to(with: [:optional, false])}
+                    #{example_of_belongs_to(with: [:required, true])}
+            MESSAGE
           else
+            <<~MESSAGE
+              the following instead:
+
+                    #{example_of_belongs_to}
+            MESSAGE
+          end
+        end
+
+        def example_of_belongs_to(with: nil)
+          initial_call = "should belong_to(:#{association_name})"
+          inside =
+            if with
+              "#{initial_call}.#{with.first}(#{with.second})"
+            else
+              initial_call
+            end
+
+          if Shoulda::Matchers.integrations.test_frameworks.any?(&:n_unit?)
+            inside
+          else
+            "it { #{inside} }"
+          end
+        end
+
+        def belongs_to_association_configured_to_be_required?
+          association_options[:optional] == false ||
+            association_options[:required] == true
+        end
+
+        def belongs_to_association_being_validated?
+          association? && association_reflection.macro == :belongs_to
+        end
+
+        def attribute_accepts_string_values?
+          if association?
             false
+          elsif attribute_serialization_coder.respond_to?(:object_class)
+            attribute_serialization_coder.object_class == String
+          else
+            RailsShim.supports_full_attributes_api?(model) &&
+              attribute_type.try(:type) == :string
           end
         end
 
-        def reflection
-          @subject.class.respond_to?(:reflect_on_association) &&
-            @subject.class.reflect_on_association(@attribute)
+        def association?
+          association_reflection.present?
+        end
+
+        def collection_association?
+          association? && [:has_many, :has_and_belongs_to_many].include?(
+            association_reflection.macro,
+          )
+        end
+
+        def attachment?
+          model_has_associations?(
+            ["#{@attribute}_attachment", "#{@attribute}_attachments"],
+          )
+        end
+
+        def association_name
+          association_reflection.name
+        end
+
+        def association_options
+          association_reflection&.options
+        end
+
+        def association_reflection
+          model.try(:reflect_on_association, @attribute)
+        end
+
+        def model_has_associations?(associations)
+          associations.any? do |association|
+            !!model.try(:reflect_on_association, association)
+          end
+        end
+
+        def attribute_serialization_coder
+          RailsShim.attribute_serialization_coder_for(model, @attribute)
+        end
+
+        def attribute_type
+          RailsShim.attribute_type_for(model, @attribute)
+        end
+
+        def presence_validation_exists_on_attribute?
+          model._validators.include?(@attribute)
+        end
+
+        def model
+          @subject.class
         end
       end
     end

data/lib/shoulda/matchers/active_model/validation_matcher/build_description.rb

@@ -15,11 +15,10 @@ module Shoulda
 
           def call
             if description_clauses_for_qualifiers.any?
-              main_description +
-                ', ' +
-                description_clauses_for_qualifiers.to_sentence
+              "#{main_description}#{clause_for_allow_blank_or_nil},"\
+              " #{description_clauses_for_qualifiers.to_sentence}"
             else
-              main_description
+              main_description + clause_for_allow_blank_or_nil
             end
           end
 
@@ -29,14 +28,18 @@ module Shoulda
 
           private
 
-          def description_clauses_for_qualifiers
-            description_clauses = []
-
+          def clause_for_allow_blank_or_nil
             if matcher.try(:expects_to_allow_blank?)
-              description_clauses << 'but only if it is not blank'
+              ' as long as it is not blank'
             elsif matcher.try(:expects_to_allow_nil?)
-              description_clauses << 'but only if it is not nil'
+              ' as long as it is not nil'
+            else
+              ''
             end
+          end
+
+          def description_clauses_for_qualifiers
+            description_clauses = []
 
             if matcher.try(:expects_strict?)
               description_clauses << 'raising a validation exception'

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

@@ -24,6 +24,11 @@ module Shoulda
           self
         end
 
+        def allow_blank
+          options[:allow_blank] = true
+          self
+        end
+
         def strict
           @expects_strict = true
           self
@@ -51,13 +56,18 @@ module Shoulda
           false
         end
 
+        def does_not_match?(subject)
+          @subject = subject
+          true
+        end
+
         def failure_message
           overall_failure_message.dup.tap do |message|
             if failure_reason.present?
               message << "\n"
               message << Shoulda::Matchers.word_wrap(
                 failure_reason,
-                indent: 2
+                indent: 2,
               )
             end
           end
@@ -65,11 +75,11 @@ module Shoulda
 
         def failure_message_when_negated
           overall_failure_message_when_negated.dup.tap do |message|
-            if failure_reason_when_negated.present?
+            if failure_reason.present?
               message << "\n"
               message << Shoulda::Matchers.word_wrap(
-                failure_reason_when_negated,
-                indent: 2
+                failure_reason,
+                indent: 2,
               )
             end
           end
@@ -111,17 +121,31 @@ module Shoulda
           )
         end
 
+        def allow_blank_matches?
+          !expects_to_allow_blank? ||
+            blank_values.all? { |value| allows_value_of(value) }
+        end
+
+        def allow_blank_does_not_match?
+          expects_to_allow_blank? &&
+            blank_values.all? { |value| disallows_value_of(value) }
+        end
+
         private
 
+        attr_reader :options
+
         def overall_failure_message
           Shoulda::Matchers.word_wrap(
-            "#{model.name} did not properly #{description}."
+            "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 it did."
+            "Expected #{model.name} not to #{description}, but this could "\
+            'not be proved.',
           )
         end
 
@@ -154,6 +178,14 @@ module Shoulda
           @last_submatcher_run = matcher
           matcher.matches?(subject)
         end
+
+        def expects_to_allow_blank?
+          options[:allow_blank]
+        end
+
+        def blank_values
+          ['', ' ', "\n", "\r", "\t", "\f"]
+        end
       end
     end
   end

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

@@ -5,7 +5,7 @@ module Shoulda
       class ValidationMessageFinder
         include Helpers
 
-        def initialize(instance, attribute, context=nil)
+        def initialize(instance, attribute, context = nil)
           @instance = instance
           @attribute = attribute
           @context = context
@@ -50,7 +50,7 @@ module Shoulda
         end
 
         def validated_instance
-          @validated_instance ||= validate_instance
+          @_validated_instance ||= validate_instance
         end
 
         def validate_instance
@@ -58,8 +58,6 @@ module Shoulda
           @instance
         end
       end
-
     end
   end
 end
-

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

@@ -98,24 +98,19 @@ module Shoulda
 
           all_validation_errors = record.errors.dup
 
-          validation_error_messages =
-            if record.errors.respond_to?(:[])
-              record.errors[attribute]
-            else
-              record.errors.on(attribute)
-            end
+          validation_error_messages = record.errors[attribute]
 
           {
             all_validation_errors: all_validation_errors,
             validation_error_messages: validation_error_messages,
-            validation_exception_message: nil
+            validation_exception_message: nil,
           }
-        rescue ::ActiveModel::StrictValidationFailed => exception
+        rescue ::ActiveModel::StrictValidationFailed => e
           @captured_validation_exception = true
           {
             all_validation_errors: nil,
             validation_error_messages: [],
-            validation_exception_message: exception.message
+            validation_exception_message: e.message,
           }
         end
       end

data/lib/shoulda/matchers/active_model.rb

@@ -26,15 +26,13 @@ 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/allow_mass_assignment_of_matcher'
 require 'shoulda/matchers/active_model/errors'
 require 'shoulda/matchers/active_model/have_secure_password_matcher'
 
 module Shoulda
   module Matchers
-    # This mixin provides matchers that are used to test behavior, such as
-    # validations, that you've added to your ActiveModel (or ActiveRecord)
-    # objects.
+    # This module provides matchers that are used to test behavior within
+    # ActiveModel or ActiveRecord classes.
     #
     # ### Testing conditional validations
     #
@@ -60,7 +58,7 @@ module Shoulda
     #     end
     #
     #     # RSpec
-    #     describe User do
+    #     RSpec.describe User, type: :model do
     #       context "when an admin" do
     #         subject { User.new(admin: true) }
     #

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

@@ -9,7 +9,7 @@ module Shoulda
       #     end
       #
       #     # RSpec
-      #     describe Car do
+      #     RSpec.describe Car, type: :model do
       #       it { should accept_nested_attributes_for(:doors) }
       #     end
       #
@@ -30,7 +30,7 @@ module Shoulda
       #     end
       #
       #     # RSpec
-      #     describe Car do
+      #     RSpec.describe Car, type: :model do
       #       it do
       #         should accept_nested_attributes_for(:mirrors).
       #           allow_destroy(true)
@@ -52,7 +52,7 @@ module Shoulda
       #     end
       #
       #     # RSpec
-      #     describe Car do
+      #     RSpec.describe Car, type: :model do
       #       it do
       #         should accept_nested_attributes_for(:windows).
       #           limit(3)
@@ -75,7 +75,7 @@ module Shoulda
       #     end
       #
       #     # RSpec
-      #     describe Car do
+      #     RSpec.describe Car, type: :model do
       #       it do
       #         should accept_nested_attributes_for(:engine).
       #           update_only(true)
@@ -158,17 +158,20 @@ module Shoulda
         end
 
         def allow_destroy_correct?
-          failure_message = "#{should_or_should_not(@options[:allow_destroy])} allow destroy"
+          failure_message = "#{should_or_should_not(@options[:allow_destroy])}"\
+            ' allow destroy'
           verify_option_is_correct(:allow_destroy, failure_message)
         end
 
         def limit_correct?
-          failure_message = "limit should be #{@options[:limit]}, got #{config[:limit]}"
+          failure_message = "limit should be #{@options[:limit]},"\
+            " got #{config[:limit]}"
           verify_option_is_correct(:limit, failure_message)
         end
 
         def update_only_correct?
-          failure_message = "#{should_or_should_not(@options[:update_only])} be update only"
+          failure_message = "#{should_or_should_not(@options[:update_only])}"\
+            ' be update only'
           verify_option_is_correct(:update_only, failure_message)
         end