remarkable_activerecord 3.0.1 → 3.0.2

data/spec/validate_presence_of_matcher_spec.rb

@@ -1,52 +1,52 @@
 require File.expand_path(File.dirname(__FILE__) + '/spec_helper')
 
-describe 'validate_presence_of' do
+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 }
+
+  # 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)
+    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.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)
-  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
+
+  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)
+  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,150 +1,169 @@
 require File.expand_path(File.dirname(__FILE__) + '/spec_helper')
 
-describe 'validate_uniqueness_of' do
+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 => :integer, :access_code => :string do
-      validates_uniqueness_of :username, options
-    end
-
-    # Create a model
-    User.create(:username => 'jose')
-
-    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.scope(:email)
-      @matcher.description.should == 'require unique values for username scoped to [:email]'
-
-      @matcher.scope(:email, :access_code)
-      @matcher.description.should == 'require unique values for username scoped to [:email, :access_code]'
-
-      @matcher.case_sensitive
-      @matcher.description.should == 'require unique values for username scoped to [:email, :access_code] and case sensitive'
-
-      @matcher.case_sensitive(false)
-      @matcher.description.should == 'require unique values for username scoped to [:email, :access_code] and case insensitive'
-
-      @matcher.allow_nil
-      @matcher.description.should == 'require unique values for username scoped to [:email, :access_code], case insensitive, and allowing nil values'
-
-      @matcher.allow_blank(false)
-      @matcher.description.should == 'require unique values for username scoped to [:email, :access_code], case insensitive, allowing nil values, and not allowing blank values'
-    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 => [:email, :access_code]).scope(:email, :access_code) }
-      it { should_not define_and_validate(:scope => :email).scope(:title) }
-      it { should_not define_and_validate(:scope => :email).scope(:access_code) }
-    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 nil 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)
+  # Defines a model, create a validation and returns a raw matcher
+  def define_and_validate(options={})
+    @model = define_model :user, :username => :string, :email => :integer, :access_code => :string do
+      validates_uniqueness_of :username, options
+    end
+
+    # Create a model
+    User.create(:username => 'jose')
+
+    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.scope(:email)
+      @matcher.description.should == 'require unique values for username scoped to [:email]'
+
+      @matcher.scope(:email, :access_code)
+      @matcher.description.should == 'require unique values for username scoped to [:email, :access_code]'
+
+      @matcher.case_sensitive
+      @matcher.description.should == 'require unique values for username scoped to [:email, :access_code] and case sensitive'
+
+      @matcher.case_sensitive(false)
+      @matcher.description.should == 'require unique values for username scoped to [:email, :access_code] and case insensitive'
+
+      @matcher.allow_nil
+      @matcher.description.should == 'require unique values for username scoped to [:email, :access_code], case insensitive, and allowing nil values'
+
+      @matcher.allow_blank(false)
+      @matcher.description.should == 'require unique values for username scoped to [:email, :access_code], case insensitive, allowing nil values, and not allowing blank values'
+    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 => [:email, :access_code]).scope(:email, :access_code) }
+      it { should_not define_and_validate(:scope => :email).scope(:title) }
+      it { should_not define_and_validate(:scope => :email).scope(:access_code) }
+    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 nil 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 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
+      proc { @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
+      proc { @matcher.matches?(@model) }.should_not raise_error(ScriptError)
     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
+    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
+
+        # Create a model
+        User.create(:username => Time.now)
+        validate_uniqueness_of(:username)
       end
-      proc { @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
+      it { should define_and_validate }
+      it { should define_and_validate.allow_nil(false) }
+
+      it 'should raise an error if allow nil is true but we cannot save nil values in the database'do
+        proc { 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
-      proc { @matcher.matches?(@model) }.should_not raise_error(ScriptError)
-    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
   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
-  end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: remarkable_activerecord
 version: !ruby/object:Gem::Version 
-  version: 3.0.1
+  version: 3.0.2
 platform: ruby
 authors: 
 - Carlos Brando
@@ -11,7 +11,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2009-04-10 00:00:00 +02:00
+date: 2009-04-13 00:00:00 +02:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -22,7 +22,7 @@ dependencies:
     requirements: 
     - - ">="
       - !ruby/object:Gem::Version 
-        version: 3.0.1
+        version: 3.0.2
     version: 
 description: "Remarkable ActiveRecord: collection of matchers and macros with I18n for ActiveRecord"
 email: