shoulda-matchers 1.0.0 → 1.1.0

data/spec/shoulda/active_model/validate_acceptance_of_matcher_spec.rb

@@ -0,0 +1,43 @@
+require 'spec_helper'
+
+describe Shoulda::Matchers::ActiveModel::ValidateAcceptanceOfMatcher do
+
+  context "an attribute which must be accepted" do
+    before do
+      @model = define_model(:example, :attr => :string) do
+        validates_acceptance_of :attr
+      end.new
+    end
+
+    it "should require that attribute to be accepted" do
+      @model.should validate_acceptance_of(:attr)
+    end
+
+    it "should not overwrite the default message with nil" do
+      @model.should validate_acceptance_of(:attr).with_message(nil)
+    end
+  end
+
+  context "an attribute that does not need to be accepted" do
+    before do
+      @model = define_model(:example, :attr => :string).new
+    end
+
+    it "should not require that attribute to be accepted" do
+      @model.should_not validate_acceptance_of(:attr)
+    end
+  end
+
+  context "an attribute which must be accepted with a custom message" do
+    before do
+      @model = define_model(:example, :attr => :string) do
+        validates_acceptance_of :attr, :message => 'custom'
+      end.new
+    end
+
+    it "should require that attribute to be accepted with that message" do
+      @model.should validate_acceptance_of(:attr).with_message(/custom/)
+    end
+  end
+
+end

data/spec/shoulda/active_model/validate_confirmation_of_matcher_spec.rb

@@ -0,0 +1,48 @@
+require 'spec_helper'
+
+describe Shoulda::Matchers::ActiveModel::ValidateConfirmationOfMatcher do
+
+  context "an attribute which needs confirmation" do
+    before do
+      define_model(:example, :attr => :string) do
+        validates_confirmation_of :attr
+      end
+      @model = Example.new
+    end
+
+    it "should require confirmation of that attribute" do
+      @model.should validate_confirmation_of(:attr)
+    end
+
+    it "should not override the default message with a blank" do
+      @model.should validate_confirmation_of(:attr).with_message(nil)
+    end
+  end
+
+  context "an attribute which must be confirmed with a custom message" do
+    before do
+      define_model :example, :attr => :string do
+        validates_confirmation_of :attr, :message => 'custom'
+      end
+      @model = Example.new
+    end
+
+    it "should require confirmation of that attribute with that message" do
+      @model.should validate_confirmation_of(:attr).with_message(/custom/)
+    end
+
+    it "should not require confirmation of that attribute with another message" do
+      @model.should_not validate_confirmation_of(:attr)
+    end
+  end
+
+  context "an attribute which doesn't need confirmation" do
+    before do
+      @model = define_model(:example, :attr => :string).new
+    end
+
+    it "should not require confirmation of that attribute" do
+      @model.should_not validate_confirmation_of(:attr)
+    end
+  end
+end

data/spec/shoulda/active_model/validate_format_of_matcher_spec.rb

@@ -0,0 +1,38 @@
+require 'spec_helper'
+
+describe Shoulda::Matchers::ActiveModel::ValidateFormatOfMatcher do
+
+  context "a postal code" do
+    before do
+      define_model :example, :attr => :string do
+        validates_format_of :attr, :with => /^\d{5}$/
+      end
+      @model = Example.new
+    end
+
+    it "should be valid" do
+      @model.should validate_format_of(:attr).with('12345')
+    end
+
+    it "should not be valid with alpha in zip" do
+      @model.should_not validate_format_of(:attr).with('1234a')
+      @model.should validate_format_of(:attr).not_with('1234a')
+    end
+
+    it "should not be valid with too few digits" do
+      @model.should_not validate_format_of(:attr).with('1234')
+      @model.should validate_format_of(:attr).not_with('1234')
+    end
+
+    it "should not be valid with too many digits" do
+      @model.should_not validate_format_of(:attr).with('123456')
+      @model.should validate_format_of(:attr).not_with('123456')
+    end
+
+    it "should raise error if you try to call both with and not_with" do
+      expect { validate_format_of(:attr).not_with('123456').with('12345') }.
+        to raise_error(RuntimeError)
+    end
+  end
+
+end

data/spec/shoulda/active_model/validate_numericality_of_matcher_spec.rb

@@ -0,0 +1,62 @@
+require 'spec_helper'
+
+describe Shoulda::Matchers::ActiveModel::ValidateNumericalityOfMatcher do
+
+  context "a numeric attribute" do
+    before do
+      define_model :example, :attr => :string do
+        validates_numericality_of :attr
+      end
+      @model = Example.new
+    end
+
+    it "should only allow numeric values for that attribute" do
+      @model.should validate_numericality_of(:attr)
+    end
+
+    it "should not override the default message with a blank" do
+      @model.should validate_numericality_of(:attr).with_message(nil)
+    end
+  end
+
+  context "a numeric attribute which must be integer" do
+    before do
+      define_model :example, :attr => :string do
+          validates_numericality_of :attr, { :only_integer => true }
+      end
+      @model = Example.new
+    end
+
+    it "should only allow integer values for that attribute" do
+      @model.should validate_numericality_of(:attr).only_integer
+    end
+  end
+
+  context "a numeric attribute with a custom validation message" do
+    before do
+      define_model :example, :attr => :string do
+        validates_numericality_of :attr, :message => 'custom'
+      end
+      @model = Example.new
+    end
+
+    it "should only allow numeric values for that attribute with that message" do
+      @model.should validate_numericality_of(:attr).with_message(/custom/)
+    end
+
+    it "should not allow numeric values for that attribute with another message" do
+      @model.should_not validate_numericality_of(:attr)
+    end
+  end
+
+  context "a non-numeric attribute" do
+    before do
+      @model = define_model(:example, :attr => :string).new
+    end
+
+    it "should not only allow numeric values for that attribute" do
+      @model.should_not validate_numericality_of(:attr)
+    end
+  end
+
+end

data/spec/shoulda/active_model/validate_presence_of_matcher_spec.rb

@@ -0,0 +1,121 @@
+require 'spec_helper'
+
+describe Shoulda::Matchers::ActiveModel::ValidatePresenceOfMatcher do
+
+  context "a required attribute" do
+    before do
+      define_model :example, :attr => :string do
+        validates_presence_of :attr
+      end
+      @model = Example.new
+    end
+
+    it "should require a value" do
+      @model.should validate_presence_of(:attr)
+    end
+
+    it "should not override the default message with a blank" do
+      @model.should validate_presence_of(:attr).with_message(nil)
+    end
+  end
+
+  context "a required attribute on a class using ActiveModel::Validations" do
+    before do
+      define_active_model_class("Example", :accessors => [:attr]) do
+        validates_presence_of :attr
+      end
+      @model = Example.new
+    end
+
+    it "should require a value" do
+      @model.should validate_presence_of(:attr)
+    end
+
+    it "should not override the default message with a blank" do
+      @model.should validate_presence_of(:attr).with_message(nil)
+    end
+  end
+
+  context "an optional attribute" do
+    before do
+      @model = define_model(:example, :attr => :string).new
+    end
+
+    it "should not require a value" do
+      @model.should_not validate_presence_of(:attr)
+    end
+  end
+
+  context "an optional attribute on a class using ActiveModel::Validations" do
+    before do
+      @model = define_active_model_class("Example", :accessors => [:attr]).new
+    end
+
+    it "should not require a value" do
+      @model.should_not validate_presence_of(:attr)
+    end
+  end
+
+  context "a required has_many association" do
+    before do
+      define_model :child
+      @model = define_model :parent do
+        has_many :children
+        validates_presence_of :children
+      end.new
+    end
+
+    it "should require the attribute to be set" do
+      @model.should validate_presence_of(:children)
+    end
+  end
+
+  context "an optional has_many association" do
+    before do
+      define_model :child
+      @model = define_model :parent do
+        has_many :children
+      end.new
+    end
+
+    it "should not require the attribute to be set" do
+      @model.should_not validate_presence_of(:children)
+    end
+  end
+
+  context "a required has_and_belongs_to_many association" do
+    before do
+      define_model :child
+      @model = define_model :parent do
+        has_and_belongs_to_many :children
+        validates_presence_of :children
+      end.new
+      create_table "children_parents", :id => false do |t|
+        t.integer :child_id
+        t.integer :parent_id
+      end
+    end
+
+    it "should require the attribute to be set" do
+      @model.should validate_presence_of(:children)
+    end
+  end
+
+  context "an optional has_and_belongs_to_many association" do
+    before do
+      define_model :child
+      @model = define_model :parent do
+        has_and_belongs_to_many :children
+      end.new
+      create_table "children_parents", :id => false do |t|
+        t.integer :child_id
+        t.integer :parent_id
+      end
+    end
+
+    it "should not require the attribute to be set" do
+      @model.should_not validate_presence_of(:children)
+    end
+  end
+
+end

data/spec/shoulda/active_model/validate_uniqueness_of_matcher_spec.rb

@@ -0,0 +1,143 @@
+require 'spec_helper'
+
+describe Shoulda::Matchers::ActiveModel::ValidateUniquenessOfMatcher do
+  context "a unique attribute" do
+    before do
+      @model = define_model(:example, :attr  => :string,
+                                      :other => :integer) do
+        validates_uniqueness_of :attr
+      end.new
+    end
+
+    context "with an existing value" do
+      before do
+        @existing = Example.create!(:attr => 'value', :other => 1)
+      end
+
+      it "should require a unique value for that attribute" do
+        @model.should validate_uniqueness_of(:attr)
+      end
+
+      it "should pass when the subject is an existing record" do
+        @existing.should validate_uniqueness_of(:attr)
+      end
+
+      it "should fail when a scope is specified" do
+        @model.should_not validate_uniqueness_of(:attr).scoped_to(:other)
+      end
+    end
+
+    context "without an existing value" do
+      before do
+        Example.find(:first).should be_nil
+        @matcher = validate_uniqueness_of(:attr)
+      end
+
+      it "should fail to require a unique value" do
+        @model.should_not @matcher
+      end
+
+      it "should alert the tester that an existing value is not present" do
+        @matcher.matches?(@model)
+        @matcher.negative_failure_message.should =~ /^Can't find first .*/
+      end
+    end
+  end
+
+  context "a unique attribute with a custom error and an existing value" do
+    before do
+      @model = define_model(:example, :attr => :string) do
+        validates_uniqueness_of :attr, :message => 'Bad value'
+      end.new
+      Example.create!(:attr => 'value')
+    end
+
+    it "should fail when checking the default message" do
+      @model.should_not validate_uniqueness_of(:attr)
+    end
+
+    it "should fail when checking a message that doesn't match" do
+      @model.should_not validate_uniqueness_of(:attr).with_message(/abc/i)
+    end
+
+    it "should pass when checking a message that matches" do
+      @model.should validate_uniqueness_of(:attr).with_message(/bad/i)
+    end
+  end
+
+  context "a scoped unique attribute with an existing value" do
+    before 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
+
+    it "should pass when the correct scope is specified" do
+      @model.should validate_uniqueness_of(:attr).scoped_to(:scope1, :scope2)
+    end
+
+    it "should pass when the subject is an existing record" do
+      @existing.should validate_uniqueness_of(:attr).scoped_to(:scope1, :scope2)
+    end
+
+    it "should fail when a different scope is specified" do
+      @model.should_not validate_uniqueness_of(:attr).scoped_to(:scope1)
+    end
+
+    it "should fail when no scope is specified" do
+      @model.should_not validate_uniqueness_of(:attr)
+    end
+
+    it "should fail when a non-existent attribute is specified as a scope" do
+      @model.should_not validate_uniqueness_of(:attr).scoped_to(:fake)
+    end
+  end
+
+  context "a non-unique attribute with an existing value" do
+    before do
+      @model = define_model(:example, :attr => :string).new
+      Example.create!(:attr => 'value')
+    end
+
+    it "should not require a unique value for that attribute" do
+      @model.should_not validate_uniqueness_of(:attr)
+    end
+  end
+
+  context "a case sensitive unique attribute with an existing value" do
+    before do
+      @model = define_model(:example, :attr  => :string) do
+        validates_uniqueness_of :attr, :case_sensitive => true
+      end.new
+      Example.create!(:attr => 'value')
+    end
+
+    it "should not require a unique, case-insensitive value for that attribute" do
+      @model.should_not validate_uniqueness_of(:attr).case_insensitive
+    end
+
+    it "should require a unique, case-sensitive value for that attribute" do
+      @model.should validate_uniqueness_of(:attr)
+    end
+  end
+
+  context "a case sensitive unique integer attribute with an existing value" do
+    before do
+      @model = define_model(:example, :attr  => :integer) do
+        validates_uniqueness_of :attr, :case_sensitive => true
+      end.new
+      Example.create!(:attr => 'value')
+    end
+
+    it "should require a unique, case-insensitive value for that attribute" do
+      @model.should validate_uniqueness_of(:attr).case_insensitive
+    end
+
+    it "should require a unique, case-sensitive value for that attribute" do
+      @model.should validate_uniqueness_of(:attr)
+    end
+  end
+end