tpitale-shoulda 2.11.0

data/test/matchers/active_record/have_named_scope_matcher_test.rb

@@ -0,0 +1,65 @@
+require File.join(File.dirname(__FILE__), '..', '..', 'test_helper')
+
+class HaveNamedScopeMatcherTest < ActiveSupport::TestCase # :nodoc:
+
+  context "an attribute with a named scope" do
+    setup do
+      define_model :example, :attr => :string do
+        named_scope :xyz, lambda {|n|
+          { :order => :attr }
+        }
+      end
+      @model = Example.new
+    end
+
+    should "accept having a scope with the correct signature" do
+      assert_accepts have_named_scope("xyz(1)"), @model
+    end
+
+    should "accept having a scope with the correct signature and find options" do
+      assert_accepts have_named_scope("xyz(1)").finding(:order => :attr), @model
+    end
+    
+    should "reject having a scope with incorrect find options" do
+      assert_rejects have_named_scope("xyz(1)").
+                       finding(:order => 'attr DESC'),
+                     @model
+    end
+    
+    should "reject having a scope with another name" do
+      assert_rejects have_named_scope("abc(1)"), @model
+    end
+
+  end
+
+  should "evaluate the scope in the correct context" do
+    define_model :example, :attr => :string do
+      named_scope :xyz, lambda {|n|
+        { :order => n }
+      }
+    end
+    model = Example.new
+    @order = :attr
+    assert_accepts have_named_scope("xyz(@order)").
+                     finding(:order => @order).
+                     in_context(self),
+                   model
+  end
+
+  context "a method that does not return a scope" do
+    setup do
+      klass = Class.new
+      klass.class_eval do
+        def self.xyz
+          'xyz'
+        end
+      end
+      @model = klass.new
+    end
+
+    should "reject having a named scope with that name" do
+      assert_rejects have_named_scope(:xyz), @model
+    end
+  end
+
+end

data/test/matchers/active_record/have_readonly_attributes_matcher_test.rb

@@ -0,0 +1,29 @@
+require File.join(File.dirname(__FILE__), '..', '..', 'test_helper')
+
+class HaveReadonlyAttributesMatcherTest < ActiveSupport::TestCase # :nodoc:
+
+  context "an attribute that cannot be set after being saved" do
+    setup do
+      define_model :example, :attr => :string do
+        attr_readonly :attr
+      end
+      @model = Example.new
+    end
+
+    should "accept being read-only" do
+      assert_accepts have_readonly_attribute(:attr), @model
+    end
+  end
+
+  context "an attribute that can be set after being saved" do
+    setup do
+      define_model :example, :attr => :string
+      @model = Example.new
+    end
+
+    should "accept being read-only" do
+      assert_rejects have_readonly_attribute(:attr), @model
+    end
+  end
+
+end

data/test/matchers/active_record/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_record/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_record/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

data/test/matchers/active_record/validate_presence_of_matcher_test.rb

@@ -0,0 +1,86 @@
+require File.join(File.dirname(__FILE__), '..', '..', 'test_helper')
+
+class ValidatePresenceOfMatcherTest < ActiveSupport::TestCase # :nodoc:
+
+  context "a required attribute" do
+    setup do
+      define_model :example, :attr => :string do
+        validates_presence_of :attr
+      end
+      @model = Example.new
+    end
+
+    should "require a value" do
+      assert_accepts validate_presence_of(:attr), @model
+    end
+
+    should "not override the default message with a blank" do
+      assert_accepts validate_presence_of(:attr).with_message(nil), @model
+    end
+  end
+
+  context "an optional attribute" do
+    setup do
+      @model = define_model(:example, :attr => :string).new
+    end
+
+    should "not require a value" do
+      assert_rejects validate_presence_of(:attr), @model
+    end
+  end
+
+  context "a required has_many association" do
+    setup do
+      define_model :child
+      @model = define_model :parent do
+        has_many :children
+        validates_presence_of :children
+      end.new
+    end
+
+    should "require the attribute to be set" do
+      assert_accepts validate_presence_of(:children), @model
+    end
+  end
+
+  context "an optional has_many association" do
+    setup do
+      define_model :child
+      @model = define_model :parent do
+        has_many :children
+      end.new
+    end
+
+    should "not require the attribute to be set" do
+      assert_rejects validate_presence_of(:children), @model
+    end
+  end
+
+  context "a required has_and_belongs_to_many association" do
+    setup do
+      define_model :child
+      @model = define_model :parent do
+        has_and_belongs_to_many :children
+        validates_presence_of :children
+      end.new
+    end
+
+    should "require the attribute to be set" do
+      assert_accepts validate_presence_of(:children), @model
+    end
+  end
+
+  context "an optional has_and_belongs_to_many association" do
+    setup do
+      define_model :child
+      @model = define_model :parent do
+        has_and_belongs_to_many :children
+      end.new
+    end
+
+    should "not require the attribute to be set" do
+      assert_rejects validate_presence_of(:children), @model
+    end
+  end
+
+end

data/test/matchers/active_record/validate_uniqueness_of_matcher_test.rb

@@ -0,0 +1,147 @@
+require File.join(File.dirname(__FILE__), '..', '..', 'test_helper')
+
+class ValidateUniquenessOfMatcherTest < ActiveSupport::TestCase # :nodoc:
+
+  context "a unique attribute" do
+    setup do
+      @model = define_model(:example, :attr  => :string,
+                                           :other => :integer) do
+        validates_uniqueness_of :attr
+      end.new
+    end
+
+    context "with an existing value" do
+      setup do
+        @existing = Example.create!(:attr => 'value', :other => 1)
+      end
+
+      should "require a unique value for that attribute" do
+        assert_accepts validate_uniqueness_of(:attr), @model
+      end
+
+      should "pass when the subject is an existing record" do
+        assert_accepts validate_uniqueness_of(:attr), @existing
+      end
+
+      should "fail when a scope is specified" do
+        assert_rejects validate_uniqueness_of(:attr).scoped_to(:other), @model
+      end
+    end
+
+    context "without an existing value" do
+      setup do
+        assert_nil Example.find(:first)
+        @matcher = validate_uniqueness_of(:attr)
+      end
+
+      should "fail to require a unique value" do
+        assert_rejects @matcher, @model
+      end
+
+      should "alert the tester that an existing value is not present" do
+        @matcher.matches?(@model)
+        assert @matcher.negative_failure_message =~ /^Can't find first .*/
+      end
+    end
+  end
+
+  context "a unique attribute with a custom error and an existing value" do
+    setup do
+      @model = define_model(:example, :attr => :string) do
+        validates_uniqueness_of :attr, :message => 'Bad value'
+      end.new
+      Example.create!
+    end
+
+    should "fail when checking the default message" do
+      assert_rejects validate_uniqueness_of(:attr), @model
+    end
+
+    should "fail when checking a message that doesn't match" do
+      assert_rejects validate_uniqueness_of(:attr).with_message(/abc/i), @model
+    end
+
+    should "pass when checking a message that matches" do
+      assert_accepts validate_uniqueness_of(:attr).with_message(/bad/i), @model
+    end
+  end
+
+  context "a scoped unique attribute with an existing value" do
+    setup do
+      @model = define_model(:example, :attr   => :string,
+                                           :scope1 => :integer,
+                                           :scope2 => :integer) do
+        validates_uniqueness_of :attr, :scope => [:scope1, :scope2]
+      end.new
+      @existing = Example.create!(:attr => 'value', :scope1 => 1, :scope2 => 2)
+    end
+
+    should "pass when the correct scope is specified" do
+      assert_accepts validate_uniqueness_of(:attr).scoped_to(:scope1, :scope2),
+        @model
+    end
+
+    should "pass when the subject is an existing record" do
+      assert_accepts validate_uniqueness_of(:attr).scoped_to(:scope1, :scope2),
+        @existing
+    end
+
+    should "fail when a different scope is specified" do
+      assert_rejects validate_uniqueness_of(:attr).scoped_to(:scope1), @model
+    end
+
+    should "fail when no scope is specified" do
+      assert_rejects validate_uniqueness_of(:attr), @model
+    end
+
+    should "fail when a non-existent attribute is specified as a scope" do
+      assert_rejects validate_uniqueness_of(:attr).scoped_to(:fake), @model
+    end
+  end
+
+  context "a non-unique attribute with an existing value" do
+    setup do
+      @model = define_model(:example, :attr => :string).new
+      Example.create!(:attr => 'value')
+    end
+
+    should "not require a unique value for that attribute" do
+      assert_rejects validate_uniqueness_of(:attr), @model
+    end
+  end
+
+  context "a case sensitive unique attribute with an existing value" do
+    setup do
+      @model = define_model(:example, :attr  => :string) do
+        validates_uniqueness_of :attr, :case_sensitive => true
+      end.new
+      Example.create!(:attr => 'value')
+    end
+
+    should "not require a unique, case-insensitive value for that attribute" do
+      assert_rejects validate_uniqueness_of(:attr).case_insensitive, @model
+    end
+
+    should "require a unique, case-sensitive value for that attribute" do
+      assert_accepts validate_uniqueness_of(:attr), @model
+    end
+  end
+
+  context "a case sensitive unique integer attribute with an existing value" do
+    setup do
+      @model = define_model(:example, :attr  => :integer) do
+        validates_uniqueness_of :attr, :case_sensitive => true
+      end.new
+      Example.create!(:attr => 'value')
+    end
+
+    should "require a unique, case-insensitive value for that attribute" do
+      assert_accepts validate_uniqueness_of(:attr).case_insensitive, @model
+    end
+
+    should "require a unique, case-sensitive value for that attribute" do
+      assert_accepts validate_uniqueness_of(:attr), @model
+    end
+  end
+
+end