shoulda-matchers 1.4.2 → 1.5.0

data/lib/shoulda/matchers/active_model.rb

@@ -30,7 +30,7 @@ module Shoulda
     #     %w(abcd 1234).each do |value|
     #       it { should_not allow_value(value).for(:phone_number) }
     #     end
-    #     it { should allow_value("(123) 456-7890").for(:phone_number) }
+    #     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 }

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

@@ -16,7 +16,7 @@ module Shoulda # :nodoc:
       end
 
       class AllowMassAssignmentOfMatcher # :nodoc:
-        attr_reader :failure_message, :negative_failure_message
+        attr_reader :failure_message_for_should, :failure_message_for_should_not
 
         def initialize(attribute)
           @attribute = attribute.to_s
@@ -25,7 +25,7 @@ module Shoulda # :nodoc:
 
         def as(role)
           if active_model_less_than_3_1?
-            raise "You can specify role only in Rails 3.1 or greater"
+            raise 'You can specify role only in Rails 3.1 or greater'
           end
           @options[:role] = role
           self
@@ -35,12 +35,12 @@ module Shoulda # :nodoc:
           @subject = subject
           if attr_mass_assignable?
             if whitelisting?
-              @negative_failure_message = "#{@attribute} was made accessible"
+              @failure_message_for_should_not = "#{@attribute} was made accessible"
             else
               if protected_attributes.empty?
-                @negative_failure_message = "no attributes were protected"
+                @failure_message_for_should_not = 'no attributes were protected'
               else
-                @negative_failure_message = "#{class_name} is protecting " <<
+                @failure_message_for_should_not = "#{class_name} is protecting " <<
                   "#{protected_attributes.to_a.to_sentence}, " <<
                   "but not #{@attribute}."
               end
@@ -48,16 +48,16 @@ module Shoulda # :nodoc:
             true
           else
             if whitelisting?
-              @failure_message = "Expected #{@attribute} to be accessible"
+              @failure_message_for_should = "Expected #{@attribute} to be accessible"
             else
-              @failure_message = "Did not expect #{@attribute} to be protected"
+              @failure_message_for_should = "Did not expect #{@attribute} to be protected"
             end
             false
           end
         end
 
         def description
-          [base_description, role_description].compact.join(" ")
+          [base_description, role_description].compact.join(' ')
         end
 
         private

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

@@ -17,11 +17,11 @@ module Shoulda # :nodoc:
       #
       # Example:
       #   it { should_not allow_value('bad').for(:isbn) }
-      #   it { should allow_value("isbn 1 2345 6789 0").for(:isbn) }
+      #   it { should allow_value('isbn 1 2345 6789 0').for(:isbn) }
       #
       def allow_value(*values)
         if values.empty?
-          raise ArgumentError, "need at least one argument"
+          raise ArgumentError, 'need at least one argument'
         else
           AllowValueMatcher.new(*values)
         end
@@ -60,11 +60,11 @@ module Shoulda # :nodoc:
           end
         end
 
-        def failure_message
+        def failure_message_for_should
           "Did not expect #{expectation}, got error: #{@matched_error}"
         end
 
-        def negative_failure_message
+        def failure_message_for_should_not
           "Expected #{expectation}, got #{error_description}"
         end
 
@@ -145,6 +145,7 @@ module Shoulda # :nodoc:
           default_error_message(
             @options[:expected_message],
             :model_name => model_name,
+            :instance => @instance,
             :attribute => @attribute
           )
         end

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

@@ -20,12 +20,12 @@ module Shoulda # :nodoc:
           self
         end
 
-        def failure_message
-          @allow_matcher.negative_failure_message
+        def failure_message_for_should
+          @allow_matcher.failure_message_for_should_not
         end
 
         def allowed_types
-          ""
+          ''
         end
       end
     end

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

@@ -22,7 +22,7 @@ module Shoulda # :nodoc:
       end
 
       class EnsureInclusionOfMatcher < ValidationMatcher # :nodoc:
-        ARBITRARY_OUTSIDE_STRING = "shouldamatchersteststring"
+        ARBITRARY_OUTSIDE_STRING = 'shouldamatchersteststring'
 
         def initialize(attribute)
           super(attribute)
@@ -88,7 +88,7 @@ module Shoulda # :nodoc:
             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"
+              @failure_message_for_should = "#{@array} doesn't match array in validation"
               false
             end
           end

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

@@ -1,7 +1,6 @@
 module Shoulda
   module Matchers
     module ActiveModel
-
       # Finds message information from exceptions thrown by #valid?
       class ExceptionMessageFinder
         def initialize(instance, attribute)

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

@@ -11,21 +11,30 @@ module Shoulda # :nodoc:
 
         # Helper method that determines the default error message used by Active
         # Record.  Works for both existing Rails 2.1 and Rails 2.2 with the newly
-        # introduced I18n module used for localization.
+        # introduced I18n module used for localization. Use with Rails 3.0 and
+        # up will delegate to ActiveModel::Errors.generate_error if a model
+        # instance is given.
         #
         #   default_error_message(:blank)
         #   default_error_message(:too_short, :count => 5)
         #   default_error_message(:too_long, :count => 60)
         #   default_error_message(:blank, :model_name => 'user', :attribute => 'name')
+        #   default_error_message(:blank, :instance => #<Model>, :attribute => 'name')
         def default_error_message(key, options = {})
           model_name = options.delete(:model_name)
           attribute = options.delete(:attribute)
-          default_translation = [ :"activerecord.errors.models.#{model_name}.#{key}",
-                                  :"activerecord.errors.messages.#{key}",
-                                  :"errors.attributes.#{attribute}.#{key}",
-                                  :"errors.messages.#{key}" ]
-          I18n.translate(:"activerecord.errors.models.#{model_name}.attributes.#{attribute}.#{key}",
-            { :default => default_translation }.merge(options))
+          instance = options.delete(:instance)
+
+          if instance && instance.errors.respond_to?(:generate_message)
+            instance.errors.generate_message(attribute.to_sym, key, {})
+          else
+            default_translation = [ :"activerecord.errors.models.#{model_name}.#{key}",
+                                    :"activerecord.errors.messages.#{key}",
+                                    :"errors.attributes.#{attribute}.#{key}",
+                                    :"errors.messages.#{key}" ]
+            I18n.translate(:"activerecord.errors.models.#{model_name}.attributes.#{attribute}.#{key}",
+              { :default => default_translation }.merge(options))
+          end
         end
       end
     end

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

@@ -21,11 +21,11 @@ module Shoulda # :nodoc:
         end
 
         def allowed_types
-          "integer"
+          'integer'
         end
 
-        def failure_message
-          @disallow_value_matcher.failure_message
+        def failure_message_for_should
+          @disallow_value_matcher.failure_message_for_should
         end
       end
     end

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

@@ -39,23 +39,25 @@ module Shoulda # :nodoc:
         private
 
         def disallows_different_value
-          set_confirmation("some value")
-          matches = disallows_value_of("different value", @message)
+          set_confirmation('some value')
+          disallows_value_of('different value', @message)
         end
 
         def allows_same_value
-          set_confirmation("same value")
-          allows_value_of("same value", @message)
+          set_confirmation('same value')
+          allows_value_of('same value', @message)
         end
 
         def allows_missing_confirmation
           set_confirmation(nil)
-          allows_value_of("any value", @message)
+          allows_value_of('any value', @message)
         end
 
         def set_confirmation(val)
           setter = :"#{@confirmation}="
-          @subject.send(setter, val) if @subject.respond_to?(setter)
+          if @subject.respond_to?(setter)
+            @subject.send(setter, val)
+          end
         end
       end
     end

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

@@ -1,7 +1,8 @@
+require 'active_support/deprecation'
+
 module Shoulda # :nodoc:
   module Matchers
     module ActiveModel # :nodoc:
-
       # Ensures that the model is not valid if the given attribute is not
       # formatted correctly.
       #
@@ -27,8 +28,8 @@ module Shoulda # :nodoc:
       end
 
       class ValidateFormatOfMatcher < ValidationMatcher # :nodoc:
-
         def initialize(attribute)
+          ActiveSupport::Deprecation.warn 'The validate_format_of matcher is deprecated and will be removed in 2.0'
           super
           @options = {}
         end
@@ -44,20 +45,28 @@ module Shoulda # :nodoc:
         end
 
         def with_message(message)
-          @expected_message = message if message
+          if message
+            @expected_message = message
+          end
           self
         end
 
         def with(value)
-          raise "You may not call both with and not_with" if @value_to_fail
-          @value_to_pass = value
-          self
+          if @value_to_fail
+            raise 'You may not call both with and not_with'
+          else
+            @value_to_pass = value
+            self
+          end
         end
 
         def not_with(value)
-          raise "You may not call both with and not_with" if @value_to_pass
-          @value_to_fail = value
-          self
+          if @value_to_pass
+            raise 'You may not call both with and not_with'
+          else
+            @value_to_fail = value
+            self
+          end
         end
 
         def matches?(subject)
@@ -72,7 +81,7 @@ module Shoulda # :nodoc:
         end
 
         def description
-          "#{@attribute} have a valid format"
+          "have a valid format for #{@attribute}"
         end
 
         private

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

@@ -48,7 +48,7 @@ module Shoulda # :nodoc:
           "only allow #{allowed_types} values for #{@attribute}"
         end
 
-        def failure_message
+        def failure_message_for_should
           submatcher_failure_messages.last
         end
 
@@ -71,7 +71,7 @@ module Shoulda # :nodoc:
         end
 
         def submatcher_failure_messages
-          failing_submatchers.map(&:failure_message)
+          failing_submatchers.map(&:failure_message_for_should)
         end
 
         def failing_submatchers
@@ -79,8 +79,8 @@ module Shoulda # :nodoc:
         end
 
         def allowed_types
-          allowed = ["numeric"] + submatcher_allowed_types
-          allowed.join(", ")
+          allowed = ['numeric'] + submatcher_allowed_types
+          allowed.join(', ')
         end
 
         def submatcher_allowed_types

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

@@ -1,17 +1,15 @@
 module Shoulda # :nodoc:
   module Matchers
     module ActiveModel # :nodoc:
-
       # Ensures that the model is invalid if the given attribute is not unique.
+      # It uses the first existing record or creates a new one if no record
+      # exists in the database. It simply uses `:validate => false` to get
+      # around validations, so it will probably fail if there are `NOT NULL`
+      # constraints. In that case, you must create a record before calling
+      # `validate_uniqueness_of`.
       #
-      # Internally, this uses values from existing records to test validations,
-      # so this will always fail if you have not saved at least one record for
-      # the model being tested, like so:
-      #
-      #   describe User do
-      #     before(:each) { User.create!(:email => 'address@example.com') }
-      #     it { should validate_uniqueness_of(:email) }
-      #   end
+      # Example:
+      #   it { should validate_uniqueness_of(:email) }
       #
       # Options:
       #
@@ -57,14 +55,6 @@ module Shoulda # :nodoc:
           self
         end
 
-        def description
-          result = "require "
-          result << "case sensitive " unless @options[:case_insensitive]
-          result << "unique value for #{@attribute}"
-          result << " scoped to #{@options[:scopes].join(', ')}" if @options[:scopes].present?
-          result
-        end
-
         def matches?(subject)
           @subject = subject.class.new
           @expected_message ||= :taken
@@ -73,6 +63,14 @@ module Shoulda # :nodoc:
             validate_after_scope_change?
         end
 
+        def description
+          result = 'require '
+          result << 'case sensitive ' unless @options[:case_insensitive]
+          result << "unique value for #{@attribute}"
+          result << " scoped to #{@options[:scopes].join(', ')}" if @options[:scopes].present?
+          result
+        end
+
         private
 
         def existing
@@ -85,7 +83,7 @@ module Shoulda # :nodoc:
 
         def create_instance_in_database
           @subject.class.new.tap do |instance|
-            instance.send("#{@attribute}=", "arbitrary_string")
+            instance.send("#{@attribute}=", 'arbitrary_string')
             instance.save(:validate => false)
           end
         end
@@ -98,7 +96,7 @@ module Shoulda # :nodoc:
                 @subject.send(setter, existing.send(scope))
                 true
               else
-                @failure_message = "#{class_name} doesn't seem to have a #{scope} attribute."
+                @failure_message_for_should = "#{class_name} doesn't seem to have a #{scope} attribute."
                 false
               end
             end
@@ -135,11 +133,11 @@ module Shoulda # :nodoc:
               if allows_value_of(existing_value, @expected_message)
                 @subject.send("#{scope}=", previous_value)
 
-                @negative_failure_message <<
+                @failure_message_for_should_not <<
                   " (with different value of #{scope})"
                 true
               else
-                @failure_message << " (with different value of #{scope})"
+                @failure_message_for_should << " (with different value of #{scope})"
                 false
               end
             end

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

@@ -2,7 +2,7 @@ module Shoulda # :nodoc:
   module Matchers
     module ActiveModel # :nodoc:
       class ValidationMatcher # :nodoc:
-        attr_reader :failure_message
+        attr_reader :failure_message_for_should
 
         def initialize(attribute)
           @attribute = attribute
@@ -14,8 +14,8 @@ module Shoulda # :nodoc:
           self
         end
 
-        def negative_failure_message
-          @negative_failure_message || @failure_message
+        def failure_message_for_should_not
+          @failure_message_for_should_not || @failure_message_for_should
         end
 
         def matches?(subject)
@@ -29,10 +29,10 @@ module Shoulda # :nodoc:
           allow = allow_value_matcher(value, message)
 
           if allow.matches?(@subject)
-            @negative_failure_message = allow.failure_message
+            @failure_message_for_should_not = allow.failure_message_for_should
             true
           else
-            @failure_message = allow.negative_failure_message
+            @failure_message_for_should = allow.failure_message_for_should_not
             false
           end
         end
@@ -41,10 +41,10 @@ module Shoulda # :nodoc:
           disallow = allow_value_matcher(value, message)
 
           if disallow.matches?(@subject)
-            @failure_message = disallow.negative_failure_message
+            @failure_message_for_should = disallow.failure_message_for_should_not
             false
           else
-            @negative_failure_message = disallow.failure_message
+            @failure_message_for_should_not = disallow.failure_message_for_should
             true
           end
         end