shoulda-activemodel 0.0.2

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

@@ -0,0 +1,57 @@
+module Shoulda # :nodoc:
+  module ActiveModel # :nodoc:
+    module Matchers
+
+      class ValidationMatcher # :nodoc:
+
+        attr_reader :failure_message
+
+        def initialize(attribute)
+          @attribute = attribute
+        end
+
+        def negative_failure_message
+          @negative_failure_message || @failure_message
+        end
+
+        def matches?(subject)
+          @subject = subject
+          false
+        end
+        
+
+        private
+
+        def allows_value_of(value, message = nil)
+          allow = AllowValueMatcher.
+            new(value).
+            for(@attribute).
+            with_message(message)
+          if allow.matches?(@subject)
+            @negative_failure_message = allow.failure_message
+            true
+          else
+            @failure_message = allow.negative_failure_message
+            false
+          end
+        end
+
+        def disallows_value_of(value, message = nil)
+          disallow = AllowValueMatcher.
+            new(value).
+            for(@attribute).
+            with_message(message)
+          if disallow.matches?(@subject)
+            @failure_message = disallow.negative_failure_message
+            false
+          else
+            @negative_failure_message = disallow.failure_message
+            true
+          end
+        end
+      end
+
+    end
+  end
+end
+

data/test/fail_macros.rb

@@ -0,0 +1,39 @@
+module Shoulda
+  class << self
+    attr_accessor :expected_exceptions
+  end
+
+  module ClassMethods
+    # Enables the core shoulda test suite to test for failure scenarios.  For
+    # example, to ensure that a set of test macros should fail, do this:
+    #
+    #   should_fail do
+    #     should_validate_presence_of :comments
+    #     should_not_allow_mass_assignment_of :name
+    #   end
+    def should_fail(&block)
+      context "should fail when trying to run:" do
+        if defined?(Test::Unit::AssertionFailedError)
+          failures = [Test::Unit::AssertionFailedError]
+        elsif defined?(MiniTest::Assertion)
+          failures = [MiniTest::Assertion]
+        end
+        Shoulda.expected_exceptions = failures
+        yield block
+        Shoulda.expected_exceptions = nil
+      end
+    end
+  end
+
+  class Context
+    # alias_method_chain hack to allow the should_fail macro to work
+    def should_with_failure_scenario(name, options = {}, &block)
+      if Shoulda.expected_exceptions
+        expected_exceptions = Shoulda.expected_exceptions
+        failure_block = lambda { assert_raise(*expected_exceptions, &block.bind(self)) }
+      end
+      should_without_failure_scenario(name, options, &(failure_block || block))
+    end
+    alias_method_chain :should, :failure_scenario
+  end
+end

data/test/matchers/active_model/ensure_inclusion_of_matcher_test.rb

@@ -0,0 +1,80 @@
+require File.join(File.dirname(__FILE__), '..', '..', 'test_helper')
+
+class EnsureInclusionOfMatcherTest < ActiveSupport::TestCase # :nodoc:
+
+  context "an attribute which must be included in a range" do
+    setup do
+      @model = define_model(:example, :attr => :integer) do
+        validates_inclusion_of :attr, :in => 2..5
+      end.new
+    end
+
+    should "accept ensuring the correct range" do
+      assert_accepts ensure_inclusion_of(:attr).in_range(2..5), @model
+    end
+
+    should "reject ensuring a lower minimum value" do
+      assert_rejects ensure_inclusion_of(:attr).in_range(1..5), @model
+    end
+
+    should "reject ensuring a higher minimum value" do
+      assert_rejects ensure_inclusion_of(:attr).in_range(3..5), @model
+    end
+
+    should "reject ensuring a lower maximum value" do
+      assert_rejects ensure_inclusion_of(:attr).in_range(2..4), @model
+    end
+
+    should "reject ensuring a higher maximum value" do
+      assert_rejects ensure_inclusion_of(:attr).in_range(2..6), @model
+    end
+
+    should "not override the default message with a blank" do
+      assert_accepts ensure_inclusion_of(:attr).
+                       in_range(2..5).
+                       with_message(nil),
+                     @model
+    end
+  end
+
+  context "an attribute with a custom ranged value validation" do
+    setup do
+      @model = define_model(:example, :attr => :string) do
+        validates_inclusion_of :attr, :in => 2..4, :message => 'not good'
+
+      end.new
+    end
+
+    should "accept ensuring the correct range" do
+      assert_accepts ensure_inclusion_of(:attr).
+                       in_range(2..4).
+                       with_message(/not good/),
+                     @model
+    end
+  end
+
+  context "an attribute with custom range validations" do
+    setup do
+      define_model :example, :attr => :integer do
+        def validate
+          if attr < 2
+            errors.add(:attr, 'too low')
+          elsif attr > 5
+            errors.add(:attr, 'too high')
+          end
+        end
+      end
+      @model = Example.new
+    end
+
+    should "accept ensuring the correct range and messages" do
+      assert_accepts ensure_inclusion_of(:attr).
+                       in_range(2..5).
+                       with_low_message(/low/).
+                       with_high_message(/high/),
+                     @model
+    end
+
+  end
+
+end

data/test/matchers/active_model/ensure_length_of_matcher_test.rb

@@ -0,0 +1,158 @@
+require File.join(File.dirname(__FILE__), '..', '..', 'test_helper')
+
+class EnsureLengthOfMatcher < ActiveSupport::TestCase # :nodoc:
+
+  context "an attribute with a non-zero minimum length validation" do
+    setup do
+      @model = define_model(:example, :attr => :string) do
+        validates_length_of :attr, :minimum => 4
+      end.new
+    end
+
+    should "accept ensuring the correct minimum length" do
+      assert_accepts ensure_length_of(:attr).is_at_least(4), @model
+    end
+
+    should "reject ensuring a lower minimum length with any message" do
+      assert_rejects ensure_length_of(:attr).
+                       is_at_least(3).
+                       with_short_message(/.*/),
+                     @model
+    end
+
+    should "reject ensuring a higher minimum length with any message" do
+      assert_rejects ensure_length_of(:attr).
+                       is_at_least(5).
+                       with_short_message(/.*/),
+                     @model
+    end
+
+    should "not override the default message with a blank" do
+      assert_accepts ensure_length_of(:attr).
+                       is_at_least(4).
+                       with_short_message(nil),
+                     @model
+    end
+  end
+
+  context "an attribute with a minimum length validation of 0" do
+    setup do
+      @model = define_model(:example, :attr => :string) do
+        validates_length_of :attr, :minimum => 0
+      end.new
+    end
+
+    should "accept ensuring the correct minimum length" do
+      assert_accepts ensure_length_of(:attr).is_at_least(0), @model
+    end
+  end
+
+  context "an attribute with a maximum length" do
+    setup do
+      @model = define_model(:example, :attr => :string) do
+        validates_length_of :attr, :maximum => 4
+      end.new
+    end
+
+    should "accept ensuring the correct maximum length" do
+      assert_accepts ensure_length_of(:attr).is_at_most(4), @model
+    end
+
+    should "reject ensuring a lower maximum length with any message" do
+      assert_rejects ensure_length_of(:attr).
+                       is_at_most(3).
+                       with_long_message(/.*/),
+                     @model
+    end
+
+    should "reject ensuring a higher maximum length with any message" do
+      assert_rejects ensure_length_of(:attr).
+                       is_at_most(5).
+                       with_long_message(/.*/),
+                     @model
+    end
+
+    should "not override the default message with a blank" do
+      assert_accepts ensure_length_of(:attr).
+                       is_at_most(4).
+                       with_long_message(nil),
+                     @model
+    end
+  end
+
+  context "an attribute with a required exact length" do
+    setup do
+      @model = define_model(:example, :attr => :string) do
+        validates_length_of :attr, :is => 4
+      end.new
+    end
+
+    should "accept ensuring the correct length" do
+      assert_accepts ensure_length_of(:attr).is_equal_to(4), @model
+    end
+
+    should "reject ensuring a lower maximum length with any message" do
+      assert_rejects ensure_length_of(:attr).
+                       is_equal_to(3).
+                       with_message(/.*/),
+                     @model
+    end
+
+    should "reject ensuring a higher maximum length with any message" do
+      assert_rejects ensure_length_of(:attr).
+                       is_equal_to(5).
+                       with_message(/.*/),
+                     @model
+    end
+
+    should "not override the default message with a blank" do
+      assert_accepts ensure_length_of(:attr).
+                       is_equal_to(4).
+                       with_message(nil),
+                     @model
+    end
+  end
+
+  context "an attribute with a custom minimum length validation" do
+    setup do
+      @model = define_model(:example, :attr => :string) do
+        validates_length_of :attr, :minimum => 4, :too_short => 'short'
+      end.new
+    end
+
+    should "accept ensuring the correct minimum length" do
+      assert_accepts ensure_length_of(:attr).
+                       is_at_least(4).
+                       with_short_message(/short/),
+                     @model
+    end
+
+  end
+
+  context "an attribute with a custom maximum length validation" do
+    setup do
+      @model = define_model(:example, :attr => :string) do
+        validates_length_of :attr, :maximum => 4, :too_long => 'long'
+      end.new
+    end
+
+    should "accept ensuring the correct minimum length" do
+      assert_accepts ensure_length_of(:attr).
+                       is_at_most(4).
+                       with_long_message(/long/),
+                     @model
+    end
+
+  end
+
+  context "an attribute without a length validation" do
+    setup do
+      @model = define_model(:example, :attr => :string).new
+    end
+
+    should "reject ensuring a minimum length" do
+      assert_rejects ensure_length_of(:attr).is_at_least(1), @model
+    end
+  end
+
+end

data/test/matchers/active_model/validate_acceptance_of_matcher_test.rb

@@ -0,0 +1,44 @@
+require File.join(File.dirname(__FILE__), '..', '..', 'test_helper')
+
+class ValidateAcceptanceOfMatcherTest < ActiveSupport::TestCase # :nodoc:
+
+  context "an attribute which must be accepted" do
+    setup do
+      @model = define_model(:example) do
+        validates_acceptance_of :attr
+      end.new
+    end
+
+    should "require that attribute to be accepted" do
+      assert_accepts validate_acceptance_of(:attr), @model
+    end
+
+    should "not overwrite the default message with nil" do
+      assert_accepts validate_acceptance_of(:attr).with_message(nil), @model
+    end
+  end
+
+  context "an attribute that does not need to be accepted" do
+    setup do
+      @model = define_model(:example, :attr => :string).new
+    end
+
+    should "not require that attribute to be accepted" do
+      assert_rejects validate_acceptance_of(:attr), @model
+    end
+  end
+
+  context "an attribute which must be accepted with a custom message" do
+    setup do
+      @model = define_model(:example) do
+        validates_acceptance_of :attr, :message => 'custom'
+      end.new
+    end
+
+    should "require that attribute to be accepted with that message" do
+      assert_accepts validate_acceptance_of(:attr).with_message(/custom/),
+                     @model
+    end
+  end
+
+end

data/test/matchers/active_model/validate_format_of_matcher_test.rb

@@ -0,0 +1,39 @@
+require File.join(File.dirname(__FILE__), '..', '..', 'test_helper')
+
+class ValidateFormatOfMatcherTest < ActiveSupport::TestCase # :nodoc:
+
+
+  context "a postal code" do
+    setup do
+      define_model :example, :attr => :string do
+        validates_format_of :attr, :with => /^\d{5}$/
+      end
+      @model = Example.new
+    end
+    
+    should "be valid" do
+      assert_accepts validate_format_of(:attr).with('12345'), @model
+    end
+    
+    should "not be valid with alpha in zip" do
+      assert_rejects validate_format_of(:attr).not_with('1234a'), @model, :message=>"is invalid"
+    end
+    
+    should "not be valid with to few digits" do
+      assert_rejects validate_format_of(:attr).not_with('1234'), @model, :message=>"is invalid"
+    end
+    
+    should "not be valid with to many digits" do
+      assert_rejects validate_format_of(:attr).not_with('123456'), @model, :message=>"is invalid"
+    end
+    
+    should "raise error if you try to call both with and not_with" do
+      assert_raise RuntimeError do
+        validate_format_of(:attr).not_with('123456').with('12345')
+      end
+    end
+    
+  end
+
+
+end

data/test/matchers/active_model/validate_numericality_of_matcher_test.rb

@@ -0,0 +1,52 @@
+require File.join(File.dirname(__FILE__), '..', '..', 'test_helper')
+
+class ValidateNumericalityOfMatcherTest < ActiveSupport::TestCase # :nodoc:
+
+  context "a numeric attribute" do
+    setup do
+      define_model :example, :attr => :string do
+        validates_numericality_of :attr
+      end
+      @model = Example.new
+    end
+
+    should "only allow numeric values for that attribute" do
+      assert_accepts validate_numericality_of(:attr), @model
+    end
+
+    should "not override the default message with a blank" do
+      assert_accepts validate_numericality_of(:attr).with_message(nil),
+                     @model
+    end
+  end
+
+  context "a numeric attribute with a custom validation message" do
+    setup do
+      define_model :example, :attr => :string do
+        validates_numericality_of :attr, :message => 'custom'
+      end
+      @model = Example.new
+    end
+
+    should "only allow numeric values for that attribute with that message" do
+      assert_accepts validate_numericality_of(:attr).
+                       with_message(/custom/),
+                     @model
+    end
+
+    should "not allow numeric values for that attribute with another message" do
+      assert_rejects validate_numericality_of(:attr), @model
+    end
+  end
+
+  context "a non-numeric attribute" do
+    setup do
+      @model = define_model(:example, :attr => :string).new
+    end
+
+    should "not only allow numeric values for that attribute" do
+      assert_rejects validate_numericality_of(:attr), @model
+    end
+  end
+
+end