sequel 1.4.0 → 1.5.0

data/spec/record_spec.rb

@@ -6,9 +6,7 @@ describe "Model#save" do
     MODEL_DB.reset
 
     @c = Class.new(Sequel::Model(:items)) do
-      def columns
-        [:id, :x, :y]
-      end
+      columns :id, :x, :y
     end
   end
   
@@ -52,9 +50,7 @@ describe "Model#save_changes" do
     MODEL_DB.reset
 
     @c = Class.new(Sequel::Model(:items)) do
-      def columns
-        [:id, :x, :y]
-      end
+      columns :id, :x, :y
     end
   end
   
@@ -109,47 +105,67 @@ describe "Model#save_changes" do
   end
 end
 
-describe "Model#set" do
-  
+describe "Model#update_values" do
   before(:each) do
     MODEL_DB.reset
 
     @c = Class.new(Sequel::Model(:items)) do
-      def columns
-        [:id, :x, :y]
-      end
+      columns :id, :x, :y
     end
   end
   
   it "should generate an update statement" do
     o = @c.new(:id => 1)
-    o.set(:x => 1)
+    o.update_values(:x => 1)
     MODEL_DB.sqls.first.should == "UPDATE items SET x = 1 WHERE (id = 1)"
   end
   
   it "should update attribute values" do
     o = @c.new(:id => 1)
     o.x.should be_nil
-    o.set(:x => 1)
+    o.update_values(:x => 1)
     o.x.should == 1
   end
   
   it "should support string keys" do
     o = @c.new(:id => 1)
     o.x.should be_nil
-    o.set('x' => 1)
+    o.update_values('x' => 1)
     o.x.should == 1
     MODEL_DB.sqls.first.should == "UPDATE items SET x = 1 WHERE (id = 1)"
   end
+end
+
+describe "Model#set_values" do
+  before(:each) do
+    MODEL_DB.reset
+
+    @c = Class.new(Sequel::Model(:items)) do
+      columns :id, :x, :y
+    end
+  end
   
-  it "should be aliased by #update" do
+  it "should not touch the database" do
     o = @c.new(:id => 1)
-    o.update(:x => 1)
-    MODEL_DB.sqls.first.should == "UPDATE items SET x = 1 WHERE (id = 1)"
+    o.set_values(:x => 1)
+    MODEL_DB.sqls.should == []
+  end
+  
+  it "should update attribute values" do
+    o = @c.new(:id => 1)
+    o.x.should be_nil
+    o.set_values(:x => 1)
+    o.x.should == 1
+  end
+  
+  it "should support string keys" do
+    o = @c.new(:id => 1)
+    o.x.should be_nil
+    o.set_values('x' => 1)
+    o.x.should == 1
   end
 end
 
-
 describe "Model#new?" do
   
   before(:each) do
@@ -170,6 +186,7 @@ describe "Model#new?" do
     n.should_not be_new
   end
   
+  ### DEPRECATED
   it "should alias new_record? to new?" do
     n = @c.new(:x => 1)
     n.should respond_to(:new_record?)
@@ -217,7 +234,7 @@ end
 
 describe Sequel::Model, "with this" do
 
-  before { @example = Class.new Sequel::Model(:examples) }
+  before { @example = Class.new Sequel::Model(:examples); @example.columns :id, :a, :x, :y }
 
   it "should return a dataset identifying the record" do
     instance = @example.new :id => 3
@@ -250,6 +267,7 @@ end
 describe "Model#pk" do
   before(:each) do
     @m = Class.new(Sequel::Model)
+    @m.columns :id, :x, :y
   end
   
   it "should be default return the value of the :id column" do
@@ -283,6 +301,7 @@ end
 describe "Model#pk_hash" do
   before(:each) do
     @m = Class.new(Sequel::Model)
+    @m.columns :id, :x, :y
   end
   
   it "should be default return the value of the :id column" do
@@ -313,14 +332,59 @@ describe "Model#pk_hash" do
   end
 end
 
+describe Sequel::Model, "set_with_params" do
+
+  before(:each) do
+    MODEL_DB.reset
+    
+    @c = Class.new(Sequel::Model(:items)) do
+      columns :x, :y, :id
+    end
+    @c.instance_variable_set(:@columns, true)
+    @o1 = @c.new
+    @o2 = @c.load(:id => 5)
+  end
+  
+  it "should filter the given params using the model columns" do
+    @o1.set_with_params(:x => 1, :z => 2)
+    @o1.values.should == {:x => 1}
+    MODEL_DB.sqls.should == []
+
+    @o2.set_with_params(:y => 1, :abc => 2)
+    @o2.values.should == {:y => 1, :id=> 5}
+    MODEL_DB.sqls.should == []
+  end
+  
+  it "should work with both strings and symbols" do
+    @o1.set_with_params('x'=> 1, 'z'=> 2)
+    @o1.values.should == {:x => 1}
+    MODEL_DB.sqls.should == []
+
+    @o2.set_with_params('y'=> 1, 'abc'=> 2)
+    @o2.values.should == {:y => 1, :id=> 5}
+    MODEL_DB.sqls.should == []
+  end
+  
+  it "should support virtual attributes" do
+    @c.class_def(:blah=) {|v| self.x = v}
+    @o1.set_with_params(:blah => 333)
+    @o1.values.should == {:x => 333}
+    MODEL_DB.sqls.should == []
+    @o1.set_with_params('blah'=> 334)
+    @o1.values.should == {:x => 334}
+    MODEL_DB.sqls.should == []
+  end
+end
+
 describe Sequel::Model, "update_with_params" do
 
   before(:each) do
     MODEL_DB.reset
     
     @c = Class.new(Sequel::Model(:items)) do
-      def self.columns; [:x, :y]; end
+      columns :x, :y, :id
     end
+    @c.instance_variable_set(:@columns, true)
     @o1 = @c.new
     @o2 = @c.load(:id => 5)
   end
@@ -334,7 +398,8 @@ describe Sequel::Model, "update_with_params" do
     MODEL_DB.sqls.first.should == "UPDATE items SET y = 1 WHERE (id = 5)"
   end
   
-  it "should be aliased by create_with" do
+  ### DEPRECATE
+  it "should be aliased by update_with" do
     @o1.update_with(:x => 1, :z => 2)
     MODEL_DB.sqls.first.should == "INSERT INTO items (x) VALUES (1)"
 
@@ -345,19 +410,21 @@ describe Sequel::Model, "update_with_params" do
   
   it "should support virtual attributes" do
     @c.class_def(:blah=) {|v| self.x = v}
-    @o1.update_with(:blah => 333)
+    @o1.update_with_params(:blah => 333)
     MODEL_DB.sqls.first.should == "INSERT INTO items (x) VALUES (333)"
   end
 end
 
+### DEPRECATE
 describe Sequel::Model, "create_with_params" do
 
   before(:each) do
     MODEL_DB.reset
     
     @c = Class.new(Sequel::Model(:items)) do
-      def self.columns; [:x, :y]; end
+      columns :x, :y
     end
+    @c.instance_variable_set(:@columns, true)
   end
   
   it "should filter the given params using the model columns" do
@@ -390,12 +457,19 @@ describe Sequel::Model, "#destroy" do
   before(:each) do
     MODEL_DB.reset
     @model = Class.new(Sequel::Model(:items))
+    @model.columns :id
     @model.dataset.meta_def(:delete) {MODEL_DB.execute delete_sql}
     
     @instance = @model.new(:id => 1234)
     #@model.stub!(:delete).and_return(:true)
   end
 
+  it "should return self" do
+    @model.db.should_receive(:transaction)
+    @model.after_destroy{3}
+    @instance.destroy.should == @instance
+  end
+
   it "should run within a transaction" do
     @model.db.should_receive(:transaction)
     @instance.destroy
@@ -434,6 +508,7 @@ end
 describe Sequel::Model, "#each" do
   setup do
     @model = Class.new(Sequel::Model(:items))
+    @model.columns :a, :b, :id
     @m = @model.new(:a => 1, :b => 2, :id => 4444)
   end
   
@@ -447,6 +522,7 @@ end
 describe Sequel::Model, "#keys" do
   setup do
     @model = Class.new(Sequel::Model(:items))
+    @model.columns :a, :b, :id
     @m = @model.new(:a => 1, :b => 2, :id => 4444)
   end
   
@@ -459,32 +535,100 @@ describe Sequel::Model, "#keys" do
   end
 end
 
-describe Sequel::Model, "#===" do
+describe Sequel::Model, "#==" do
   specify "should compare instances by values" do
-    a = Sequel::Model.new(:id => 1, :x => 3)
-    b = Sequel::Model.new(:id => 1, :x => 4)
-    c = Sequel::Model.new(:id => 1, :x => 3)
+    z = Class.new(Sequel::Model)
+    z.columns :id, :x
+    a = z.new(:id => 1, :x => 3)
+    b = z.new(:id => 1, :x => 4)
+    c = z.new(:id => 1, :x => 3)
     
     a.should_not == b
     a.should == c
     b.should_not == c
   end
+
+  specify "should be aliased to #eql?" do
+    z = Class.new(Sequel::Model)
+    z.columns :id, :x
+    a = z.new(:id => 1, :x => 3)
+    b = z.new(:id => 1, :x => 4)
+    c = z.new(:id => 1, :x => 3)
+    
+    a.eql?(b).should == false
+    a.eql?(c).should == true
+    b.eql?(c).should == false
+  end
 end
 
 describe Sequel::Model, "#===" do
-  specify "should compare instances by pk only" do
-    a = Sequel::Model.new(:id => 1, :x => 3)
-    b = Sequel::Model.new(:id => 1, :x => 4)
-    c = Sequel::Model.new(:id => 2, :x => 3)
+  specify "should compare instances by class and pk if pk is not nil" do
+    z = Class.new(Sequel::Model)
+    z.columns :id, :x
+    y = Class.new(Sequel::Model)
+    y.columns :id, :x
+    a = z.new(:id => 1, :x => 3)
+    b = z.new(:id => 1, :x => 4)
+    c = z.new(:id => 2, :x => 3)
+    d = y.new(:id => 1, :x => 3)
     
     a.should === b
     a.should_not === c
+    a.should_not === d
+  end
+
+  specify "should always be false if the primary key is nil" do
+    z = Class.new(Sequel::Model)
+    z.columns :id, :x
+    y = Class.new(Sequel::Model)
+    y.columns :id, :x
+    a = z.new(:x => 3)
+    b = z.new(:x => 4)
+    c = z.new(:x => 3)
+    d = y.new(:x => 3)
+    
+    a.should_not === b
+    a.should_not === c
+    a.should_not === d
+  end
+end
+
+describe Sequel::Model, "#hash" do
+  specify "should be the same only for objects with the same class and pk if the pk is not nil" do
+    z = Class.new(Sequel::Model)
+    z.columns :id, :x
+    y = Class.new(Sequel::Model)
+    y.columns :id, :x
+    a = z.new(:id => 1, :x => 3)
+    b = z.new(:id => 1, :x => 4)
+    c = z.new(:id => 2, :x => 3)
+    d = y.new(:id => 1, :x => 3)
+    
+    a.hash.should == b.hash
+    a.hash.should_not == c.hash
+    a.hash.should_not == d.hash
+  end
+
+  specify "should be the same only for objects with the same class and values if the pk is nil" do
+    z = Class.new(Sequel::Model)
+    z.columns :id, :x
+    y = Class.new(Sequel::Model)
+    y.columns :id, :x
+    a = z.new(:x => 3)
+    b = z.new(:x => 4)
+    c = z.new(:x => 3)
+    d = y.new(:x => 3)
+    
+    a.hash.should_not == b.hash
+    a.hash.should == c.hash
+    a.hash.should_not == d.hash
   end
 end
 
 describe Sequel::Model, "#initialize" do
   setup do
     @c = Class.new(Sequel::Model) do
+      columns :id, :x
     end
   end
   
@@ -528,7 +672,7 @@ describe Sequel::Model, ".create" do
   before(:each) do
     MODEL_DB.reset
     @c = Class.new(Sequel::Model(:items)) do
-      def columns; [:x]; end
+      columns :x
     end
   end
 
@@ -566,7 +710,7 @@ describe Sequel::Model, "#refresh" do
   setup do
     MODEL_DB.reset
     @c = Class.new(Sequel::Model(:items)) do
-      def columns; [:x]; end
+      columns :x
     end
   end
 
@@ -590,4 +734,18 @@ describe Sequel::Model, "#refresh" do
     @m.reload
     @m[:x].should == 'kaboom'
   end
+
+  specify "should remove cached associations" do
+    @c.many_to_one :node, :class=>@c
+    @c.one_to_many :attributes, :class=>@c
+    @c.many_to_many :tags, :class=>@c
+    @m = @c.new(:id => 555)
+    @m.instance_variable_set(:@node, 15)
+    @m.instance_variable_set(:@attributes, [15])
+    @m.instance_variable_set(:@tags, [15])
+    @m.reload
+    @m.instance_variable_get(:@node).should == nil
+    @m.instance_variable_get(:@attributes).should == nil
+    @m.instance_variable_get(:@tags).should == nil
+  end
 end

data/spec/spec_helper.rb

@@ -1,8 +1,12 @@
 require 'rubygems'
 unless Object.const_defined?('Sequel')
+  $:.unshift(File.join(File.dirname(__FILE__), "../../sequel_core/lib/"))
   require 'sequel_core'
 end
-require File.join(File.dirname(__FILE__), "../lib/sequel_model")
+unless Sequel.const_defined?('Model')
+  $:.unshift(File.join(File.dirname(__FILE__), "../lib/"))
+  require 'sequel_model'
+end
 
 class MockDataset < Sequel::Dataset
   def insert(*args)
@@ -40,4 +44,15 @@ class MockDatabase < Sequel::Database
   def dataset; MockDataset.new(self); end
 end
 
-Sequel::Model.db = MODEL_DB = MockDatabase.new
+class << Sequel::Model
+  alias orig_columns columns
+  def columns(*cols)
+    return if cols.empty?
+    define_method(:columns){cols}
+    @dataset.instance_variable_set(:@columns, cols) if @dataset
+    define_method(:str_columns){cols.map{|x|x.to_s.freeze}}
+    def_column_accessor(*cols)
+  end
+end
+
+Sequel::Model.db = MODEL_DB = MockDatabase.new

data/spec/validations_spec.rb

@@ -1,33 +1,386 @@
 require File.join(File.dirname(__FILE__), "spec_helper")
 
+describe "Validation::Errors" do
+  setup do
+    @errors = Validation::Errors.new
+    class Validation::Errors
+      attr_accessor :errors
+    end
+  end
+  
+  specify "should be clearable using #clear" do
+    @errors.errors = {1 => 2, 3 => 4}
+    @errors.clear
+    @errors.errors.should == {}
+  end
+  
+  specify "should be empty if no errors are added" do
+    @errors.should be_empty
+    @errors[:blah] << "blah"
+    @errors.should_not be_empty
+  end
+  
+  specify "should return errors for a specific attribute using #on or #[]" do
+    @errors[:blah].should == []
+    @errors.on(:blah).should == []
+
+    @errors[:blah] << 'blah'
+    @errors[:blah].should == ['blah']
+    @errors.on(:blah).should == ['blah']
+
+    @errors[:bleu].should == []
+    @errors.on(:bleu).should == []
+  end
+  
+  specify "should accept errors using #[] << or #add" do
+    @errors[:blah] << 'blah'
+    @errors[:blah].should == ['blah']
+    
+    @errors.add :blah, 'zzzz'
+    @errors[:blah].should == ['blah', 'zzzz']
+  end
+  
+  specify "should return full messages using #full_messages" do
+    @errors.full_messages.should == []
+    
+    @errors[:blow] << 'blieuh'
+    @errors[:blow] << 'blich'
+    @errors[:blay] << 'bliu'
+    msgs = @errors.full_messages
+    msgs.size.should == 3
+    msgs.should include('blow blieuh', 'blow blich', 'blay bliu')
+  end
+end
+
+describe Validation do
+  setup do
+    @c = Class.new do
+      include Validation
+      
+      def self.validates_coolness_of(attr)
+        validates_each(attr) {|o, a, v| o.errors[a] << 'is not cool' if v != :cool}
+      end
+    end
+    
+    @d = Class.new do
+      attr_accessor :errors
+      def initialize; @errors = Validation::Errors.new; end
+    end
+  end
+  
+  specify "should respond to validates, validations, has_validations?" do
+    @c.should respond_to(:validations)
+    @c.should respond_to(:has_validations?)
+  end
+  
+  specify "should acccept validation definitions using validates_each" do
+    @c.validates_each(:xx, :yy) {|o, a, v| o.errors[a] << 'too low' if v < 50}
+    
+    @c.validations[:xx].size.should == 1
+    @c.validations[:yy].size.should == 1
+    
+    o = @d.new
+    @c.validations[:xx].first.call(o, :aa, 40)
+    @c.validations[:yy].first.call(o, :bb, 60)
+    
+    o.errors.full_messages.should == ['aa too low']
+  end
+
+  specify "should return true/false for has_validations?" do
+    @c.has_validations?.should == false
+    @c.validates_each(:xx) {1}
+    @c.has_validations?.should == true
+  end
+  
+  specify "should provide a validates method that takes block with validation definitions" do
+    @c.validates do
+      coolness_of :blah
+    end
+    @c.validations[:blah].should_not be_empty
+
+    o = @d.new
+    @c.validations[:blah].first.call(o, :ttt, 40)
+    o.errors.full_messages.should == ['ttt is not cool']
+    o.errors.clear
+    @c.validations[:blah].first.call(o, :ttt, :cool)
+    o.errors.should be_empty
+  end
+end
+
+describe "A Validation instance" do
+  setup do
+    @c = Class.new do
+      attr_accessor :score
+      
+      include Validation
+      
+      validates_each :score do |o, a, v|
+        o.errors[a] << 'too low' if v < 87
+      end
+    end
+    
+    @o = @c.new
+  end
+  
+  specify "should supply a #valid? method that returns true if validations pass" do
+    @o.score = 50
+    @o.should_not be_valid
+    @o.score = 100
+    @o.should be_valid
+  end
+  
+  specify "should provide an errors object" do
+    @o.score = 100
+    @o.should be_valid
+    @o.errors.should be_empty
+    
+    @o.score = 86
+    @o.should_not be_valid
+    @o.errors[:score].should == ['too low']
+    @o.errors[:blah].should be_empty
+  end
+end
+
+describe Validation::Generator do
+  setup do
+    $testit = nil
+    
+    @c = Class.new do
+      include Validation
+      
+      def self.validates_blah
+        $testit = 1324
+      end
+    end
+  end
+  
+  specify "should instance_eval the block, sending everything to its receiver" do
+    Validation::Generator.new(@c) do
+      blah
+    end
+    $testit.should == 1324
+  end
+end
+
+describe "Validations" do
+  setup do
+    @c = Class.new do
+      attr_accessor :value
+      include Validation
+    end
+    @m = @c.new
+  end
+
+  specify "should validate acceptance_of" do
+    @c.validates_acceptance_of :value
+    @m.should be_valid
+    @m.value = '1'
+    @m.should be_valid
+  end
+  
+  specify "should validate acceptance_of with accept" do
+    @c.validates_acceptance_of :value, :accept => 'true'
+    @m.value = '1'
+    @m.should_not be_valid
+    @m.value = 'true'
+    @m.should be_valid
+  end
+  
+  specify "should validate acceptance_of with allow_nil => false" do
+    @c.validates_acceptance_of :value, :allow_nil => false
+    @m.should_not be_valid
+  end
+
+  specify "should validate confirmation_of" do
+    @c.send(:attr_accessor, :value_confirmation)
+    @c.validates_confirmation_of :value
+    
+    @m.value = 'blah'
+    @m.should_not be_valid
+    
+    @m.value_confirmation = 'blah'
+    @m.should be_valid
+  end
+
+  specify "should validate format_of" do
+    @c.validates_format_of :value, :with => /.+_.+/
+    @m.value = 'abc_'
+    @m.should_not be_valid
+    @m.value = 'abc_def'
+    @m.should be_valid
+  end
+  
+  specify "should raise for validate_format_of without regexp" do
+    proc {@c.validates_format_of :value}.should raise_error(ArgumentError)
+    proc {@c.validates_format_of :value, :with => :blah}.should raise_error(ArgumentError)
+  end
+  
+  specify "should validate length_of with maximum" do
+    @c.validates_length_of :value, :maximum => 5
+    @m.should_not be_valid
+    @m.value = '12345'
+    @m.should be_valid
+    @m.value = '123456'
+    @m.should_not be_valid
+  end
+
+  specify "should validate length_of with minimum" do
+    @c.validates_length_of :value, :minimum => 5
+    @m.should_not be_valid
+    @m.value = '12345'
+    @m.should be_valid
+    @m.value = '1234'
+    @m.should_not be_valid
+  end
+
+  specify "should validate length_of with within" do
+    @c.validates_length_of :value, :within => 2..5
+    @m.should_not be_valid
+    @m.value = '12345'
+    @m.should be_valid
+    @m.value = '1'
+    @m.should_not be_valid
+    @m.value = '123456'
+    @m.should_not be_valid
+  end
+
+  specify "should validate length_of with is" do
+    @c.validates_length_of :value, :is => 3
+    @m.should_not be_valid
+    @m.value = '123'
+    @m.should be_valid
+    @m.value = '12'
+    @m.should_not be_valid
+    @m.value = '1234'
+    @m.should_not be_valid
+  end
+  
+  specify "should validate length_of with allow_nil" do
+    @c.validates_length_of :value, :is => 3, :allow_nil => true
+    @m.should be_valid
+  end
+
+  specify "should validate numericality_of" do
+    @c.validates_numericality_of :value
+    @m.value = 'blah'
+    @m.should_not be_valid
+    @m.value = '123'
+    @m.should be_valid
+    @m.value = '123.1231'
+    @m.should be_valid
+  end
+
+  specify "should validate numericality_of with only_integer" do
+    @c.validates_numericality_of :value, :only_integer => true
+    @m.value = 'blah'
+    @m.should_not be_valid
+    @m.value = '123'
+    @m.should be_valid
+    @m.value = '123.1231'
+    @m.should_not be_valid
+  end
+  
+  specify "should validate presence_of" do
+    @c.validates_presence_of :value
+    @m.should_not be_valid
+    @m.value = ''
+    @m.should_not be_valid
+    @m.value = 1234
+    @m.should be_valid
+  end
+end
+
+context "Superclass validations" do
+  setup do
+    @c1 = Class.new do
+      include Validation
+      attr_accessor :value
+      validates_length_of :value, :minimum => 5
+    end
+    
+    @c2 = Class.new(@c1) do
+      validates_format_of :value, :with => /^[a-z]+$/
+    end
+  end
+  
+  specify "should be checked when validating" do
+    o = @c2.new
+    o.value = 'ab'
+    o.valid?.should == false
+    o.errors.full_messages.should == [
+      'value is too short'
+    ]
+
+    o.value = '12'
+    o.valid?.should == false
+    o.errors.full_messages.should == [
+      'value is too short',
+      'value is invalid'
+    ]
+
+    o.value = 'abcde'
+    o.valid?.should be_true
+  end
+  
+  specify "should be skipped if skip_superclass_validations is called" do
+    @c2.skip_superclass_validations
+
+    o = @c2.new
+    o.value = 'ab'
+    o.valid?.should be_true
+
+    o.value = '12'
+    o.valid?.should == false
+    o.errors.full_messages.should == [
+      'value is invalid'
+    ]
+
+    o.value = 'abcde'
+    o.valid?.should be_true
+  end
+end
+
+context ".validates with block" do
+  specify "should support calling .each" do
+    @c = Class.new do
+      attr_accessor :vvv
+      
+      include Validation
+      validates do
+        each :vvv do |o, a, v|
+          o.errors[a] << "is less than zero" if v.to_i < 0
+        end
+      end
+    end
+    
+    o = @c.new
+    o.vvv = 1
+    o.should be_valid
+    o.vvv = -1
+    o.should_not be_valid
+  end
+end
+
 describe Sequel::Model, "Validations" do
 
   before(:all) do
     class Person < Sequel::Model
-      def columns
-        [:id,:name,:first_name,:last_name,:middle_name,:initials,:age, :terms]
-      end
+      columns :id,:name,:first_name,:last_name,:middle_name,:initials,:age, :terms
     end
 
     class Smurf < Person
     end
     
     class Cow < Sequel::Model
-      def columns
-        [:id, :name, :got_milk]
-      end
+      columns :id, :name, :got_milk
     end
 
     class User < Sequel::Model
-      def columns
-        [:id, :username, :password]
-      end
+      columns :id, :username, :password
     end
     
     class Address < Sequel::Model
-      def columns
-        [:id, :zip_code]
-      end
+      columns :id, :zip_code
     end
   end
   
@@ -137,6 +490,52 @@ describe Sequel::Model, "Validations" do
     @cow.name = "Betsy"
     @cow.should be_valid
   end
+ 
+  it "should validate the uniqueness of a column" do
+    class User < Sequel::Model
+      validations.clear
+      validates do
+        uniqueness_of :username
+      end
+    end
+    User.dataset.extend(Module.new {
+      def fetch_rows(sql)
+        @db << sql
+        
+        case sql
+        when /COUNT.*username = '0records'/
+        when /COUNT.*username = '2records'/
+          yield({:v => 2})
+        when /COUNT.*username = '1record'/
+          yield({:v => 1})
+        when /username = '1record'/
+          yield({:id => 3, :username => "1record", :password => "test"})
+        end
+      end
+    })
+    
+    @user = User.new(:username => "2records", :password => "anothertest")
+    @user.should_not be_valid
+    @user.errors.full_messages.should == ['username is already taken']
+
+    @user = User.new(:username => "1record", :password => "anothertest")
+    @user.should_not be_valid
+    @user.errors.full_messages.should == ['username is already taken']
+
+    @user = User.new(:id=>4, :username => "1record", :password => "anothertest")
+    @user.instance_variable_set(:@new, false)
+    @user.should_not be_valid
+    @user.errors.full_messages.should == ['username is already taken']
+
+    @user = User.new(:id=>3, :username => "1record", :password => "anothertest")
+    @user.instance_variable_set(:@new, false)
+    @user.should be_valid
+    @user.errors.full_messages.should == []
+
+    @user = User.new(:username => "0records", :password => "anothertest")
+    @user.should be_valid
+    @user.errors.full_messages.should == []
+  end
   
   it "should have a validates block that contains multiple validations" do
     class Person < Sequel::Model
@@ -185,7 +584,7 @@ describe Sequel::Model, "Validations" do
 
   it "should validate correctly instances initialized with string keys" do
     class Can < Sequel::Model
-      def columns; [:id, :name]; end
+      columns :id, :name
       
       validates_length_of :name, :minimum => 4
     end
@@ -219,7 +618,7 @@ end
 describe "Model#save" do
   setup do
     @c = Class.new(Sequel::Model(:people)) do
-      def columns; [:id]; end
+      columns :id
 
       validates_each :id do |o, a, v|
         o.errors[a] << 'blah' unless v == 5
@@ -243,4 +642,4 @@ describe "Model#save" do
   specify "should return false if validations fail" do
     @m.save.should == false
   end
-end
+end