shoulda-matchers 1.4.2 → 1.5.0

data/spec/shoulda/active_model/validate_numericality_of_matcher_spec.rb

@@ -1,112 +0,0 @@
-require 'spec_helper'
-
-describe Shoulda::Matchers::ActiveModel::ValidateNumericalityOfMatcher do
-  it "should state in its description that it allows only numeric values" do
-    matcher = Shoulda::Matchers::ActiveModel::ValidateNumericalityOfMatcher.new(:attr)
-    matcher.description.should == "only allow numeric values for attr"
-  end
-
-  context "given 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
-      matcher = new_matcher(:attr)
-      matcher.matches?(@model).should be_true
-    end
-
-    it "should not override the default message with a blank" do
-      matcher = new_matcher(:attr)
-      matcher.with_message(nil)
-      matcher.matches?(@model).should be_true
-    end
-
-    context "when asked to enforce integer values for that attribute" do
-      it "should not match" do
-        matcher = new_matcher(:attr)
-        matcher.only_integer
-        matcher.matches?(@model).should be_false
-      end
-
-      it "should fail with the ActiveRecord :not_an_integer message" do
-        matcher = new_matcher(:attr)
-        matcher.only_integer
-        matcher.matches?(@model)
-        matcher.failure_message.should include 'Expected errors to include "must be an integer"'
-      end
-    end
-  end
-
-  context "given 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 "allows integer values for that attribute" do
-      matcher = new_matcher(:attr)
-      matcher.only_integer
-      matcher.matches?(@model).should be_true
-    end
-
-    it "does not allow non-integer values for that attribute" do
-      matcher = new_matcher(:attr)
-      matcher.only_integer
-      matcher.matches?(@model).should be_true
-    end
-
-    it "should state in its description that it allows only integer values" do
-      matcher = new_matcher(:attr)
-      matcher.only_integer
-      matcher.description.should == "only allow numeric, integer values for attr"
-    end
-  end
-
-  context "given 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
-      matcher = new_matcher(:attr)
-      matcher.with_message(/custom/)
-      matcher.matches?(@model).should be_true
-    end
-
-    it "should not allow numeric values for that attribute with another message" do
-      matcher = new_matcher(:attr)
-      matcher.with_message(/wrong/)
-      matcher.matches?(@model).should be_false
-    end
-  end
-
-  context "given 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
-      matcher = new_matcher(:attr)
-      matcher.matches?(@model).should be_false
-    end
-
-    it "should fail with the ActiveRecord :not_a_number message" do
-      matcher = new_matcher(:attr)
-      matcher.matches?(@model)
-      matcher.failure_message.should include 'Expected errors to include "is not a number"'
-    end
-  end
-
-  def new_matcher(attr)
-    Shoulda::Matchers::ActiveModel::ValidateNumericalityOfMatcher.new(attr)
-  end
-end

data/spec/shoulda/active_model/validate_presence_of_matcher_spec.rb

@@ -1,135 +0,0 @@
-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
-
-  if Rails::VERSION::STRING.to_f >= 3.2
-    context "a strictly required attribute" do
-      before do
-        define_model :example, :attr => :string do
-          validates_presence_of :attr, :strict => true
-        end
-        @model = Example.new
-      end
-
-      it "should require a value" do
-        @model.should validate_presence_of(:attr).strict
-      end
-    end
-  end
-
-end

data/spec/shoulda/active_model/validate_uniqueness_of_matcher_spec.rb

@@ -1,154 +0,0 @@
-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
-        attr_accessible :attr, :other
-        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 "does not not require a created instance" do
-        @model.should @matcher
-      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
-        attr_accessible :attr
-        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,
-                                      :other => :integer) do
-        attr_accessible :attr, :scope1, :scope2, :other
-        validates_uniqueness_of :attr, :scope => [:scope1, :scope2]
-      end.new
-      @existing = Example.create!(:attr => 'value', :scope1 => 1, :scope2 => 2, :other => 3)
-    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 too narrow of a scope is specified" do
-      @model.should_not validate_uniqueness_of(:attr).scoped_to(:scope1, :scope2, :other)
-    end
-
-    it "should fail when too broad of a scope is specified" do
-      @model.should_not validate_uniqueness_of(:attr).scoped_to(:scope1)
-    end
-
-    it "should fail when a different scope is specified" do
-      @model.should_not validate_uniqueness_of(:attr).scoped_to(:other)
-    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) do
-        attr_accessible :attr
-      end.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
-        attr_accessible :attr
-        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
-        attr_accessible :attr
-        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

data/spec/shoulda/active_record/accept_nested_attributes_for_matcher_spec.rb

@@ -1,84 +0,0 @@
-require 'spec_helper'
-
-describe Shoulda::Matchers::ActiveRecord::AcceptNestedAttributesForMatcher do
-  before do
-    define_model :child, :parent_id => :integer
-    define_model :parent do
-      has_many :children
-    end
-  end
-
-  let(:parent) { Parent.new }
-  let(:matcher) { accept_nested_attributes_for(:children) }
-
-  it "should accept an existing declaration" do
-    Parent.accepts_nested_attributes_for :children
-    matcher.matches?(parent).should be_true
-  end
-
-  it "should reject a missing declaration" do
-    matcher.matches?(parent).should be_false
-    matcher.failure_message.should == "Expected Parent to accept nested attributes for children (is not declared)"
-  end
-
-  context "allow_destroy" do
-    it "should accept a valid truthy value" do
-      Parent.accepts_nested_attributes_for :children, :allow_destroy => true
-      matcher.allow_destroy(true).matches?(parent).should be_true
-    end
-
-    it "should accept a valid falsey value" do
-      Parent.accepts_nested_attributes_for :children, :allow_destroy => false
-      matcher.allow_destroy(false).matches?(parent).should be_true
-    end
-
-    it "should reject an invalid truthy value" do
-      Parent.accepts_nested_attributes_for :children, :allow_destroy => true
-      matcher.allow_destroy(false).matches?(parent).should be_false
-      matcher.failure_message.should =~ /should not allow destroy/
-    end
-
-    it "should reject an invalid falsey value" do
-      Parent.accepts_nested_attributes_for :children, :allow_destroy => false
-      matcher.allow_destroy(true).matches?(parent).should be_false
-      matcher.failure_message.should =~ /should allow destroy/
-    end
-  end
-
-  context "limit" do
-    it "should accept a correct value" do
-      Parent.accepts_nested_attributes_for :children, :limit => 3
-      matcher.limit(3).matches?(parent).should be_true
-    end
-
-    it "should reject a false value" do
-      Parent.accepts_nested_attributes_for :children, :limit => 3
-      matcher.limit(2).matches?(parent).should be_false
-      matcher.failure_message.should =~ /limit should be 2, got 3/
-    end
-  end
-
-  context "update_only" do
-    it "should accept a valid truthy value" do
-      Parent.accepts_nested_attributes_for :children, :update_only => true
-      matcher.update_only(true).matches?(parent).should be_true
-    end
-
-    it "should accept a valid falsey value" do
-      Parent.accepts_nested_attributes_for :children, :update_only => false
-      matcher.update_only(false).matches?(parent).should be_true
-    end
-
-    it "should reject an invalid truthy value" do
-      Parent.accepts_nested_attributes_for :children, :update_only => true
-      matcher.update_only(false).matches?(parent).should be_false
-      matcher.failure_message.should =~ /should not be update only/
-    end
-
-    it "should reject an invalid falsey value" do
-      Parent.accepts_nested_attributes_for :children, :update_only => false
-      matcher.update_only(true).matches?(parent).should be_false
-      matcher.failure_message.should =~ /should be update only/
-    end
-  end
-end