shoulda-matchers 3.0.1 → 3.1.0

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

@@ -3,13 +3,20 @@ module Shoulda
     module ActiveModel
       # @private
       class ValidationMatcher
-        attr_reader :failure_message
+        include Qualifiers::IgnoringInterferenceByWriter
 
         def initialize(attribute)
+          super
           @attribute = attribute
-          @strict = false
-          @failure_message = nil
-          @failure_message_when_negated = nil
+          @expects_strict = false
+          @subject = nil
+          @last_submatcher_run = nil
+          @expected_message = nil
+          @expects_custom_validation_message = false
+        end
+
+        def description
+          ValidationMatcher::BuildDescription.call(self, simple_description)
         end
 
         def on(context)
@@ -18,12 +25,25 @@ module Shoulda
         end
 
         def strict
-          @strict = true
+          @expects_strict = true
           self
         end
 
-        def failure_message_when_negated
-          @failure_message_when_negated || @failure_message
+        def expects_strict?
+          @expects_strict
+        end
+
+        def with_message(expected_message)
+          if expected_message
+            @expects_custom_validation_message = true
+            @expected_message = expected_message
+          end
+
+          self
+        end
+
+        def expects_custom_validation_message?
+          @expects_custom_validation_message
         end
 
         def matches?(subject)
@@ -31,66 +51,108 @@ module Shoulda
           false
         end
 
-        private
+        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
+              )
+            end
+          end
+        end
 
-        def allows_value_of(value, message = nil, &block)
-          allow = allow_value_matcher(value, message)
-          yield allow if block_given?
-
-          if allow.matches?(@subject)
-            @failure_message_when_negated = allow.failure_message_when_negated
-            true
-          else
-            @failure_message = allow.failure_message
-            false
+        def failure_message_when_negated
+          overall_failure_message_when_negated.dup.tap do |message|
+            if failure_reason_when_negated.present?
+              message << "\n"
+              message << Shoulda::Matchers.word_wrap(
+                failure_reason_when_negated,
+                indent: 2
+              )
+            end
           end
         end
 
+        protected
+
+        attr_reader :attribute, :context, :subject, :last_submatcher_run
+
+        def model
+          subject.class
+        end
+
+        def allows_value_of(value, message = nil, &block)
+          matcher = allow_value_matcher(value, message, &block)
+          run_allow_or_disallow_matcher(matcher)
+        end
+
         def disallows_value_of(value, message = nil, &block)
-          disallow = disallow_value_matcher(value, message)
-          yield disallow if block_given?
-
-          if disallow.matches?(@subject)
-            @failure_message_when_negated = disallow.failure_message_when_negated
-            true
-          else
-            @failure_message = disallow.failure_message
-            false
-          end
+          matcher = disallow_value_matcher(value, message, &block)
+          run_allow_or_disallow_matcher(matcher)
         end
 
-        def allow_value_matcher(value, message)
-          matcher = AllowValueMatcher.new(value).for(@attribute).
-            with_message(message)
+        def allow_value_matcher(value, message = nil, &block)
+          build_allow_or_disallow_value_matcher(
+            matcher_class: AllowValueMatcher,
+            value: value,
+            message: message,
+            &block
+          )
+        end
 
-          if defined?(@context)
-            matcher.on(@context)
-          end
+        def disallow_value_matcher(value, message = nil, &block)
+          build_allow_or_disallow_value_matcher(
+            matcher_class: DisallowValueMatcher,
+            value: value,
+            message: message,
+            &block
+          )
+        end
 
-          if strict?
-            matcher.strict
-          end
+        private
 
-          matcher
+        def overall_failure_message
+          Shoulda::Matchers.word_wrap(
+            "#{model.name} did not properly #{description}."
+          )
         end
 
-        def disallow_value_matcher(value, message)
-          matcher = DisallowValueMatcher.new(value).for(@attribute).
-            with_message(message)
+        def overall_failure_message_when_negated
+          Shoulda::Matchers.word_wrap(
+            "Expected #{model.name} not to #{description}, but it did."
+          )
+        end
 
-          if defined?(@context)
-            matcher.on(@context)
-          end
+        def failure_reason
+          last_submatcher_run.try(:failure_message)
+        end
 
-          if strict?
-            matcher.strict
-          end
+        def failure_reason_when_negated
+          last_submatcher_run.try(:failure_message_when_negated)
+        end
+
+        def build_allow_or_disallow_value_matcher(args)
+          matcher_class = args.fetch(:matcher_class)
+          value = args.fetch(:value)
+          message = args[:message]
+
+          matcher = matcher_class.new(value).
+            for(attribute).
+            with_message(message).
+            on(context).
+            strict(expects_strict?).
+            ignoring_interference_by_writer(ignore_interference_by_writer)
+
+          yield matcher if block_given?
 
           matcher
         end
 
-        def strict?
-          @strict
+        def run_allow_or_disallow_matcher(matcher)
+          @last_submatcher_run = matcher
+          matcher.matches?(subject)
         end
       end
     end

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

@@ -0,0 +1,60 @@
+module Shoulda
+  module Matchers
+    module ActiveModel
+      class ValidationMatcher
+        # @private
+        class BuildDescription
+          def self.call(matcher, main_description)
+            new(matcher, main_description).call
+          end
+
+          def initialize(matcher, main_description)
+            @matcher = matcher
+            @main_description = main_description
+          end
+
+          def call
+            if description_clauses_for_qualifiers.any?
+              main_description +
+                ', ' +
+                description_clauses_for_qualifiers.to_sentence
+            else
+              main_description
+            end
+          end
+
+          protected
+
+          attr_reader :matcher, :main_description
+
+          private
+
+          def description_clauses_for_qualifiers
+            description_clauses = []
+
+            if matcher.try(:expects_to_allow_blank?)
+              description_clauses << 'but only if it is not blank'
+            elsif matcher.try(:expects_to_allow_nil?)
+              description_clauses << 'but only if it is not nil'
+            end
+
+            if matcher.try(:expects_strict?)
+              description_clauses << 'raising a validation exception'
+
+              if matcher.try(:expects_custom_validation_message?)
+                description_clauses.last << ' with a custom message'
+              end
+
+              description_clauses.last << ' on failure'
+            elsif matcher.try(:expects_custom_validation_message?)
+              description_clauses <<
+                'producing a custom validation error on failure'
+            end
+
+            description_clauses
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -5,99 +5,118 @@ module Shoulda
       class Validator
         include Helpers
 
-        attr_writer :attribute, :context, :record
+        def initialize(record, attribute, options = {})
+          @record = record
+          @attribute = attribute
+          @context = options[:context]
+          @expects_strict = options[:expects_strict]
+          @expected_message = options[:expected_message]
 
-        def initialize
-          reset
+          @_validation_result = nil
+          @captured_validation_exception = false
+          @captured_range_error = false
         end
 
-        def reset
-          @messages = nil
+        def call
+          !messages_match? && !captured_range_error?
         end
 
-        def strict=(strict)
-          @strict = strict
+        def has_messages?
+          messages.any?
+        end
 
-          if strict
-            extend StrictValidator
-          end
+        def captured_validation_exception?
+          @captured_validation_exception
         end
 
-        def allow_description(allowed_values)
-          "allow #{attribute} to be set to #{allowed_values}"
+        def type_of_message_matched?
+          expects_strict? == captured_validation_exception?
         end
 
-        def expected_message_from(attribute_message)
-          attribute_message
+        def all_formatted_validation_error_messages
+          format_validation_errors(all_validation_errors)
         end
 
-        def messages
-          @messages ||= collect_messages
+        def validation_exception_message
+          validation_result[:validation_exception_message]
         end
 
-        def formatted_messages
-          messages
+        protected
+
+        attr_reader :attribute, :context, :record
+
+        private
+
+        def expects_strict?
+          @expects_strict
         end
 
-        def has_messages?
-          messages.any?
+        def messages_match?
+          has_messages? &&
+            type_of_message_matched? &&
+            matched_messages.compact.any?
         end
 
-        def messages_description
-          if has_messages?
-            " errors:\n#{pretty_error_messages(record)}"
+        def messages
+          if expects_strict?
+            [validation_exception_message]
           else
-            ' no errors'
+            validation_error_messages
           end
         end
 
-        def expected_messages_description(expected_message)
-          if expected_message
-            "errors to include #{expected_message.inspect}"
+        def matched_messages
+          if @expected_message
+            messages.grep(@expected_message)
           else
-            'errors'
+            messages
           end
         end
 
         def captured_range_error?
-          !!captured_range_error
+          !!@captured_range_error
         end
 
-        protected
-
-        attr_reader :attribute, :context, :strict, :record,
-          :captured_range_error
-
-        def collect_messages
-          validation_errors
+        def all_validation_errors
+          validation_result[:all_validation_errors]
         end
 
-        private
-
-        def strict?
-          !!@strict
+        def validation_error_messages
+          validation_result[:validation_error_messages]
         end
 
-        def collect_errors_or_exceptions
-          collect_messages
+        def validation_result
+          @_validation_result ||= perform_validation
         end
 
-        def validation_errors
+        def perform_validation
           if context
             record.valid?(context)
           else
             record.valid?
           end
 
-          if record.errors.respond_to?(:[])
-            record.errors[attribute]
-          else
-            record.errors.on(attribute)
-          end
-        end
-
-        def human_attribute_name
-          record.class.human_attribute_name(attribute)
+          all_validation_errors = record.errors.dup
+
+          validation_error_messages =
+            if record.errors.respond_to?(:[])
+              record.errors[attribute]
+            else
+              record.errors.on(attribute)
+            end
+
+          {
+            all_validation_errors: all_validation_errors,
+            validation_error_messages: validation_error_messages,
+            validation_exception_message: nil
+          }
+        rescue ::ActiveModel::StrictValidationFailed => exception
+          @captured_validation_exception = true
+          {
+            all_validation_errors: nil,
+            validation_error_messages: [],
+            validation_exception_message: exception.message
+          }
         end
       end
     end

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

@@ -63,8 +63,8 @@ module Shoulda
         end
 
         def matches?(subject)
-          @model = subject
-          enum_defined? && enum_values_match?
+          @record = subject
+          enum_defined? && enum_values_match? && column_type_is_integer?
         end
 
         def failure_message
@@ -84,15 +84,17 @@ module Shoulda
             desc << " with #{options[:expected_enum_values]}"
           end
 
+          desc << " and store the value in a column with an integer type"
+
           desc
         end
 
         protected
 
-        attr_reader :model, :attribute_name, :options
+        attr_reader :record, :attribute_name, :options
 
         def expectation
-          "#{model.class.name} to #{description}"
+          "#{model.name} to #{description}"
         end
 
         def expected_enum_values
@@ -100,7 +102,7 @@ module Shoulda
         end
 
         def actual_enum_values
-          model.class.send(attribute_name.to_s.pluralize)
+          model.send(attribute_name.to_s.pluralize)
         end
 
         def enum_defined?
@@ -111,6 +113,18 @@ module Shoulda
           expected_enum_values.empty? || actual_enum_values == expected_enum_values
         end
 
+        def column_type_is_integer?
+          column.type == :integer
+        end
+
+        def column
+          model.columns_hash[attribute_name.to_s]
+        end
+
+        def model
+          record.class
+        end
+
         def hashify(value)
           if value.nil?
             return {}