remarkable_activerecord 3.0.0

data/spec/validate_inclusion_of_matcher_spec.rb

@@ -0,0 +1,84 @@
+require File.expand_path(File.dirname(__FILE__) + '/spec_helper')
+
+describe 'validate_inclusion_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 do
+      validates_inclusion_of :title, :size, options
+    end
+
+    validate_inclusion_of(:title, :size)
+  end
+
+  describe 'messages' do
+    before(:each){ @matcher = define_and_validate(:in => 2..10) }
+
+    it 'should contain a description' do
+      @matcher.in(2..10)
+      @matcher.description.should == 'ensure inclusion of title and size in 2..10'
+
+      @matcher = validate_inclusion_of(:title, :size).in('X', 'Y', 'Z')
+      @matcher.description.should == 'ensure inclusion of title and size in "X", "Y", and "Z"'
+    end
+
+    it 'should set is_valid? message' do
+      @matcher.in(1..10).matches?(@model)
+      @matcher.failure_message.should == 'Expected Product to be valid when title is set to 1'
+    end
+
+    it 'should set is_invalid? message' do
+      @matcher.in(3..10).matches?(@model)
+      @matcher.failure_message.should == 'Expected Product to be invalid when title is set to 2'
+    end
+
+    it 'should set allow_nil? message' do
+      @matcher.allow_nil.matches?(@model)
+      @matcher.failure_message.should == 'Expected Product to allow nil values for title'
+    end
+
+    it 'should set allow_blank? message' do
+      @matcher.allow_blank.matches?(@model)
+      @matcher.failure_message.should == 'Expected Product to allow blank values for title'
+    end
+  end
+
+  describe 'matchers' do
+    it { should define_and_validate(:in => ['X', 'Y', 'Z']).in('X', 'Y', 'Z') }
+    it { should_not define_and_validate(:in => ['X', 'Y', 'Z']).in('A') }
+
+    it { should define_and_validate(:in => 2..3).in(2..3) }
+    it { should define_and_validate(:in => 2..20).in(2..20) }
+    it { should_not define_and_validate(:in => 2..20).in(1..20) }
+    it { should_not define_and_validate(:in => 2..20).in(3..20) }
+    it { should_not define_and_validate(:in => 2..20).in(2..19) }
+    it { should_not define_and_validate(:in => 2..20).in(2..21) }
+
+    it { should define_and_validate(:in => ['X', 'Y', 'Z'], :message => 'valid').in('X', 'Y', 'Z').message('valid') }
+
+    create_optional_boolean_specs(:allow_nil, self, :in => ['X'])
+    create_optional_boolean_specs(:allow_blank, self, :in => ['X'])
+  end
+
+  describe 'macros' do
+    describe 'with array' do
+      before(:each){ define_and_validate(:in => ['X', 'Y', 'Z']) }
+
+      should_validate_inclusion_of :title, :in => ['X']
+      should_validate_inclusion_of :title, :size, :in => ['X']
+      should_not_validate_inclusion_of :title, :size, :in => ['A']
+    end
+
+    describe 'with range' do
+      before(:each){ define_and_validate(:in => 2..20) }
+
+      should_validate_inclusion_of :title, :in => 2..20
+      should_not_validate_inclusion_of :title, :in => 1..20
+      should_not_validate_inclusion_of :title, :in => 3..20
+      should_not_validate_inclusion_of :title, :in => 2..19
+      should_not_validate_inclusion_of :title, :in => 2..21
+    end
+  end
+end
+

data/spec/validate_length_of_matcher_spec.rb

@@ -0,0 +1,165 @@
+require File.expand_path(File.dirname(__FILE__) + '/spec_helper')
+
+describe 'validate_length_of' do
+  include ModelBuilder
+
+  # Defines a model, create a validation and returns a raw matcher
+  def define_and_validate(options={})
+    options = options.merge(:within => 3..5) if options.slice(:in, :within, :maximum, :minimum, :is).empty?
+
+    @model = define_model :product, :size => :string, :category => :string do
+      validates_length_of :size, options
+    end
+
+    validate_length_of(:size)
+  end
+
+  describe 'messages' do
+    before(:each){ @matcher = define_and_validate }
+  
+    it 'should contain a description' do
+      @matcher.within(3..5)
+      @matcher.description.should == 'ensure length of size is within 3..5 characters'
+
+      @matcher.within(nil).in(3..5)
+      @matcher.description.should == 'ensure length of size is within 3..5 characters'
+
+      @matcher.in(nil).is(3)
+      @matcher.description.should == 'ensure length of size is equal to 3 characters'
+
+      @matcher.is(nil).maximum(5)
+      @matcher.description.should == 'ensure length of size is maximum 5 characters'
+
+      @matcher.maximum(nil).minimum(3)
+      @matcher.description.should == 'ensure length of size is minimum 3 characters'
+
+      @matcher.allow_nil(false)
+      @matcher.description.should == 'ensure length of size is minimum 3 characters and not allowing nil values'
+
+      @matcher.allow_blank
+      @matcher.description.should == 'ensure length of size is minimum 3 characters, not allowing nil values, and allowing blank values'
+    end
+
+    it 'should set less_than_min_length? message' do
+      @matcher.within(4..5).matches?(@model)
+      @matcher.failure_message.should == 'Expected Product to be invalid when size length is less than 4 characters'
+    end
+
+    it 'should set exactly_min_length? message' do
+      @matcher.should_receive(:less_than_min_length?).and_return(true)
+      @matcher.within(2..5).matches?(@model)
+      @matcher.failure_message.should == 'Expected Product to be valid when size length is 2 characters'
+    end
+
+    it 'should set more_than_max_length? message' do
+      @matcher.within(3..4).matches?(@model)
+      @matcher.failure_message.should == 'Expected Product to be invalid when size length is more than 4 characters'
+    end
+
+    it 'should set exactly_max_length? message' do
+      @matcher.should_receive(:more_than_max_length?).and_return(true)
+      @matcher.within(3..6).matches?(@model)
+      @matcher.failure_message.should == 'Expected Product to be valid when size length is 6 characters'
+    end
+
+    it 'should set allow_blank? message' do
+      @matcher.within(3..5).allow_blank.matches?(@model)
+      @matcher.failure_message.should == 'Expected Product to allow blank values for size'
+    end
+
+    it 'should set allow_nil? message' do
+      @matcher.within(3..5).allow_nil.matches?(@model)
+      @matcher.failure_message.should == 'Expected Product to allow nil values for size'
+    end
+  end
+
+  describe 'matcher' do
+    # Wrap specs without options. Usually a couple specs.
+    describe 'without options' do
+      before(:each){ define_and_validate }
+
+      it { should validate_length_of(:size, :within => 3..5) }
+      it { should_not validate_length_of(:category, :within => 3..5) }
+    end
+
+    describe "with message option" do
+
+      if RAILS_VERSION =~ /^2.3/
+        it { should define_and_validate(:message => 'not valid').within(3..5).message('not valid') }
+        it { should_not define_and_validate(:message => 'not valid').within(3..5).message('valid') }
+      else
+        it { should define_and_validate(:too_short => 'not valid', :too_long => 'not valid').within(3..5).message('not valid') }
+        it { should_not define_and_validate(:too_short => 'not valid', :too_long => 'not valid').within(3..5).message('valid') }
+      end
+
+      it { should define_and_validate(:is => 4, :message => 'not valid').is(4).message('not valid') }
+      it { should_not define_and_validate(:is => 4, :message => 'not valid').is(4).message('valid') }
+    end
+
+    describe "with too_short option" do
+      it { should define_and_validate(:too_short => 'not valid').within(3..5).too_short('not valid') }
+      it { should_not define_and_validate(:too_short => 'not valid').within(3..5).too_short('valid') }
+    end
+
+    describe "with too_long option" do
+      it { should define_and_validate(:too_long => 'not valid').within(3..5).too_long('not valid') }
+      it { should_not define_and_validate(:too_long => 'not valid').within(3..5).too_long('valid') }
+    end
+
+    describe "with wrong_length option" do
+      it { should define_and_validate(:is => 4, :wrong_length => 'not valid').is(4).wrong_length('not valid') }
+      it { should_not define_and_validate(:is => 4, :wrong_length => 'not valid').is(4).wrong_length('valid') }
+    end
+
+    describe "with within option" do
+      it { should define_and_validate(:within => 3..5).within(3..5)     }
+      it { should_not define_and_validate(:within => 3..5).within(2..5) }
+      it { should_not define_and_validate(:within => 3..5).within(4..5) }
+      it { should_not define_and_validate(:within => 3..5).within(3..4) }
+      it { should_not define_and_validate(:within => 3..5).within(3..6) }
+    end
+
+    describe "with in option" do
+      it { should define_and_validate(:in => 3..5).within(3..5)     }
+      it { should_not define_and_validate(:in => 3..5).within(2..5) }
+      it { should_not define_and_validate(:in => 3..5).within(4..5) }
+      it { should_not define_and_validate(:in => 3..5).within(3..4) }
+      it { should_not define_and_validate(:in => 3..5).within(3..6) }
+    end
+
+    describe "with minimum option" do
+      it { should define_and_validate(:minimum => 3).minimum(3)     }
+      it { should_not define_and_validate(:minimum => 3).minimum(2) }
+      it { should_not define_and_validate(:minimum => 3).minimum(4) }
+    end
+
+    describe "with maximum option" do
+      it { should define_and_validate(:maximum => 3).maximum(3)     }
+      it { should_not define_and_validate(:maximum => 3).maximum(2) }
+      it { should_not define_and_validate(:maximum => 3).maximum(4) }
+    end
+
+    describe "with is option" do
+      it { should define_and_validate(:is => 3).is(3)     }
+      it { should_not define_and_validate(:is => 3).is(2) }
+      it { should_not define_and_validate(:is => 3).is(4) }
+    end
+
+    # 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)
+  end
+
+  # In macros we include just a few tests to assure that everything works properly
+  describe 'macros' do
+    before(:each) { define_and_validate }
+
+    should_validate_length_of :size, :in => 3..5
+    should_validate_length_of :size, :within => 3..5
+    should_not_validate_length_of :size, :within => 2..5
+    should_not_validate_length_of :size, :within => 4..5
+    should_not_validate_length_of :size, :within => 3..4
+    should_not_validate_length_of :size, :within => 3..6
+    should_not_validate_length_of :category, :in => 3..5
+  end
+end

data/spec/validate_numericality_of_matcher_spec.rb

@@ -0,0 +1,180 @@
+require File.expand_path(File.dirname(__FILE__) + '/spec_helper')
+
+describe 'validate_numericality_of' do
+  include ModelBuilder
+
+  # Defines a model, create a validation and returns a raw matcher
+  def define_and_validate(options={})
+    @model = define_model :product, :price => :integer, :size => :integer do
+      validates_numericality_of :price, options
+    end
+
+    validate_numericality_of(:price)
+  end
+
+  describe 'messages' do
+    before(:each){ @matcher = define_and_validate }
+
+    # To tests descriptions, we don't need to use mocks neither stubs.
+    # We just need to define a matcher.
+    #
+    it 'should contain a description' do
+      matcher = validate_numericality_of(:age)
+      matcher.description.should == 'ensure numericality of age'
+
+      matcher.allow_nil(false)
+      matcher.description.should == 'ensure numericality of age not allowing nil values'
+
+      matcher.allow_blank
+      matcher.description.should == 'ensure numericality of age not allowing nil values and allowing blank values'
+
+      matcher = validate_numericality_of(:age, :only_integer => true)
+      matcher.description.should == 'ensure numericality of age allowing only integer values'
+
+      matcher = validate_numericality_of(:age, :even => true)
+      matcher.description.should == 'ensure numericality of age allowing only even values'
+
+      matcher = validate_numericality_of(:age, :odd => true)
+      matcher.description.should == 'ensure numericality of age allowing only odd values'
+
+      matcher = validate_numericality_of(:age, :equal_to => 10)
+      matcher.description.should == 'ensure numericality of age is equal to 10'
+
+      matcher = validate_numericality_of(:age, :less_than_or_equal_to => 10)
+      matcher.description.should == 'ensure numericality of age is less than or equal to 10'
+
+      matcher = validate_numericality_of(:age, :greater_than_or_equal_to => 10)
+      matcher.description.should == 'ensure numericality of age is greater than or equal to 10'
+
+      matcher = validate_numericality_of(:age, :less_than => 10)
+      matcher.description.should == 'ensure numericality of age is less than 10'
+
+      matcher = validate_numericality_of(:age, :greater_than => 10)
+      matcher.description.should == 'ensure numericality of age is greater than 10'
+
+      matcher = validate_numericality_of(:age, :greater_than => 10, :less_than => 20)
+      matcher.description.should == 'ensure numericality of age is greater than 10 and is less than 20'
+    end
+
+    it 'should set only_numeric_values? message' do
+      @matcher.should_receive(:only_numeric_values?).and_return(false)
+      @matcher.matches?(@model)
+      @matcher.failure_message.should == 'Expected Product to allow only numeric values for price'
+      @matcher.negative_failure_message.should == 'Did not expect Product to allow only numeric values for price'
+    end
+
+    it 'should set only_integer_values? message' do
+      @matcher.should_receive(:only_integer?).and_return([false, { :not => '' }])
+      @matcher.matches?(@model)
+      @matcher.failure_message.should == 'Expected Product to allow only integer values for price'
+    end
+
+    it 'should set only_odd_values? message' do
+      @matcher.should_receive(:only_odd?).and_return(false)
+      @matcher.matches?(@model)
+      @matcher.failure_message.should == 'Expected Product to allow only odd values for price'
+    end
+
+    it 'should set only_even_values? message' do
+      @matcher.should_receive(:only_even?).and_return(false)
+      @matcher.matches?(@model)
+      @matcher.failure_message.should == 'Expected Product to allow only even values for price'
+    end
+
+    it 'should set equals_to? message' do
+      @matcher.should_receive(:equals_to?).and_return([false, { :count => 10 }])
+      @matcher.matches?(@model)
+      @matcher.failure_message.should == 'Expected Product to be valid only when price is equal to 10'
+    end
+
+    it 'should set less_than_minimum? message' do
+      @matcher.should_receive(:less_than_minimum?).and_return([false, { :count => 10 }])
+      @matcher.matches?(@model)
+      @matcher.failure_message.should == 'Expected Product to be invalid when price is less than 10'
+    end
+
+    it 'should set more_than_maximum? message' do
+      @matcher.should_receive(:more_than_maximum?).and_return([false, { :count => 10 }])
+      @matcher.matches?(@model)
+      @matcher.failure_message.should == 'Expected Product to be invalid when price is greater than 10'
+    end
+  end
+
+  describe 'matcher' do
+    # Wrap specs without options. Usually a couple specs.
+    describe 'without options' do
+      before(:each){ define_and_validate }
+
+      it { should validate_numericality_of(:price) }
+      it { should_not validate_numericality_of(:size) }
+    end
+
+    # Wrap each option inside a describe group.
+    describe 'with equal_to option' do
+      it { should define_and_validate(:equal_to => 100).equal_to(100) }
+      it { should_not define_and_validate(:equal_to => 100).equal_to(99) }
+      it { should_not define_and_validate(:equal_to => 100).equal_to(101) }
+    end
+
+    describe 'with less_than option' do
+      it { should define_and_validate(:less_than => 100).less_than(100) }
+      it { should_not define_and_validate(:less_than => 100).less_than(99) }
+      it { should_not define_and_validate(:less_than => 100).less_than(101) }
+    end
+
+    describe 'with greater_than option' do
+      it { should define_and_validate(:greater_than => 100).greater_than(100) }
+      it { should_not define_and_validate(:greater_than => 100).greater_than(99) }
+      it { should_not define_and_validate(:greater_than => 100).greater_than(101) }
+    end
+
+    describe 'with less_than_or_equal_to option' do
+      it { should define_and_validate(:less_than_or_equal_to => 100).less_than_or_equal_to(100) }
+      it { should_not define_and_validate(:less_than_or_equal_to => 100).less_than_or_equal_to(99) }
+      it { should_not define_and_validate(:less_than_or_equal_to => 100).less_than_or_equal_to(101) }
+    end
+
+    describe 'with greater_than_or_equal_to option' do
+      it { should define_and_validate(:greater_than_or_equal_to => 100).greater_than_or_equal_to(100) }
+      it { should_not define_and_validate(:greater_than_or_equal_to => 100).greater_than_or_equal_to(99) }
+      it { should_not define_and_validate(:greater_than_or_equal_to => 100).greater_than_or_equal_to(101) }
+    end
+
+    describe "with even option" do
+      it { should define_and_validate(:even => true).even }
+      it { should_not define_and_validate.even(true)      }
+    end
+
+    describe "with odd option" do
+      it { should define_and_validate(:odd => true).odd }
+      it { should_not define_and_validate.odd(true)     }
+    end
+
+    describe "with several options" do
+      it { should define_and_validate(:less_than => 100, :greater_than => 10).less_than(100).greater_than(10) }
+      it { should define_and_validate(:less_than => 100, :message => 'not valid').less_than(100).message('not valid') }
+      it { should define_and_validate(:less_than_or_equal_to => 100, :greater_than => 1).less_than_or_equal_to(100).greater_than(1) }
+    end
+
+    # A macro to spec messages
+    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(:only_integer, self)
+  end
+
+  # In macros we include just a few tests to assure that everything works properly
+  describe 'macros' do
+    before(:each) { define_and_validate(:less_than => 100000, :greater_than => 9999) }
+
+    should_validate_numericality_of :price
+    should_validate_numericality_of :price, :less_than => 100000
+    should_validate_numericality_of :price, :greater_than => 9999
+    should_validate_numericality_of :price, :less_than => 100000, :greater_than => 999
+    should_not_validate_numericality_of :size
+    should_not_validate_numericality_of :price, :less_than => 55555
+    should_not_validate_numericality_of :price, :greater_than => 55555
+  end
+end

data/spec/validate_presence_of_matcher_spec.rb

@@ -0,0 +1,52 @@
+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)
+  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

@@ -0,0 +1,150 @@
+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 => :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
+  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