remarkable_activerecord 3.1.9 → 3.1.10

data/spec/validate_presence_of_matcher_spec.rb

@@ -1,84 +0,0 @@
-require File.expand_path(File.dirname(__FILE__) + '/spec_helper')
-
-describe 'validate_presence_of' do
-  include ModelBuilder
-
-  # Defines a model, create a validation and returns a raw matcher
-  def define_and_validate(options={})
-    @model = define_model :product, :title => :string, :size => :string, :category => :string do
-      validates_presence_of :title, :size, options
-    end
-
-    validate_presence_of(:title, :size)
-  end
-
-  describe 'messages' do
-    before(:each){ @matcher = define_and_validate }
-
-    it 'should contain a description' do
-      @matcher.description.should == 'require title and size to be set'
-    end
-
-    it 'should set allow_nil? message' do
-      @matcher = validate_presence_of(:category)
-      @matcher.matches?(@model)
-      @matcher.failure_message.should == 'Expected Product to require category to be set'
-      @matcher.negative_failure_message.should == 'Did not expect Product to require category to be set'
-    end
-  end
-
-  describe 'matchers' do
-    describe 'without options' do
-      before(:each){ define_and_validate }
-
-      it { should validate_presence_of(:size)         }
-      it { should validate_presence_of(:title)        }
-      it { should validate_presence_of(:title, :size) }
-      it { should_not validate_presence_of(:category) }
-    end
-
-    create_message_specs(self)
-
-    describe 'with belongs to' do
-      def define_and_validate(validation)
-        define_model :category
-
-        define_model :product, :category_id => :integer do
-          belongs_to :category
-          validates_presence_of :category if validation
-        end
-
-        validate_presence_of(:category)
-      end
-
-      it { should define_and_validate(true) }
-      it { should_not define_and_validate(false) }
-    end
-
-    describe 'with has many' do
-      def define_and_validate(validation)
-        define_model :stocks, :product_id => :integer
-
-        define_model :product do
-          has_many :stocks
-          validates_presence_of :stocks if validation
-        end
-
-        validate_presence_of :stocks
-      end
-
-      it { should define_and_validate(true) }
-      it { should_not define_and_validate(false) }
-    end
-  end
-
-  describe 'macros' do
-    before(:each){ define_and_validate }
-
-    should_validate_presence_of(:size)
-    should_validate_presence_of(:title)
-    should_validate_presence_of(:size, :title)
-    should_not_validate_presence_of(:category)
-  end
-end
-

data/spec/validate_uniqueness_of_matcher_spec.rb

@@ -1,182 +0,0 @@
-require File.expand_path(File.dirname(__FILE__) + '/spec_helper')
-
-describe 'validate_uniqueness_of' do
-  include ModelBuilder
-
-  # Defines a model, create a validation and returns a raw matcher
-  def define_and_validate(options={})
-    @model = define_model :user, :username => :string, :email => :string, :public => :boolean, :deleted_at => :timestamp do
-      validates_uniqueness_of :username, options
-    end
-
-    # Create a model
-    User.create(:username => 'jose', :deleted_at => 1.day.ago, :public => false)
-
-    validate_uniqueness_of(:username)
-  end
-
-  describe 'messages' do
-    before(:each){ @matcher = define_and_validate }
-
-    it 'should contain a description' do
-      @matcher.description.should == 'require unique values for username'
-
-      @matcher.case_sensitive
-      @matcher.description.should == 'require unique values for username case sensitive'
-
-      @matcher.case_sensitive(false)
-      @matcher.description.should == 'require unique values for username case insensitive'
-
-      @matcher.allow_nil
-      @matcher.description.should == 'require unique values for username case insensitive and allowing nil values'
-
-      @matcher.allow_blank(false)
-      @matcher.description.should == 'require unique values for username case insensitive, allowing nil values, and not allowing blank values'
-
-      @matcher = validate_uniqueness_of(:username, :scope => :email)
-      @matcher.description.should == 'require unique values for username scoped to :email'
-
-      @matcher = validate_uniqueness_of(:username)
-      @matcher.scope(:email)
-      @matcher.scope(:public)
-      @matcher.description.should == 'require unique values for username scoped to :email and :public'
-    end
-
-    it 'should set responds_to_scope? message' do
-      @matcher.scope(:title).matches?(@model)
-      @matcher.failure_message.should == 'Expected User instance responds to title='
-    end
-
-    it 'should set is_unique? message' do
-      @matcher = validate_uniqueness_of(:email)
-      @matcher.matches?(@model)
-      @matcher.failure_message.should == 'Expected User to require unique values for email'
-    end
-
-    it 'should set case_sensitive? message' do
-      @matcher.case_sensitive(false).matches?(@model)
-      @matcher.failure_message.should == 'Expected User to not be case sensitive on username validation'
-    end
-
-    it 'should valid with new scope' do
-      @matcher.scope(:email).matches?(@model)
-      @matcher.failure_message.should == 'Expected User to be valid when username scope (email) change'
-    end
-  end
-
-  describe 'matcher' do
-
-    describe 'without options' do
-      before(:each){ define_and_validate }
-
-      it { should validate_uniqueness_of(:username) }
-      it { should_not validate_uniqueness_of(:email) }
-    end
-
-    describe 'scoped to' do
-      it { should define_and_validate(:scope => :email).scope(:email) }
-      it { should define_and_validate(:scope => :public).scope(:public) }
-      it { should define_and_validate(:scope => :deleted_at).scope(:deleted_at) }
-      it { should define_and_validate(:scope => [:email, :public]).scope(:email, :public) }
-      it { should define_and_validate(:scope => [:email, :public, :deleted_at]).scope(:email, :public, :deleted_at) }
-      it { should_not define_and_validate(:scope => :email).scope(:title) }
-      it { should_not define_and_validate(:scope => :email).scope(:public) }
-    end
-
-    create_message_specs(self)
-
-    # Those are macros to test optionals which accept only boolean values
-    create_optional_boolean_specs(:allow_nil, self)
-    create_optional_boolean_specs(:allow_blank, self)
-    create_optional_boolean_specs(:case_sensitive, self)
-  end
-
-  describe 'errors' do
-    it 'should raise an error if no object is found' do
-      @matcher = define_and_validate
-      User.destroy_all
-
-      proc { @matcher.matches?(@model) }.should raise_error(ScriptError)
-    end
-
-    it 'should raise an error if no object with not nil attribute is found' do
-      @matcher = define_and_validate.allow_nil
-      User.destroy_all
-
-      User.create(:username => nil)
-      proc { @matcher.matches?(@model) }.should raise_error(ScriptError)
-
-      User.create(:username => 'jose')
-      proc { @matcher.matches?(@model) }.should_not raise_error(ScriptError)
-    end
-
-    it 'should raise an error if no object with not blank attribute is found' do
-      @matcher = define_and_validate.allow_blank
-      User.destroy_all
-
-      User.create(:username => '')
-      proc { @matcher.matches?(@model) }.should raise_error(ScriptError)
-
-      User.create(:username => 'jose')
-      proc { @matcher.matches?(@model) }.should_not raise_error(ScriptError)
-    end
-
-    it 'should raise an error if @existing record is the same as @subject' do
-      @matcher = define_and_validate
-      proc { @matcher.matches?(User.first) }.should raise_error(ScriptError, /which is different from the subject record/)
-    end
-
-    it 'should raise an error if cannot find a new scope value' do
-      @matcher = define_and_validate(:scope => :email).scope(:email)
-
-      User.stub!(:find).and_return do |many, conditions|
-        if many == :all
-          1000.upto(1100).map{|i| User.new(:email => i) }
-        else
-          User.new(:username => 'jose')
-        end
-      end
-      lambda { @matcher.matches?(@model) }.should raise_error(ScriptError)
-
-      User.stub!(:find).and_return do |many, conditions|
-        if many == :all
-          1000.upto(1099).map{|i| User.new(:email => i) }
-        else
-          User.new(:username => 'jose')
-        end
-      end
-      lambda { @matcher.matches?(@model) }.should_not raise_error(ScriptError)
-    end
-
-    describe 'when null or blank values are not allowed' do
-      def define_and_validate(options={})
-        @model = define_model :user, :username => [:string, {:null => false}] do
-          validates_uniqueness_of :username, options
-        end
-
-        User.create(:username => 'jose')
-        validate_uniqueness_of(:username)
-      end
-
-      it { should define_and_validate }
-      it { should define_and_validate(:allow_nil => false).allow_nil(false) }
-
-      it 'should raise an error if allow nil is true but we cannot save nil values in the database'do
-        lambda { should define_and_validate.allow_nil }.should raise_error(ScriptError, /You declared that username accepts nil values in validate_uniqueness_of, but I cannot save nil values in the database, got/)
-      end
-    end
-  end
-
-  describe 'macros' do
-    before(:each){ define_and_validate(:scope => :email) }
-
-    should_validate_uniqueness_of :username
-    should_validate_uniqueness_of :username, :scope => :email
-    should_not_validate_uniqueness_of :email
-    should_not_validate_uniqueness_of :username, :scope => :access_code
-
-    should_validate_uniqueness_of :username do |m|
-      m.scope :email
-    end
-  end
-end