shoulda-matchers 1.3.0 → 1.4.0

data/lib/shoulda/matchers/action_controller/set_the_flash_matcher.rb

@@ -25,6 +25,9 @@ module Shoulda # :nodoc:
         attr_reader :failure_message, :negative_failure_message
 
         def to(value)
+          if !value.is_a?(String) && !value.is_a?(Regexp)
+            raise "cannot match against #{value.inspect}"
+          end
           @value = value
           self
         end
@@ -134,7 +137,7 @@ module Shoulda # :nodoc:
 
         def pretty_key
           if @options[:key]
-            "[:#{@key}]"
+            "[:#{@options[:key]}]"
           else
             ""
           end

data/lib/shoulda/matchers/active_model.rb

@@ -1,5 +1,7 @@
 require 'shoulda/matchers/active_model/helpers'
 require 'shoulda/matchers/active_model/validation_matcher'
+require 'shoulda/matchers/active_model/validation_message_finder'
+require 'shoulda/matchers/active_model/exception_message_finder'
 require 'shoulda/matchers/active_model/allow_value_matcher'
 require 'shoulda/matchers/active_model/ensure_length_of_matcher'
 require 'shoulda/matchers/active_model/ensure_inclusion_of_matcher'
@@ -11,6 +13,7 @@ require 'shoulda/matchers/active_model/validate_acceptance_of_matcher'
 require 'shoulda/matchers/active_model/validate_confirmation_of_matcher'
 require 'shoulda/matchers/active_model/validate_numericality_of_matcher'
 require 'shoulda/matchers/active_model/allow_mass_assignment_of_matcher'
+require 'shoulda/matchers/active_model/errors'
 
 
 module Shoulda
@@ -27,8 +30,19 @@ module Shoulda
     #     end
     #     it { should allow_value("(123) 456-7890").for(:phone_number) }
     #     it { should_not allow_mass_assignment_of(:password) }
+    #     it { should allow_value('Activated', 'Pending').for(:status).strict }
+    #     it { should_not allow_value('Amazing').for(:status).strict }
     #   end
     #
+    # These tests work with the following model:
+    #
+    # class User < ActiveRecord::Base
+    #   validates_presence_of :name
+    #   validates_presence_of :phone_number
+    #   validates_format_of :phone_number, :with => /\\(\\d{3}\\) \\d{3}\\-\\d{4}/
+    #   validates_inclusion_of :status, :in => %w(Activated Pending), :strict => true
+    #   attr_accessible :name, :phone_number
+    # end
     module ActiveModel
     end
   end

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

@@ -11,6 +11,9 @@ module Shoulda # :nodoc:
       # * <tt>with_message</tt> - value the test expects to find in
       #   <tt>errors.on(:attribute)</tt>. Regexp or string. If omitted,
       #   the test looks for any errors in <tt>errors.on(:attribute)</tt>.
+      # * <tt>strict</tt> - expects the model to raise an exception when the
+      #   validation fails rather than adding to the errors collection. Used for
+      #   testing `validates!` and the `:strict => true` validation options.
       #
       # Example:
       #   it { should_not allow_value('bad').for(:isbn) }
@@ -29,6 +32,7 @@ module Shoulda # :nodoc:
 
         def initialize(*values)
           @values_to_match = values
+          @message_finder_factory = ValidationMessageFinder
           @options = {}
         end
 
@@ -42,6 +46,11 @@ module Shoulda # :nodoc:
           self
         end
 
+        def strict
+          @message_finder_factory = ExceptionMessageFinder
+          self
+        end
+
         def matches?(instance)
           @instance = instance
           @values_to_match.none? do |value|
@@ -60,30 +69,29 @@ module Shoulda # :nodoc:
         end
 
         def description
-          "allow #{@attribute} to be set to #{allowed_values}"
+          message_finder.allow_description(allowed_values)
         end
 
         private
 
         def errors_match?
-          if @instance.valid?
-            false
+          has_messages? && errors_for_attribute_match?
+        end
+
+        def has_messages?
+          message_finder.has_messages?
+        end
+
+        def errors_for_attribute_match?
+          if expected_message
+            @matched_error = errors_match_regexp? || errors_match_string?
           else
-            if expected_message
-              @matched_error = errors_match_regexp? || errors_match_string?
-            else
-              errors_for_attribute.compact.any?
-            end
+            errors_for_attribute.compact.any?
           end
         end
 
         def errors_for_attribute
-          if @instance.errors.respond_to?(:[])
-            errors = @instance.errors[@attribute]
-          else
-            errors = @instance.errors.on(@attribute)
-          end
-          Array.wrap(errors)
+          message_finder.messages
         end
 
         def errors_match_regexp?
@@ -100,15 +108,15 @@ module Shoulda # :nodoc:
 
         def expectation
           includes_expected_message = expected_message ? "to include #{expected_message.inspect}" : ''
-          ["errors", includes_expected_message, "when #{@attribute} is set to #{@value.inspect}"].join(' ')
+          [error_source, includes_expected_message, "when #{@attribute} is set to #{@value.inspect}"].join(' ')
+        end
+
+        def error_source
+          message_finder.source_description
         end
 
         def error_description
-          if @instance.errors.empty?
-            "no errors"
-          else
-            "errors: #{pretty_error_messages(@instance)}"
-          end
+          message_finder.messages_description
         end
 
         def allowed_values
@@ -122,16 +130,32 @@ module Shoulda # :nodoc:
         def expected_message
           if @options.key?(:expected_message)
             if Symbol === @options[:expected_message]
-              default_error_message(@options[:expected_message], :model_name => model_name, :attribute => @attribute)
+              default_expected_message
             else
               @options[:expected_message]
             end
           end
         end
 
+        def default_expected_message
+          message_finder.expected_message_from(default_attribute_message)
+        end
+
+        def default_attribute_message
+          default_error_message(
+            @options[:expected_message],
+            :model_name => model_name,
+            :attribute => @attribute
+          )
+        end
+
         def model_name
           @instance.class.to_s.underscore
         end
+
+        def message_finder
+          @message_finder ||= @message_finder_factory.new(@instance, @attribute)
+        end
       end
     end
   end

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

@@ -5,6 +5,7 @@ module Shoulda # :nodoc:
       # Ensure that the attribute's value is not in the range specified
       #
       # Options:
+      # * <tt>in_array</tt> - the array of not allowed values for this attribute
       # * <tt>in_range</tt> - the range of not allowed values for this attribute
       # * <tt>with_message</tt> - value the test expects to find in
       #   <tt>errors.on(:attribute)</tt>. Regexp or string. Defaults to the
@@ -18,6 +19,10 @@ module Shoulda # :nodoc:
       end
 
       class EnsureExclusionOfMatcher < ValidationMatcher # :nodoc:
+        def in_array(array)
+          @array = array
+          self
+        end
 
         def in_range(range)
           @range = range
@@ -32,20 +37,30 @@ module Shoulda # :nodoc:
         end
 
         def description
-          "ensure exclusion of #{@attribute} in #{@range.inspect}"
+          "ensure exclusion of #{@attribute} in #{inspect_message}"
         end
 
         def matches?(subject)
           super(subject)
 
-          allows_lower_value &&
-            disallows_minimum_value &&
-            allows_higher_value &&
-            disallows_maximum_value
+          if @range
+            allows_lower_value &&
+              disallows_minimum_value &&
+              allows_higher_value &&
+              disallows_maximum_value
+          elsif @array
+            disallows_all_values_in_array?
+          end
         end
 
         private
 
+        def disallows_all_values_in_array?
+          @array.all? do |value|
+            disallows_value_of(value, expected_message)
+          end
+        end
+
         def allows_lower_value
           @minimum == 0 || allows_value_of(@minimum - 1, expected_message)
         end
@@ -65,8 +80,15 @@ module Shoulda # :nodoc:
         def expected_message
           @expected_message || :exclusion
         end
-      end
 
+        def inspect_message
+          if @range
+            @range.inspect
+          else
+            @array.inspect
+          end
+        end
+      end
     end
   end
 end

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

@@ -5,7 +5,7 @@ module Shoulda # :nodoc:
       # Ensure that the attribute's value is in the range specified
       #
       # Options:
-      # * <tt>in_array</tt> - the range of allowed values for this attribute
+      # * <tt>in_array</tt> - the array of allowed values for this attribute
       # * <tt>in_range</tt> - the range of allowed values for this attribute
       # * <tt>with_low_message</tt> - value the test expects to find in
       #   <tt>errors.on(:attribute)</tt>. Regexp or string. Defaults to the
@@ -83,7 +83,7 @@ module Shoulda # :nodoc:
               disallows_higher_value &&
               allows_maximum_value
           elsif @array
-            if allows_all_values_in_array? && allows_blank_value? && allows_nil_value?
+            if allows_all_values_in_array? && allows_blank_value? && allows_nil_value? && disallows_value_outside_of_array?
               true
             else
               @failure_message = "#{@array} doesn't match array in validation"
@@ -96,7 +96,8 @@ module Shoulda # :nodoc:
 
         def allows_blank_value?
           if @options.key?(:allow_blank)
-            @options[:allow_blank] == allows_value_of('')
+            blank_values = ['', ' ', "\n", "\r", "\t", "\f"]
+            @options[:allow_blank] == blank_values.all? { |value| allows_value_of(value) }
           else
             true
           end
@@ -135,8 +136,25 @@ module Shoulda # :nodoc:
         def allows_maximum_value
           allows_value_of(@maximum, @high_message)
         end
-      end
 
+        def disallows_value_outside_of_array?
+          if value_outside_of_array
+            disallows_value_of(value_outside_of_array)
+          else
+            raise CouldNotDetermineValueOutsideOfArray
+          end
+        end
+
+        def value_outside_of_array
+          found = @array.detect do |item|
+            !@array.include?(item.next)
+          end
+
+          if found
+            found.next
+          end
+        end
+      end
     end
   end
 end

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

@@ -58,6 +58,7 @@ module Shoulda # :nodoc:
           @options[:minimum] = length
           @options[:maximum] = length
           @short_message ||= :wrong_length
+          @long_message ||= :wrong_length
           self
         end
 

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

@@ -0,0 +1,7 @@
+module Shoulda # :nodoc:
+  module Matchers
+    module ActiveModel # :nodoc:
+      class CouldNotDetermineValueOutsideOfArray < RuntimeError; end
+    end
+  end
+end

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

@@ -0,0 +1,58 @@
+module Shoulda
+  module Matchers
+    module ActiveModel
+
+      # Finds message information from exceptions thrown by #valid?
+      class ExceptionMessageFinder
+        def initialize(instance, attribute)
+          @instance = instance
+          @attribute = attribute
+        end
+
+        def allow_description(allowed_values)
+          "doesn't raise when #{@attribute} is set to #{allowed_values}"
+        end
+
+        def messages_description
+          if has_messages?
+            messages.join
+          else
+            'no exception'
+          end
+        end
+
+        def has_messages?
+          messages.any?
+        end
+
+        def messages
+          @messages ||= validate_and_rescue
+        end
+
+        def source_description
+          'exception'
+        end
+
+        def expected_message_from(attribute_message)
+          "#{human_attribute_name} #{attribute_message}"
+        end
+
+        private
+
+        def validate_and_rescue
+          @instance.valid?
+          []
+        rescue ::ActiveModel::StrictValidationFailed => exception
+          [exception.message]
+        end
+
+        def human_attribute_name
+          @instance.class.human_attribute_name(@attribute)
+        end
+      end
+
+    end
+  end
+end
+
+

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

@@ -122,7 +122,7 @@ module Shoulda # :nodoc:
               previous_value = existing.send(scope)
 
               # Assume the scope is a foreign key if the field is nil
-              previous_value ||= 0
+              previous_value ||= correct_type_for_column(@subject.class.columns_hash[scope.to_s])
 
               next_value = if previous_value.respond_to?(:next)
                 previous_value.next
@@ -146,6 +146,14 @@ module Shoulda # :nodoc:
           end
         end
 
+        def correct_type_for_column(column)
+          if column.type == :string
+            '0'
+          else
+            0
+          end
+        end
+
         def class_name
           @subject.class.name
         end

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

@@ -6,6 +6,12 @@ module Shoulda # :nodoc:
 
         def initialize(attribute)
           @attribute = attribute
+          @strict = false
+        end
+
+        def strict
+          @strict = true
+          self
         end
 
         def negative_failure_message
@@ -20,10 +26,8 @@ module Shoulda # :nodoc:
         private
 
         def allows_value_of(value, message = nil)
-          allow = AllowValueMatcher.
-            new(value).
-            for(@attribute).
-            with_message(message)
+          allow = allow_value_matcher(value, message)
+
           if allow.matches?(@subject)
             @negative_failure_message = allow.failure_message
             true
@@ -34,10 +38,8 @@ module Shoulda # :nodoc:
         end
 
         def disallows_value_of(value, message = nil)
-          disallow = AllowValueMatcher.
-            new(value).
-            for(@attribute).
-            with_message(message)
+          disallow = allow_value_matcher(value, message)
+
           if disallow.matches?(@subject)
             @failure_message = disallow.negative_failure_message
             false
@@ -46,6 +48,23 @@ module Shoulda # :nodoc:
             true
           end
         end
+
+        def allow_value_matcher(value, message)
+          matcher = AllowValueMatcher.
+            new(value).
+            for(@attribute).
+            with_message(message)
+
+          if strict?
+            matcher.strict
+          else
+            matcher
+          end
+        end
+
+        def strict?
+          @strict
+        end
       end
     end
   end