shoulda-activemodel 0.0.2

data/lib/shoulda/active_model.rb

@@ -0,0 +1,16 @@
+require 'shoulda'
+require 'shoulda/active_model/helpers'
+require 'shoulda/active_model/matchers'
+require 'shoulda/active_model/assertions'
+require 'shoulda/active_model/macros'
+
+module Test # :nodoc: all
+  module Unit
+    class TestCase
+      include Shoulda::ActiveModel::Helpers
+      include Shoulda::ActiveModel::Matchers
+      include Shoulda::ActiveModel::Assertions
+      extend Shoulda::ActiveModel::Macros
+    end
+  end
+end

data/lib/shoulda/active_model/assertions.rb

@@ -0,0 +1,61 @@
+module Shoulda # :nodoc:
+  module ActiveModel # :nodoc:
+    module Assertions
+      # Asserts that the given object is valid
+      #
+      #  assert_valid User.new(params)
+      def assert_valid(obj)
+        assert obj.valid?, "Errors: #{pretty_error_messages obj}"
+      end
+
+      # Asserts that an Active Model model validates with the passed
+      # <tt>value</tt> by making sure the <tt>error_message_to_avoid</tt> is not
+      # contained within the list of errors for that attribute.
+      #
+      #   assert_good_value(User.new, :email, "user@example.com")
+      #   assert_good_value(User.new, :ssn, "123456789", /length/)
+      #
+      # If a class is passed as the first argument, a new object will be
+      # instantiated before the assertion.  If an instance variable exists with
+      # the same name as the class (underscored), that object will be used
+      # instead.
+      #
+      #   assert_good_value(User, :email, "user@example.com")
+      #
+      #   product = Product.new(:tangible => false)
+      #   assert_good_value(product, :price, "0")
+      def assert_good_value(object_or_klass, attribute, value, error_message_to_avoid = nil)
+        object = get_instance_of(object_or_klass)
+        matcher = allow_value(value).
+                    for(attribute).
+                    with_message(error_message_to_avoid)
+        assert_accepts(matcher, object)
+      end
+
+      # Asserts that an Active Model model invalidates the passed
+      # <tt>value</tt> by making sure the <tt>error_message_to_expect</tt> is
+      # contained within the list of errors for that attribute.
+      #
+      #   assert_bad_value(User.new, :email, "invalid")
+      #   assert_bad_value(User.new, :ssn, "123", /length/)
+      #
+      # If a class is passed as the first argument, a new object will be
+      # instantiated before the assertion.  If an instance variable exists with
+      # the same name as the class (underscored), that object will be used
+      # instead.
+      #
+      #   assert_bad_value(User, :email, "invalid")
+      #
+      #   product = Product.new(:tangible => true)
+      #   assert_bad_value(product, :price, "0")
+      def assert_bad_value(object_or_klass, attribute, value,
+                           error_message_to_expect = nil)
+        object = get_instance_of(object_or_klass)
+        matcher = allow_value(value).
+                    for(attribute).
+                    with_message(error_message_to_expect)
+        assert_rejects(matcher, object)
+      end
+    end
+  end
+end

data/lib/shoulda/active_model/helpers.rb

@@ -0,0 +1,31 @@
+module Shoulda # :nodoc:
+  module ActiveModel # :nodoc:
+    module Helpers
+      def pretty_error_messages(obj) # :nodoc:
+        obj.errors.map do |a, m| 
+          msg = "#{a} #{m}" 
+          msg << " (#{obj.send(a).inspect})" unless a.to_sym == :base
+        end
+      end
+
+      # 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.
+      #
+      #   default_error_message(:blank)
+      #   default_error_message(:too_short, :count => 5)
+      #   default_error_message(:too_long, :count => 60)
+      def default_error_message(key, values = {})
+        if Object.const_defined?(:I18n) # Rails >= 2.2
+          message = I18n.translate("activerecord.errors.messages.#{key}", values, :default => '')
+          if message.blank? # Rails 3 where the namespace has moved
+            message = I18n.translate("errors.messages.#{key}", values)
+          end
+          message
+        else # Rails <= 2.1.x
+          ::ActiveRecord::Errors.default_error_messages[key] % values[:count]
+        end
+      end
+    end
+  end
+end

data/lib/shoulda/active_model/macros.rb

@@ -0,0 +1,268 @@
+module Shoulda # :nodoc:
+  module ActiveModel # :nodoc:
+    # = Macro test helpers for your active model models
+    #
+    # These helpers will test most of the validations and associations for your ActiveModel models.
+    #
+    #   class UserTest < Test::Unit::TestCase
+    #     should_validate_presence_of :name, :phone_number
+    #     should_not_allow_values_for :phone_number, "abcd", "1234"
+    #     should_allow_values_for :phone_number, "(123) 456-7890"
+    #   end
+    #
+    # For all of these helpers, the last parameter may be a hash of options.
+    #
+    module Macros
+      include Matchers
+
+      # Ensures that the model cannot be saved if one of the attributes listed is not present.
+      #
+      # Options:
+      # * <tt>:message</tt> - value the test expects to find in <tt>errors.on(:attribute)</tt>.
+      #   Regexp or string.  Default = <tt>I18n.translate('activemodel.errors.messages.blank')</tt>
+      #
+      # Example:
+      #   should_validate_presence_of :name, :phone_number
+      #
+      def should_validate_presence_of(*attributes)
+        message = get_options!(attributes, :message)
+
+        attributes.each do |attribute|
+          matcher = validate_presence_of(attribute).with_message(message)
+          should matcher.description do
+            assert_accepts(matcher, subject)
+          end
+        end
+      end
+      
+      # Ensures that the model cannot be saved if one of the attributes listed is not unique.
+      # Requires an existing model
+      #
+      # Options:
+
+      # * <tt>:message</tt> - value the test expects to find in <tt>errors.on(:attribute)</tt>.
+      #   Regexp or string.  Default = <tt>I18n.translate('activemodel.errors.messages.taken')</tt>
+      # * <tt>:scoped_to</tt> - field(s) to scope the uniqueness to.
+      # * <tt>:case_sensitive</tt> - whether or not uniqueness is defined by an
+      #   exact match. Ignored by non-text attributes. Default = <tt>true</tt>
+      #
+      # Examples:
+      #   should_validate_uniqueness_of :keyword, :username
+      #   should_validate_uniqueness_of :name, :message => "O NOES! SOMEONE STOELED YER NAME!"
+      #   should_validate_uniqueness_of :email, :scoped_to => :name
+      #   should_validate_uniqueness_of :address, :scoped_to => [:first_name, :last_name]
+      #   should_validate_uniqueness_of :email, :case_sensitive => false
+      #
+      def should_validate_uniqueness_of(*attributes)
+        message, scope, case_sensitive = get_options!(attributes, :message, :scoped_to, :case_sensitive)
+        scope = [*scope].compact
+        case_sensitive = true if case_sensitive.nil?
+
+        attributes.each do |attribute|
+          matcher = validate_uniqueness_of(attribute).
+            with_message(message).scoped_to(scope)
+          matcher = matcher.case_insensitive unless case_sensitive
+          should matcher.description do
+            assert_accepts(matcher, subject)
+          end
+        end
+      end
+
+      # Ensures that the attribute cannot be set to the given values
+      #
+      # Options:
+      # * <tt>:message</tt> - value the test expects to find in <tt>errors.on(:attribute)</tt>.
+      #   Regexp or string. If omitted, the test will pass if there is ANY error in
+      #   <tt>errors.on(:attribute)</tt>.
+      #
+      # Example:
+      #   should_not_allow_values_for :isbn, "bad 1", "bad 2"
+      #
+      def should_not_allow_values_for(attribute, *bad_values)
+        message = get_options!(bad_values, :message)
+        bad_values.each do |value|
+          matcher = allow_value(value).for(attribute).with_message(message)
+          should "not #{matcher.description}" do
+            assert_rejects matcher, subject
+          end
+        end
+      end
+
+      # Ensures that the attribute can be set to the given values.
+      #
+      # Example:
+      #   should_allow_values_for :isbn, "isbn 1 2345 6789 0", "ISBN 1-2345-6789-0"
+      #
+      def should_allow_values_for(attribute, *good_values)
+        get_options!(good_values)
+        good_values.each do |value|
+          matcher = allow_value(value).for(attribute)
+          should matcher.description do
+            assert_accepts matcher, subject
+          end
+        end
+      end
+
+      # Ensures that the length of the attribute is in the given range
+      #
+      # Options:
+      # * <tt>:short_message</tt> - value the test expects to find in <tt>errors.on(:attribute)</tt>.
+      #   Regexp or string.  Default = <tt>I18n.translate('activemodel.errors.messages.too_short') % range.first</tt>
+      # * <tt>:long_message</tt> - value the test expects to find in <tt>errors.on(:attribute)</tt>.
+      #   Regexp or string.  Default = <tt>I18n.translate('activemodel.errors.messages.too_long') % range.last</tt>
+      #
+      # Example:
+      #   should_ensure_length_in_range :password, (6..20)
+      #
+      def should_ensure_length_in_range(attribute, range, opts = {})
+        short_message, long_message = get_options!([opts], 
+                                                   :short_message,
+                                                   :long_message)
+        matcher = ensure_length_of(attribute).
+          is_at_least(range.first).
+          with_short_message(short_message).
+          is_at_most(range.last).
+          with_long_message(long_message)
+
+        should matcher.description do
+          assert_accepts matcher, subject
+        end
+      end
+
+      # Ensures that the length of the attribute is at least a certain length
+      #
+      # Options:
+      # * <tt>:short_message</tt> - value the test expects to find in <tt>errors.on(:attribute)</tt>.
+      #   Regexp or string.  Default = <tt>I18n.translate('activemodel.errors.messages.too_short') % min_length</tt>
+      #
+      # Example:
+      #   should_ensure_length_at_least :name, 3
+      #
+      def should_ensure_length_at_least(attribute, min_length, opts = {})
+        short_message = get_options!([opts], :short_message)
+
+        matcher = ensure_length_of(attribute).
+          is_at_least(min_length).
+          with_short_message(short_message)
+
+        should matcher.description do
+          assert_accepts matcher, subject
+        end
+      end
+
+      # Ensures that the length of the attribute is exactly a certain length
+      #
+      # Options:
+      # * <tt>:message</tt> - value the test expects to find in <tt>errors.on(:attribute)</tt>.
+      #   Regexp or string.  Default = <tt>I18n.translate('activemodel.errors.messages.wrong_length') % length</tt>
+      #
+      # Example:
+      #   should_ensure_length_is :ssn, 9
+      #
+      def should_ensure_length_is(attribute, length, opts = {})
+        message = get_options!([opts], :message)
+        matcher = ensure_length_of(attribute).
+          is_equal_to(length).
+          with_message(message)
+
+        should matcher.description do
+          assert_accepts matcher, subject
+        end
+      end
+
+      # Ensure that the attribute is in the range specified
+      #
+      # Options:
+      # * <tt>:low_message</tt> - value the test expects to find in <tt>errors.on(:attribute)</tt>.
+      #   Regexp or string.  Default = <tt>I18n.translate('activemodel.errors.messages.inclusion')</tt>
+      # * <tt>:high_message</tt> - value the test expects to find in <tt>errors.on(:attribute)</tt>.
+      #   Regexp or string.  Default = <tt>I18n.translate('activemodel.errors.messages.inclusion')</tt>
+      #
+      # Example:
+      #   should_ensure_value_in_range :age, (0..100)
+      #
+      def should_ensure_value_in_range(attribute, range, opts = {})
+        message, low_message, high_message = get_options!([opts],
+                                                          :message,
+                                                          :low_message,
+                                                          :high_message)
+        matcher = ensure_inclusion_of(attribute).
+          in_range(range).
+          with_message(message).
+          with_low_message(low_message).
+          with_high_message(high_message)
+        should matcher.description do
+          assert_accepts matcher, subject
+        end
+      end
+
+      # Ensure that the attribute is numeric
+      #
+      # Options:
+      # * <tt>:message</tt> - value the test expects to find in <tt>errors.on(:attribute)</tt>.
+      #   Regexp or string.  Default = <tt>I18n.translate('activemodel.errors.messages.not_a_number')</tt>
+      #
+      # Example:
+      #   should_validate_numericality_of :age
+      #
+      def should_validate_numericality_of(*attributes)
+        message = get_options!(attributes, :message)
+        attributes.each do |attribute|
+          matcher = validate_numericality_of(attribute).
+            with_message(message)
+          should matcher.description do
+            assert_accepts matcher, subject
+          end
+        end
+      end
+
+      # Ensure that the given class methods are defined on the model.
+      #
+      #   should_have_class_methods :find, :destroy
+      #
+      def should_have_class_methods(*methods)
+        get_options!(methods)
+        klass = described_type
+        methods.each do |method|
+          should "respond to class method ##{method}" do
+            assert_respond_to klass, method, "#{klass.name} does not have class method #{method}"
+          end
+        end
+      end
+
+      # Ensure that the given instance methods are defined on the model.
+      #
+      #   should_have_instance_methods :email, :name, :name=
+      #
+      def should_have_instance_methods(*methods)
+        get_options!(methods)
+        klass = described_type
+        methods.each do |method|
+          should "respond to instance method ##{method}" do
+            assert_respond_to klass.new, method, "#{klass.name} does not have instance method #{method}"
+          end
+        end
+      end
+
+      # Ensures that the model cannot be saved if one of the attributes listed is not accepted.
+      #
+      # Options:
+      # * <tt>:message</tt> - value the test expects to find in <tt>errors.on(:attribute)</tt>.
+      #   Regexp or string.  Default = <tt>I18n.translate('activemodel.errors.messages.accepted')</tt>
+      #
+      # Example:
+      #   should_validate_acceptance_of :eula
+      #
+      def should_validate_acceptance_of(*attributes)
+        message = get_options!(attributes, :message)
+
+        attributes.each do |attribute|
+          matcher = validate_acceptance_of(attribute).with_message(message)
+          should matcher.description do
+            assert_accepts matcher, subject
+          end
+        end
+      end
+    end
+  end
+end

data/lib/shoulda/active_model/matchers.rb

@@ -0,0 +1,30 @@
+require 'shoulda/active_model/matchers/validation_matcher'
+require 'shoulda/active_model/matchers/allow_value_matcher'
+require 'shoulda/active_model/matchers/ensure_length_of_matcher'
+require 'shoulda/active_model/matchers/ensure_inclusion_of_matcher'
+require 'shoulda/active_model/matchers/validate_presence_of_matcher'
+require 'shoulda/active_model/matchers/validate_format_of_matcher'
+require 'shoulda/active_model/matchers/validate_uniqueness_of_matcher'
+require 'shoulda/active_model/matchers/validate_acceptance_of_matcher'
+require 'shoulda/active_model/matchers/validate_numericality_of_matcher'
+
+module Shoulda # :nodoc:
+  module ActiveModel # :nodoc:
+    # = Matchers for your ActiveModel models
+    #
+    # These matchers will test most of the validations and associations for your
+    # ActiveModel models.
+    #
+    #   describe User do
+    #     it { should validate_presence_of(:name) }
+    #     it { should validate_presence_of(:phone_number) }
+    #     %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) }
+    #   end
+    #
+    module Matchers
+    end
+  end
+end

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

@@ -0,0 +1,102 @@
+module Shoulda # :nodoc:
+  module ActiveModel # :nodoc:
+    module Matchers
+
+      # Ensures that the attribute can be set to the given value.
+      #
+      # Options:
+      # * <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>.
+      #
+      # Example:
+      #   it { should_not allow_value('bad').for(:isbn) }
+      #   it { should allow_value("isbn 1 2345 6789 0").for(:isbn) }
+      #
+      def allow_value(value)
+        AllowValueMatcher.new(value)
+      end
+
+      class AllowValueMatcher # :nodoc:
+        include Helpers
+
+        def initialize(value)
+          @value = value
+        end
+
+        def for(attribute)
+          @attribute = attribute
+          self
+        end
+
+        def with_message(message)
+          @expected_message = message if message
+          self
+        end
+
+        def matches?(instance)
+          @instance = instance
+          if Symbol === @expected_message
+            @expected_message = default_error_message(@expected_message)
+          end
+          @instance.send("#{@attribute}=", @value)
+          !errors_match?
+        end
+
+        def failure_message
+          "Did not expect #{expectation}, got error: #{@matched_error}"
+        end
+
+        def negative_failure_message
+          "Expected #{expectation}, got #{error_description}"
+        end
+
+        def description
+          "allow #{@attribute} to be set to #{@value.inspect}"
+        end
+
+        private
+
+        def errors_match?
+          @instance.valid?
+          @errors = @instance.errors[@attribute]
+          @errors = [@errors] unless @errors.is_a?(Array)
+          @expected_message ? (errors_match_regexp? || errors_match_string?) : (@errors != [nil])
+        end
+
+        def errors_match_regexp?
+          if Regexp === @expected_message
+            @matched_error = @errors.detect { |e| e =~ @expected_message }
+            !@matched_error.nil?
+          else
+            false
+          end
+        end
+
+        def errors_match_string?
+          if @errors.include?(@expected_message)
+            @matched_error = @expected_message
+            true
+          else
+            false
+          end
+        end
+
+        def expectation
+          "errors " <<
+          (@expected_message ? "to include #{@expected_message.inspect} " : "") <<
+          "when #{@attribute} is set to #{@value.inspect}"
+        end
+
+        def error_description
+          if @instance.errors.empty?
+            "no errors"
+          else
+            "errors: #{pretty_error_messages(@instance)}"
+          end
+        end
+      end
+
+    end
+  end
+end