sequel 4.26.0 → 5.37.0

data/spec/extensions/typecast_on_load_spec.rb

@@ -1,80 +0,0 @@
-require File.join(File.dirname(File.expand_path(__FILE__)), "spec_helper")
-
-describe Sequel::Model, "TypecastOnLoad plugin" do
-  before do
-    @db = Sequel.mock(:fetch=>{:id=>1, :b=>"1", :y=>"0"}, :columns=>[:id, :b, :y], :numrows=>1)
-    def @db.supports_schema_parsing?() true end
-    def @db.schema(*args)
-      [[:id, {}], [:y, {:type=>:boolean, :db_type=>'tinyint(1)'}], [:b, {:type=>:integer, :db_type=>'integer'}]]
-    end
-    @c = Class.new(Sequel::Model(@db[:items])) do
-      attr_accessor :bset
-      def b=(x)
-        self.bset = true
-        super
-      end
-    end
-  end 
-
-  it "should call setter method with value when loading the object, for all given columns" do
-    @c.plugin :typecast_on_load, :b
-    o = @c.load(:id=>1, :b=>"1", :y=>"0")
-    o.values.must_equal(:id=>1, :b=>1, :y=>"0")
-    o.bset.must_equal true
-  end
-
-  it "should call setter method with value when reloading the object, for all given columns" do
-    @c.plugin :typecast_on_load, :b
-    o = @c.load(:id=>1, :b=>"1", :y=>"0")
-    o.refresh
-    o.values.must_equal(:id=>1, :b=>1, :y=>"0")
-    o.bset.must_equal true
-  end
-
-  it "should call setter method with value when automatically reloading the object on creation" do
-    @c.plugin :typecast_on_load, :b
-    o = @c.new(:b=>"1", :y=>"0")
-    o.save.values.must_equal(:id=>1, :b=>1, :y=>"0")
-    o.bset.must_equal true
-  end
-
-  it "should call setter method with value when automatically reloading the object on creation via insert_select" do
-    @c.plugin :typecast_on_load, :b
-    @c.dataset.meta_def(:insert_select){|h| insert(h); first}
-    o = @c.new(:b=>"1", :y=>"0")
-    o.save.values.must_equal(:id=>1, :b=>1, :y=>"0")
-    o.bset.must_equal true
-  end
-
-  it "should allowing setting columns separately via add_typecast_on_load_columns" do
-    @c.plugin :typecast_on_load
-    @c.load(:id=>1, :b=>"1", :y=>"0").values.must_equal(:id=>1, :b=>"1", :y=>"0")
-    @c.add_typecast_on_load_columns :b
-    @c.load(:id=>1, :b=>"1", :y=>"0").values.must_equal(:id=>1, :b=>1, :y=>"0")
-    @c.add_typecast_on_load_columns :y
-    @c.load(:id=>1, :b=>"1", :y=>"0").values.must_equal(:id=>1, :b=>1, :y=>false)
-  end
-
-  it "should work with subclasses" do
-    @c.plugin :typecast_on_load
-    @c.load(:id=>1, :b=>"1", :y=>"0").values.must_equal(:id=>1, :b=>"1", :y=>"0")
-
-    c1 = Class.new(@c)
-    @c.add_typecast_on_load_columns :b
-    @c.load(:id=>1, :b=>"1", :y=>"0").values.must_equal(:id=>1, :b=>1, :y=>"0")
-    c1.load(:id=>1, :b=>"1", :y=>"0").values.must_equal(:id=>1, :b=>"1", :y=>"0")
-
-    c2 = Class.new(@c)
-    @c.add_typecast_on_load_columns :y
-    @c.load(:id=>1, :b=>"1", :y=>"0").values.must_equal(:id=>1, :b=>1, :y=>false)
-    c2.load(:id=>1, :b=>"1", :y=>"0").values.must_equal(:id=>1, :b=>1, :y=>"0")
-    
-    c1.add_typecast_on_load_columns :y
-    c1.load(:id=>1, :b=>"1", :y=>"0").values.must_equal(:id=>1, :b=>"1", :y=>false)
-  end
-
-  it "should not mark the object as modified" do
-    @c.plugin :typecast_on_load, :b
-    @c.load(:id=>1, :b=>"1", :y=>"0").modified?.must_equal false
-  end
-end

data/spec/extensions/unlimited_update_spec.rb

@@ -1,20 +0,0 @@
-require File.join(File.dirname(File.expand_path(__FILE__)), "spec_helper")
-
-describe "Sequel::Plugins::UnlimitedUpdate" do
-  before do
-    @db = Sequel.mock(:host=>'mysql', :numrows=>1)
-    @c = Class.new(Sequel::Model(@db[:test]))
-    @c.columns :id, :name
-    @o = @c.load(:id=>1, :name=>'a')
-    @db.sqls
-  end
-
-  it "should remove limit from update dataset" do
-    @o.save
-    @db.sqls.must_equal ["UPDATE test SET name = 'a' WHERE (id = 1) LIMIT 1"]
-
-    @c.plugin :unlimited_update
-    @o.save
-    @db.sqls.must_equal ["UPDATE test SET name = 'a' WHERE (id = 1)"]
-  end
-end

data/spec/extensions/update_or_create_spec.rb

@@ -1,87 +0,0 @@
-require File.join(File.dirname(File.expand_path(__FILE__)), "spec_helper")
-
-describe "Sequel::Plugins::UpdateOrCreate" do
-  before do
-    @db = Sequel.mock(:autoid=>proc{1}, :numrows=>1)
-    @c = Class.new(Sequel::Model(@db[:test]))
-    @c.plugin :update_or_create
-    @c.columns :id, :a, :b 
-    @db.sqls
-  end
-
-  it ".update_or_create should update an existing record if one exists" do
-    @db.fetch = [[{:id=>1, :a=>2, :b=>3}]]
-    @c.update_or_create(:a=>2){|t| t.b = 4}.must_equal @c.load(:id=>1, :a=>2, :b=>4)
-    @db.sqls.must_equal ["SELECT * FROM test WHERE (a = 2) LIMIT 1", "UPDATE test SET b = 4 WHERE (id = 1)"]
-
-    @db.fetch = [[{:id=>1, :a=>2, :b=>3}]]
-    @c.update_or_create({:a=>2}, :b=>4).must_equal @c.load(:id=>1, :a=>2, :b=>4)
-    @db.sqls.must_equal ["SELECT * FROM test WHERE (a = 2) LIMIT 1", "UPDATE test SET b = 4 WHERE (id = 1)"]
-
-    @db.fetch = [[{:id=>1, :a=>2, :b=>3}]]
-    @c.update_or_create({:a=>2}, :a=>3){|t| t.b = 4}.must_equal @c.load(:id=>1, :a=>3, :b=>4)
-    sqls = @db.sqls
-    sqls.shift.must_equal "SELECT * FROM test WHERE (a = 2) LIMIT 1"
-    sqls.shift.must_match(/UPDATE test SET [ab] = [34], [ab] = [34] WHERE \(id = 1\)/)
-  end
-
-  it ".update_or_create should create a record if an existing record does not exist" do
-    @db.fetch = [[], [{:id=>1, :a=>1, :b=>4}]]
-    @c.update_or_create(:a=>1){|t| t.b = 4}.must_equal @c.load(:id=>1, :a=>1, :b=>4)
-    sqls = @db.sqls
-    sqls.shift.must_equal "SELECT * FROM test WHERE (a = 1) LIMIT 1"
-    sqls.shift.must_match(/INSERT INTO test \([ab], [ab]\) VALUES \([14], [14]\)/)
-    sqls.shift.must_equal "SELECT * FROM test WHERE (id = 1) LIMIT 1"
-
-    @db.fetch = [[], [{:id=>1, :a=>1, :b=>4}]]
-    @c.update_or_create({:a=>1}, :b=>4).must_equal @c.load(:id=>1, :a=>1, :b=>4)
-    sqls = @db.sqls
-    sqls.shift.must_equal "SELECT * FROM test WHERE (a = 1) LIMIT 1"
-    sqls.shift.must_match(/INSERT INTO test \([ab], [ab]\) VALUES \([14], [14]\)/)
-    sqls.shift.must_equal "SELECT * FROM test WHERE (id = 1) LIMIT 1"
-
-    @db.fetch = [[], [{:id=>1, :a=>3, :b=>4}]]
-    @c.update_or_create({:a=>1}, :a=>3){|t| t.b = 4}.must_equal @c.load(:id=>1, :a=>3, :b=>4)
-    sqls = @db.sqls
-    sqls.shift.must_equal "SELECT * FROM test WHERE (a = 1) LIMIT 1"
-    sqls.shift.must_match(/INSERT INTO test \([ab], [ab]\) VALUES \([34], [34]\)/)
-    sqls.shift.must_equal "SELECT * FROM test WHERE (id = 1) LIMIT 1"
-  end
-
-  it ".update_or_create should return an existing record even if no changes necessary" do
-    @db.fetch = [[{:id=>1, :a=>2, :b=>3}]]
-    @c.update_or_create(:a=>2){|t| t.b = 3}.must_equal @c.load(:id=>1, :a=>2, :b=>3)
-    @db.sqls.must_equal ["SELECT * FROM test WHERE (a = 2) LIMIT 1"]
-  end
-
-  it ".find_or_new should return an existing record" do
-    @db.fetch = [[{:id=>1, :a=>2, :b=>3}]]
-    @c.find_or_new(:a=>2){|t| t.b = 4}.must_equal @c.load(:id=>1, :a=>2, :b=>4)
-    @db.sqls.must_equal ["SELECT * FROM test WHERE (a = 2) LIMIT 1"]
-
-    @db.fetch = [[{:id=>1, :a=>2, :b=>3}]]
-    @c.find_or_new({:a=>2}, :b=>4).must_equal @c.load(:id=>1, :a=>2, :b=>4)
-    @db.sqls.must_equal ["SELECT * FROM test WHERE (a = 2) LIMIT 1"]
-
-    @db.fetch = [[{:id=>1, :a=>2, :b=>3}]]
-    @c.find_or_new({:a=>2}, :a=>3){|t| t.b = 4}.must_equal @c.load(:id=>1, :a=>3, :b=>4)
-    @db.sqls.must_equal ["SELECT * FROM test WHERE (a = 2) LIMIT 1"]
-  end
-
-  it ".find_or_new should return a new record if no record exists" do
-    o = @c.find_or_new(:a=>1){|t| t.b = 4}
-    o.must_equal @c.load(:a=>1, :b=>4)
-    o.new?.must_equal true
-    @db.sqls.must_equal ["SELECT * FROM test WHERE (a = 1) LIMIT 1"]
-
-    o = @c.find_or_new({:a=>1}, :b=>4)
-    o.must_equal @c.load(:a=>1, :b=>4)
-    o.new?.must_equal true
-    @db.sqls.must_equal ["SELECT * FROM test WHERE (a = 1) LIMIT 1"]
-
-    o = @c.find_or_new({:a=>1}, :a=>3){|t| t.b = 4}
-    o.must_equal @c.load(:a=>3, :b=>4)
-    o.new?.must_equal true
-    @db.sqls.must_equal ["SELECT * FROM test WHERE (a = 1) LIMIT 1"]
-  end
-end

data/spec/extensions/update_primary_key_spec.rb

@@ -1,100 +0,0 @@
-require File.join(File.dirname(File.expand_path(__FILE__)), "spec_helper")
-
-describe "Sequel::Plugins::UpdatePrimaryKey" do
-  before do
-    @c = Class.new(Sequel::Model(:a))
-    @c.plugin :update_primary_key
-    @c.columns :a, :b
-    @c.set_primary_key :a
-    @c.unrestrict_primary_key
-    @ds = @c.dataset
-    DB.reset
-  end
-
-  it "should handle regular updates" do
-    @ds._fetch = [[{:a=>1, :b=>3}], [{:a=>1, :b=>4}], [{:a=>1, :b=>4}], [{:a=>1, :b=>5}], [{:a=>1, :b=>5}], [{:a=>1, :b=>6}], [{:a=>1, :b=>6}]]
-    @c.first.update(:b=>4)
-    @c.all.must_equal [@c.load(:a=>1, :b=>4)]
-    DB.sqls.must_equal ["SELECT * FROM a LIMIT 1", "UPDATE a SET b = 4 WHERE (a = 1)", "SELECT * FROM a"]
-    @c.first.set(:b=>5).save
-    @c.all.must_equal [@c.load(:a=>1, :b=>5)]
-    DB.sqls.must_equal ["SELECT * FROM a LIMIT 1", "UPDATE a SET b = 5 WHERE (a = 1)", "SELECT * FROM a"]
-    @c.first.set(:b=>6).save(:columns=>:b)
-    @c.all.must_equal [@c.load(:a=>1, :b=>6)]
-    DB.sqls.must_equal ["SELECT * FROM a LIMIT 1", "UPDATE a SET b = 6 WHERE (a = 1)", "SELECT * FROM a"]
-  end
-
-  it "should handle updating the primary key field with another field" do
-    @ds._fetch = [[{:a=>1, :b=>3}], [{:a=>2, :b=>4}]]
-    @c.first.update(:a=>2, :b=>4)
-    @c.all.must_equal [@c.load(:a=>2, :b=>4)]
-    sqls = DB.sqls
-    ["UPDATE a SET a = 2, b = 4 WHERE (a = 1)", "UPDATE a SET b = 4, a = 2 WHERE (a = 1)"].must_include(sqls.slice!(1))
-    sqls.must_equal ["SELECT * FROM a LIMIT 1", "SELECT * FROM a"]
-  end
-
-  it "should handle updating just the primary key field when saving changes" do
-    @ds._fetch = [[{:a=>1, :b=>3}], [{:a=>2, :b=>3}], [{:a=>2, :b=>3}], [{:a=>3, :b=>3}]]
-    @c.first.update(:a=>2)
-    @c.all.must_equal [@c.load(:a=>2, :b=>3)]
-    DB.sqls.must_equal ["SELECT * FROM a LIMIT 1", "UPDATE a SET a = 2 WHERE (a = 1)", "SELECT * FROM a"]
-    @c.first.set(:a=>3).save(:columns=>:a)
-    @c.all.must_equal [@c.load(:a=>3, :b=>3)]
-    DB.sqls.must_equal ["SELECT * FROM a LIMIT 1", "UPDATE a SET a = 3 WHERE (a = 2)", "SELECT * FROM a"]
-  end
-
-  it "should handle saving after modifying the primary key field with another field" do
-    @ds._fetch = [[{:a=>1, :b=>3}], [{:a=>2, :b=>4}]]
-    @c.first.set(:a=>2, :b=>4).save
-    @c.all.must_equal [@c.load(:a=>2, :b=>4)]
-    sqls = DB.sqls
-    ["UPDATE a SET a = 2, b = 4 WHERE (a = 1)", "UPDATE a SET b = 4, a = 2 WHERE (a = 1)"].must_include(sqls.slice!(1))
-    sqls.must_equal ["SELECT * FROM a LIMIT 1", "SELECT * FROM a"]
-  end
-
-  it "should handle saving after modifying just the primary key field" do
-    @ds._fetch = [[{:a=>1, :b=>3}], [{:a=>2, :b=>3}]]
-    @c.first.set(:a=>2).save
-    @c.all.must_equal [@c.load(:a=>2, :b=>3)]
-    sqls = DB.sqls
-    ["UPDATE a SET a = 2, b = 3 WHERE (a = 1)", "UPDATE a SET b = 3, a = 2 WHERE (a = 1)"].must_include(sqls.slice!(1))
-    sqls.must_equal ["SELECT * FROM a LIMIT 1", "SELECT * FROM a"]
-  end
-
-  it "should handle saving after updating the primary key" do
-    @ds._fetch = [[{:a=>1, :b=>3}], [{:a=>2, :b=>5}]]
-    @c.first.update(:a=>2).update(:b=>4).set(:b=>5).save
-    @c.all.must_equal [@c.load(:a=>2, :b=>5)]
-    DB.sqls.must_equal ["SELECT * FROM a LIMIT 1", "UPDATE a SET a = 2 WHERE (a = 1)", "UPDATE a SET b = 4 WHERE (a = 2)", "UPDATE a SET b = 5 WHERE (a = 2)", "SELECT * FROM a"]
-  end
-
-  it "should work correctly when using the prepared_statements plugin" do
-    @c.plugin :prepared_statements
-    @ds._fetch = [[{:a=>1, :b=>3}], [{:a=>2, :b=>4}]]
-    o = @c.first
-    o.update(:a=>2, :b=>4)
-    @c.all.must_equal [@c.load(:a=>2, :b=>4)]
-    sqls = DB.sqls
-    ["UPDATE a SET a = 2, b = 4 WHERE (a = 1)", "UPDATE a SET b = 4, a = 2 WHERE (a = 1)"].must_include(sqls.slice!(1))
-    sqls.must_equal ["SELECT * FROM a LIMIT 1", "SELECT * FROM a"]
-
-    o.delete
-  end
-
-  it "should clear the associations cache of non-many_to_one associations when changing the primary key" do
-    @c.one_to_many :cs, :class=>@c
-    @c.many_to_one :c, :class=>@c
-    o = @c.new(:a=>1)
-    o.associations[:cs] = @c.new
-    o.associations[:c] = o2 = @c.new
-    o.a = 2
-    o.associations.must_equal(:c=>o2)
-  end
-
-  it "should handle frozen instances" do
-    o = @c.new
-    o.a = 1
-    o.freeze
-    o.pk_hash.must_equal(:a=>1)
-  end
-end

data/spec/extensions/update_refresh_spec.rb

@@ -1,53 +0,0 @@
-require File.join(File.dirname(File.expand_path(__FILE__)), "spec_helper")
-
-describe "Sequel::Plugins::UpdateRefresh" do
-  before do
-    @db = Sequel.mock(:numrows=>1, :fetch=>{:id=>1, :name=>'b'})
-    @c = Class.new(Sequel::Model(@db[:test]))
-    @ds = @c.dataset
-    @c.columns :id, :name
-    @c.plugin :update_refresh
-    @db.sqls
-  end
-
-  it "should refresh the instance after updating" do
-    o = @c.load(:id=>1, :name=>'a')
-    o.save
-    @db.sqls.must_equal ["UPDATE test SET name = 'a' WHERE (id = 1)", "SELECT * FROM test WHERE (id = 1) LIMIT 1"]
-    o.name.must_equal 'b'
-  end
-
-  it "should refresh the instance after updating" do
-    @db.extend_datasets{def supports_returning?(x) true end; def update_sql(*); sql = super; update_returning_sql(sql); sql end}
-    @c.dataset = @db[:test]
-    @db.sqls
-    o = @c.load(:id=>1, :name=>'a')
-    o.save
-    @db.sqls.must_equal ["UPDATE test SET name = 'a' WHERE (id = 1) RETURNING *"]
-    o.name.must_equal 'b'
-  end
-
-  it "should support specifying columns to return" do
-    @db.extend_datasets{def supports_returning?(x) true end; def update_sql(*); sql = super; update_returning_sql(sql); sql end}
-    @c.plugin :update_refresh, :columns => [ :a ]
-    @c.dataset = @db[:test]
-    @db.sqls
-    o = @c.load(:id=>1, :name=>'a')
-    o.save
-    @db.sqls.must_equal ["UPDATE test SET name = 'a' WHERE (id = 1) RETURNING a"]
-    o.name.must_equal 'b'
-  end
-
-
-  it "should refresh the instance after updating when returning specific columns" do
-    @db.extend_datasets{def supports_returning?(x) true end; def update_sql(*); sql = super; update_returning_sql(sql); sql end}
-    @c.plugin :insert_returning_select
-    @c.dataset = @db[:test].select(:id, :name)
-    @db.sqls
-    o = @c.load(:id=>1, :name=>'a')
-    o.this.opts[:returning] = [:id, :name]
-    o.save
-    @db.sqls.must_equal ["UPDATE test SET name = 'a' WHERE (id = 1) RETURNING id, name"]
-    o.name.must_equal 'b'
-  end
-end

data/spec/extensions/validate_associated_spec.rb

@@ -1,52 +0,0 @@
-require File.join(File.dirname(File.expand_path(__FILE__)), "spec_helper")
-
-describe "ValidatesAssociated plugin" do
-  before do
-    @db = Sequel.mock(:autoid=>1, :numrows=>1, :fetch=>{:id=>1, :name=>'a', :c_id=>nil})
-    @c = Class.new(Sequel::Model(@db[:cs]))
-    @c.plugin :validate_associated
-    @c.columns :id, :name, :c_id
-    @c.one_to_many :cs, :class=>@c, :key=>:c_id
-    @o = @c.load(:id=>1, :name=>'a')
-    @db.sqls
-  end
-  
-  it "should return nil when saving if the associated object is invalid when raise_on_save_failure is false" do
-    @c.raise_on_save_failure = false
-    @c.send(:define_method, :validate){|*| errors.add(:name, 'is b') if name == 'b'}
-    o = @c.load(:id=>2, :name=>'b')
-    @o.send(:delay_validate_associated_object, @c.association_reflection(:cs), o)
-    @o.save.must_equal nil
-    @o.errors[:cs].must_equal ["name is b"]
-    o.errors[:name].must_equal ['is b']
-  end
-
-  it "should support creating new one_to_many and one_to_one objects with presence validations on the foreign key" do
-    @c.class_eval do
-      plugin :validation_helpers
-      def validate
-        validates_integer :c_id
-        super
-      end
-    end
-    @o.c_id = 5
-    @o.send(:delay_validate_associated_object, @c.association_reflection(:cs), @c.load(:id=>2, :name=>'b', :c_id=>2))
-    @o.valid?.must_equal true
-  end
-
-  it "should should not remove existing values from object when validating" do
-    o = @c.load(:id=>2, :name=>'b', :c_id=>3)
-    @o.send(:delay_validate_associated_object, @c.association_reflection(:cs), o)
-    @o.valid?.must_equal true
-    o.c_id.must_equal 3
-  end
-  
-  it "should not attempt to validate associated_object if the :validate=>false option is passed to save" do
-    @c.one_to_many :cs, :class=>@c, :key=>:c_id
-    @c.send(:define_method, :validate){|*| errors.add(:name, 'is b') if name == 'b'}
-    o = @c.load(:id=>2, :name=>'b', :c_id=>3)
-    @o.send(:delay_validate_associated_object, @c.association_reflection(:cs), o)
-    @o.save(:validate=>false).must_equal @o
-    @db.sqls.must_equal ["UPDATE cs SET name = 'a' WHERE (id = 1)"]
-  end
-end

data/spec/extensions/validation_class_methods_spec.rb

@@ -1,1027 +0,0 @@
-require File.join(File.dirname(File.expand_path(__FILE__)), "spec_helper")
-
-model_class = proc do |klass, &block|
-  c = Class.new(klass)
-  c.plugin :validation_class_methods
-  c.class_eval(&block) if block
-  c
-end
-
-describe Sequel::Model do
-  before do
-    @c = model_class.call Sequel::Model do
-      def self.validates_coolness_of(attr)
-        validates_each(attr) {|o, a, v| o.errors.add(a, 'is not cool') if v != :cool}
-      end
-    end
-  end
-  
-  it "should respond to validations, has_validations?, and validation_reflections" do
-    @c.must_respond_to(:validations)
-    @c.must_respond_to(:has_validations?)
-    @c.must_respond_to(:validation_reflections)
-  end
-  
-  it "should be able to reflect on validations" do
-    @c.validation_reflections.must_equal({})
-    @c.validates_acceptance_of(:a)
-    @c.validation_reflections.must_equal(:a=>[[:acceptance, {:tag=>:acceptance, :message=>"is not accepted", :allow_nil=>true, :accept=>"1"}]])
-    @c.validates_presence_of(:a)
-    @c.validation_reflections[:a].length.must_equal 2
-    @c.validation_reflections[:a].last.must_equal [:presence, {:tag=>:presence, :message=>"is not present"}]
-  end
-
-  it "should handle validation reflections correctly when subclassing" do
-    @c.validates_acceptance_of(:a)
-    c = Class.new(@c)
-    c.validation_reflections.map{|k,v| k}.must_equal [:a]
-    c.validates_presence_of(:a)
-    @c.validation_reflections.must_equal(:a=>[[:acceptance, {:tag=>:acceptance, :message=>"is not accepted", :allow_nil=>true, :accept=>"1"}]])
-    c.validation_reflections[:a].last.must_equal [:presence, {:tag=>:presence, :message=>"is not present"}]
-  end
-
-  it "should acccept validation definitions using validates_each" do
-    @c.validates_each(:xx, :yy) {|o, a, v| o.errors.add(a, 'too low') if v < 50}
-    o = @c.new
-    def o.xx; 40; end
-    def o.yy; 60; end
-    o.valid?.must_equal false
-    o.errors.full_messages.must_equal ['xx too low']
-  end
-
-  it "should return true/false for has_validations?" do
-    @c.has_validations?.must_equal false
-    @c.validates_each(:xx) {1}
-    @c.has_validations?.must_equal true
-  end
-  
-  it "should validate multiple attributes at once" do
-    o = @c.new
-    def o.xx
-      1
-    end
-    def o.yy
-      2
-    end
-    vals = nil
-    atts = nil
-    @c.validates_each([:xx, :yy]){|obj,a,v| atts=a; vals=v}
-    o.valid?
-    vals.must_equal [1,2]
-    atts.must_equal [:xx, :yy]
-  end
-  
-  it "should respect allow_missing option when using multiple attributes" do
-    o = @c.new
-    def o.xx
-      self[:xx]
-    end
-    def o.yy
-      self[:yy]
-    end
-    vals = nil
-    atts = nil
-    @c.validates_each([:xx, :yy], :allow_missing=>true){|obj,a,v| atts=a; vals=v}
-
-    o.values[:xx] = 1
-    o.valid?
-    vals.must_equal [1,nil]
-    atts.must_equal [:xx, :yy]
-
-    vals = nil
-    atts = nil
-    o.values.clear
-    o.values[:yy] = 2
-    o.valid?
-    vals.must_equal [nil, 2]
-    atts.must_equal [:xx, :yy]
-
-    vals = nil
-    atts = nil
-    o.values.clear
-    o.valid?.must_equal true
-    vals.must_equal nil
-    atts.must_equal nil
-  end
-  
-  it "should overwrite existing validation with the same tag and attribute" do
-    @c.validates_each(:xx, :xx, :tag=>:low) {|o, a, v| o.xxx; o.errors.add(a, 'too low') if v < 50}
-    @c.validates_each(:yy, :yy) {|o, a, v| o.yyy; o.errors.add(a, 'too low') if v < 50}
-    @c.validates_presence_of(:zz, :zz)
-    @c.validates_length_of(:aa, :aa, :tag=>:blah)
-    o = @c.new
-    def o.zz
-      @a ||= 0
-      @a += 1
-    end
-    def o.aa
-      @b ||= 0
-      @b += 1
-    end
-    def o.xx; 40; end
-    def o.yy; 60; end
-    def o.xxx; end
-    def o.yyy; end
-    o.valid?.must_equal false
-    o.zz.must_equal 2
-    o.aa.must_equal 2
-    o.errors.full_messages.must_equal ['xx too low']
-  end
-
-  it "should provide a validates method that takes block with validation definitions" do
-    @c.validates do
-      coolness_of :blah
-    end
-    @c.validations[:blah].wont_be :empty?
-    o = @c.new
-    def o.blah; end
-    o.valid?.must_equal false
-    o.errors.full_messages.must_equal ['blah is not cool']
-  end
-
-  it "should have the validates block have appropriate respond_to?" do
-    c = nil
-    @c.validates{c = respond_to?(:foo)}
-    c.must_equal false
-    @c.validates{c = respond_to?(:length_of)}
-    c.must_equal true
-  end if RUBY_VERSION >= '1.9'
-end
-
-describe Sequel::Model do
-  before do
-    @c = model_class.call Sequel::Model do
-      columns :score
-      validates_each :score do |o, a, v|
-        o.errors.add(a, 'too low') if v < 87
-      end
-    end
-    
-    @o = @c.new
-  end
-  
-  it "should supply a #valid? method that returns true if validations pass" do
-    @o.score = 50
-    @o.wont_be :valid?
-    @o.score = 100
-    @o.must_be :valid?
-  end
-  
-  it "should provide an errors object" do
-    @o.score = 100
-    @o.must_be :valid?
-    @o.errors.must_be :empty?
-    
-    @o.score = 86
-    @o.wont_be :valid?
-    @o.errors[:score].must_equal ['too low']
-    @o.errors.on(:blah).must_equal nil
-  end
-end
-
-describe "Sequel::Plugins::ValidationClassMethods::ClassMethods::Generator" do
-  before do
-    @testit = testit = []
-    
-    @c = model_class.call Sequel::Model do
-      (class << self; self end).send(:define_method, :validates_blah) do
-        testit << 1324
-      end
-    end
-  end
-  
-  it "should instance_eval the block, sending everything to its receiver" do
-    @c.validates do
-      blah
-    end
-    @testit.must_equal [1324]
-  end
-end
-
-describe Sequel::Model do
-  before do
-    @c = model_class.call Sequel::Model do
-      columns :value
-      
-      def self.filter(*args)
-        o = Object.new
-        def o.count; 2; end
-        o
-      end
-
-      def skip; false; end
-      def dont_skip; true; end
-    end
-    @m = @c.new
-  end
-
-  it "should validate acceptance_of" do
-    @c.validates_acceptance_of :value
-    @m.must_be :valid?
-    @m.value = '1'
-    @m.must_be :valid?
-  end
-  
-  it "should validate acceptance_of with accept" do
-    @c.validates_acceptance_of :value, :accept => 'true'
-    @m.value = '1'
-    @m.wont_be :valid?
-    @m.value = 'true'
-    @m.must_be :valid?
-  end
-  
-  it "should validate acceptance_of with allow_nil => false" do
-    @c.validates_acceptance_of :value, :allow_nil => false
-    @m.wont_be :valid?
-  end
-
-  it "should validate acceptance_of with allow_missing => true" do
-    @c.validates_acceptance_of :value, :allow_missing => true
-    @m.must_be :valid?
-  end
-
-  it "should validate acceptance_of with allow_missing => true and allow_nil => false" do
-    @c.validates_acceptance_of :value, :allow_missing => true, :allow_nil => false
-    @m.must_be :valid?
-    @m.value = nil
-    @m.wont_be :valid?
-  end
-
-  it "should validate acceptance_of with if => true" do
-    @c.validates_acceptance_of :value, :if => :dont_skip
-    @m.value = '0'
-    @m.wont_be :valid?
-  end
-
-  it "should validate acceptance_of with if => false" do
-    @c.validates_acceptance_of :value, :if => :skip
-    @m.value = '0'
-    @m.must_be :valid?
-  end
-
-  it "should validate acceptance_of with if proc that evaluates to true" do
-    @c.validates_acceptance_of :value, :if => proc{true}
-    @m.value = '0'
-    @m.wont_be :valid?
-  end
-
-  it "should validate acceptance_of with if proc that evaluates to false" do
-    @c.validates_acceptance_of :value, :if => proc{false}
-    @m.value = '0'
-    @m.must_be :valid?
-  end
-
-  it "should raise an error if :if option is not a Symbol, Proc, or nil" do
-    @c.validates_acceptance_of :value, :if => 1
-    @m.value = '0'
-    proc{@m.valid?}.must_raise(Sequel::Error)
-  end
-
-  it "should validate confirmation_of" do
-    @c.send(:attr_accessor, :value_confirmation)
-    @c.validates_confirmation_of :value
-    
-    @m.value = 'blah'
-    @m.wont_be :valid?
-    
-    @m.value_confirmation = 'blah'
-    @m.must_be :valid?
-  end
-  
-  it "should validate confirmation_of with if => true" do
-    @c.send(:attr_accessor, :value_confirmation)
-    @c.validates_confirmation_of :value, :if => :dont_skip
-
-    @m.value = 'blah'
-    @m.wont_be :valid?
-  end
-
-  it "should validate confirmation_of with if => false" do
-    @c.send(:attr_accessor, :value_confirmation)
-    @c.validates_confirmation_of :value, :if => :skip
-
-    @m.value = 'blah'
-    @m.must_be :valid?
-  end
-
-  it "should validate confirmation_of with allow_missing => true" do
-    @c.send(:attr_accessor, :value_confirmation)
-    @c.validates_acceptance_of :value, :allow_missing => true
-    @m.must_be :valid?
-    @m.value_confirmation = 'blah'
-    @m.must_be :valid?
-    @m.value = nil
-    @m.wont_be :valid?
-  end
-
-  it "should validate format_of" do
-    @c.validates_format_of :value, :with => /.+_.+/
-    @m.value = 'abc_'
-    @m.wont_be :valid?
-    @m.value = 'abc_def'
-    @m.must_be :valid?
-  end
-  
-  it "should raise for validate_format_of without regexp" do
-    proc {@c.validates_format_of :value}.must_raise(ArgumentError)
-    proc {@c.validates_format_of :value, :with => :blah}.must_raise(ArgumentError)
-  end
-  
-  it "should validate format_of with if => true" do
-    @c.validates_format_of :value, :with => /_/, :if => :dont_skip
-
-    @m.value = 'a'
-    @m.wont_be :valid?
-  end
-
-  it "should validate format_of with if => false" do
-    @c.validates_format_of :value, :with => /_/, :if => :skip
-
-    @m.value = 'a'
-    @m.must_be :valid?
-  end
-  
-  it "should validate format_of with allow_missing => true" do
-    @c.validates_format_of :value, :allow_missing => true, :with=>/./
-    @m.must_be :valid?
-    @m.value = nil
-    @m.wont_be :valid?
-  end
-
-  it "should validate length_of with maximum" do
-    @c.validates_length_of :value, :maximum => 5
-    @m.wont_be :valid?
-    @m.value = '12345'
-    @m.must_be :valid?
-    @m.value = '123456'
-    @m.wont_be :valid?
-    @m.errors[:value].must_equal ['is too long']
-    @m.value = nil
-    @m.wont_be :valid?
-    @m.errors[:value].must_equal ['is not present']
-  end
-
-  it "should validate length_of with maximum using customized error messages" do
-    @c.validates_length_of :value, :maximum => 5, :too_long=>'tl', :nil_message=>'np'
-    @m.value = '123456'
-    @m.wont_be :valid?
-    @m.errors[:value].must_equal ['tl']
-    @m.value = nil
-    @m.wont_be :valid?
-    @m.errors[:value].must_equal ['np']
-  end
-
-  it "should validate length_of with minimum" do
-    @c.validates_length_of :value, :minimum => 5
-    @m.wont_be :valid?
-    @m.value = '12345'
-    @m.must_be :valid?
-    @m.value = '1234'
-    @m.wont_be :valid?
-  end
-
-  it "should validate length_of with within" do
-    @c.validates_length_of :value, :within => 2..5
-    @m.wont_be :valid?
-    @m.value = '12345'
-    @m.must_be :valid?
-    @m.value = '1'
-    @m.wont_be :valid?
-    @m.value = '123456'
-    @m.wont_be :valid?
-  end
-
-  it "should validate length_of with is" do
-    @c.validates_length_of :value, :is => 3
-    @m.wont_be :valid?
-    @m.value = '123'
-    @m.must_be :valid?
-    @m.value = '12'
-    @m.wont_be :valid?
-    @m.value = '1234'
-    @m.wont_be :valid?
-  end
-  
-  it "should validate length_of with allow_nil" do
-    @c.validates_length_of :value, :is => 3, :allow_nil => true
-    @m.must_be :valid?
-  end
-
-  it "should validate length_of with if => true" do
-    @c.validates_length_of :value, :is => 3, :if => :dont_skip
-
-    @m.value = 'a'
-    @m.wont_be :valid?
-  end
-
-  it "should validate length_of with if => false" do
-    @c.validates_length_of :value, :is => 3, :if => :skip
-
-    @m.value = 'a'
-    @m.must_be :valid?
-  end
-
-  it "should validate length_of with allow_missing => true" do
-    @c.validates_length_of :value, :allow_missing => true, :minimum => 5
-    @m.must_be :valid?
-    @m.value = nil
-    @m.wont_be :valid?
-  end
-
-  it "should allow multiple calls to validates_length_of with different options without overwriting" do
-    @c.validates_length_of :value, :maximum => 5
-    @c.validates_length_of :value, :minimum => 5
-    @m.wont_be :valid?
-    @m.value = '12345'
-    @m.must_be :valid?
-    @m.value = '123456'
-    @m.wont_be :valid?
-    @m.value = '12345'
-    @m.must_be :valid?
-    @m.value = '1234'
-    @m.wont_be :valid?
-  end
-
-  it "should validate numericality_of" do
-    @c.validates_numericality_of :value
-    @m.value = 'blah'
-    @m.wont_be :valid?
-    @m.value = '123'
-    @m.must_be :valid?
-    @m.value = '123.1231'
-    @m.must_be :valid?
-    @m.value = '+1'
-    @m.must_be :valid?
-    @m.value = '-1'
-    @m.must_be :valid?
-    @m.value = '+1.123'
-    @m.must_be :valid?
-    @m.value = '-0.123'
-    @m.must_be :valid?
-    @m.value = '-0.123E10'
-    @m.must_be :valid?
-    @m.value = '32.123e10'
-    @m.must_be :valid?
-    @m.value = '+32.123E10'
-    @m.must_be :valid?
-    @m.must_be :valid?
-    @m.value = '.0123'
-  end
-
-  it "should validate numericality_of with only_integer" do
-    @c.validates_numericality_of :value, :only_integer => true
-    @m.value = 'blah'
-    @m.wont_be :valid?
-    @m.value = '123'
-    @m.must_be :valid?
-    @m.value = '123.1231'
-    @m.wont_be :valid?
-  end
-  
-  it "should validate numericality_of with if => true" do
-    @c.validates_numericality_of :value, :if => :dont_skip
-
-    @m.value = 'a'
-    @m.wont_be :valid?
-  end
-
-  it "should validate numericality_of with if => false" do
-    @c.validates_numericality_of :value, :if => :skip
-
-    @m.value = 'a'
-    @m.must_be :valid?
-  end
-
-  it "should validate numericality_of with allow_missing => true" do
-    @c.validates_numericality_of :value, :allow_missing => true
-    @m.must_be :valid?
-    @m.value = nil
-    @m.wont_be :valid?
-  end
-
-  it "should validate presence_of" do
-    @c.validates_presence_of :value
-    @m.wont_be :valid?
-    @m.value = ''
-    @m.wont_be :valid?
-    @m.value = 1234
-    @m.must_be :valid?
-    @m.value = nil
-    @m.wont_be :valid?
-    @m.value = true
-    @m.must_be :valid?
-    @m.value = false
-    @m.must_be :valid?
-  end
-  
-  it "should validate inclusion_of with an array" do
-    @c.validates_inclusion_of :value, :in => [1,2]
-    @m.wont_be :valid?
-    @m.value = 1
-    @m.must_be :valid?
-    @m.value = 1.5
-    @m.wont_be :valid?
-    @m.value = 2
-    @m.must_be :valid?    
-    @m.value = 3
-    @m.wont_be :valid? 
-  end
-  
-  it "should validate inclusion_of with a range" do
-    @c.validates_inclusion_of :value, :in => 1..4
-    @m.wont_be :valid?
-    @m.value = 1
-    @m.must_be :valid?
-    @m.value = 1.5
-    @m.must_be :valid?
-    @m.value = 0
-    @m.wont_be :valid?
-    @m.value = 5
-    @m.wont_be :valid?    
-  end
-  
-  it "should raise an error if inclusion_of doesn't receive a valid :in option" do
-    lambda{@c.validates_inclusion_of :value}.must_raise(ArgumentError)
-    lambda{@c.validates_inclusion_of :value, :in => 1}.must_raise(ArgumentError)
-  end
-  
-  it "should raise an error if inclusion_of handles :allow_nil too" do
-    @c.validates_inclusion_of :value, :in => 1..4, :allow_nil => true
-    @m.value = nil
-    @m.must_be :valid?
-    @m.value = 0
-    @m.wont_be :valid?
-  end
-
-  it "should validate presence_of with if => true" do
-    @c.validates_presence_of :value, :if => :dont_skip
-    @m.wont_be :valid?
-  end
-
-  it "should validate presence_of with if => false" do
-    @c.validates_presence_of :value, :if => :skip
-    @m.must_be :valid?
-  end
-
-  it "should validate presence_of with allow_missing => true" do
-    @c.validates_presence_of :value, :allow_missing => true
-    @m.must_be :valid?
-    @m.value = nil
-    @m.wont_be :valid?
-  end
-
-  it "should validate uniqueness_of with if => true" do
-    @c.validates_uniqueness_of :value, :if => :dont_skip
-
-    @m.value = 'a'
-    @m.wont_be :valid?
-  end
-
-  it "should validate uniqueness_of with if => false" do
-    @c.validates_uniqueness_of :value, :if => :skip
-    @m.value = 'a'
-    @m.must_be :valid?
-  end
-  
-  it "should validate uniqueness_of with allow_missing => true" do
-    @c.validates_uniqueness_of :value, :allow_missing => true
-    @m.must_be :valid?
-    @m.value = 1
-    @m.wont_be :valid?
-  end
-end
-
-describe "Superclass validations" do
-  before do
-    @c1 = model_class.call Sequel::Model do
-      columns :value
-      validates_length_of :value, :minimum => 5
-    end
-    
-    @c2 = Class.new(@c1)
-    @c2.class_eval do
-      columns :value
-      validates_format_of :value, :with => /^[a-z]+$/
-    end
-  end
-  
-  it "should be checked when validating" do
-    o = @c2.new
-    o.value = 'ab'
-    o.valid?.must_equal false
-    o.errors.full_messages.must_equal ['value is too short']
-
-    o.value = '12'
-    o.valid?.must_equal false
-    o.errors.full_messages.must_equal ['value is too short', 'value is invalid']
-
-    o.value = 'abcde'
-    o.valid?.must_equal true
-  end
-  
-  it "should have skip_superclass_validations? return whether superclass validations were skipped" do
-    @c2.skip_superclass_validations?.must_equal nil
-    @c2.skip_superclass_validations
-    @c2.skip_superclass_validations?.must_equal true
-  end
-
-  it "should be skipped if skip_superclass_validations is called" do
-    @c2.skip_superclass_validations
-
-    o = @c2.new
-    o.value = 'ab'
-    o.valid?.must_equal true
-
-    o.value = '12'
-    o.valid?.must_equal false
-    o.errors.full_messages.must_equal ['value is invalid']
-
-    o.value = 'abcde'
-    o.valid?.must_equal true
-  end
-end
-
-describe ".validates with block" do
-  it "should support calling .each" do
-    @c = model_class.call Sequel::Model do
-      columns :vvv
-      validates do
-        each :vvv do |o, a, v|
-          o.errors.add(a, "is less than zero") if v.to_i < 0
-        end
-      end
-    end
-    
-    o = @c.new
-    o.vvv = 1
-    o.must_be :valid?
-    o.vvv = -1
-    o.wont_be :valid?
-  end
-end
-
-describe Sequel::Model, "Validations" do
-  before do
-    class ::Person < Sequel::Model
-      plugin :validation_class_methods
-      columns :id,:name,:first_name,:last_name,:middle_name,:initials,:age, :terms
-    end
-
-    class ::Smurf < Person
-    end
-
-    class ::Can < Sequel::Model
-      plugin :validation_class_methods
-      columns :id, :name
-    end
-    
-    class ::Cow < Sequel::Model
-      plugin :validation_class_methods
-      columns :id, :name, :got_milk
-    end
-
-    class ::User < Sequel::Model
-      plugin :validation_class_methods
-      columns :id, :username, :password
-    end
-    
-    class ::Address < Sequel::Model
-      plugin :validation_class_methods
-      columns :id, :zip_code
-    end
-  end
-  after do
-    [:Person, :Smurf, :Cow, :User, :Address].each{|c| Object.send(:remove_const, c)}
-  end
-  
-  it "should validate the acceptance of a column" do
-    class ::Cow < Sequel::Model
-      validations.clear
-      validates_acceptance_of :got_milk, :accept => 'blah', :allow_nil => false
-    end
-    
-    @cow = Cow.new
-    @cow.wont_be :valid?
-    @cow.errors.full_messages.must_equal ["got_milk is not accepted"]
-    
-    @cow.got_milk = "blah"
-    @cow.must_be :valid?
-  end
-  
-  it "should validate the confirmation of a column" do
-    class ::User < Sequel::Model
-      def password_confirmation
-        "test"
-      end
-      
-      validations.clear
-      validates_confirmation_of :password
-    end
-    
-    @user = User.new
-    @user.wont_be :valid?
-    @user.errors.full_messages.must_equal ["password is not confirmed"]
-    
-    @user.password = "test"
-    @user.must_be :valid?
-  end
-  
-  it "should validate format of column" do
-    class ::Person < Sequel::Model
-      validates_format_of :first_name, :with => /^[a-zA-Z]+$/
-    end
-
-    @person = Person.new :first_name => "Lancelot99"
-    @person.valid?.must_equal false
-    @person = Person.new :first_name => "Anita"
-    @person.valid?.must_equal true
-  end
-  
-  it "should validate length of column" do
-    class ::Person < Sequel::Model
-      validations.clear
-      validates_length_of :first_name, :maximum => 30
-      validates_length_of :last_name, :minimum => 30
-      validates_length_of :middle_name, :within => 1..5
-      validates_length_of :initials, :is => 2
-    end
-    
-    @person = Person.new(
-      :first_name => "Anamethatiswaytofreakinglongandwayoverthirtycharacters",
-      :last_name => "Alastnameunderthirtychars",
-      :initials => "LGC",
-      :middle_name => "danger"
-    )
-    
-    @person.wont_be :valid?
-    @person.errors.full_messages.size.must_equal 4
-    @person.errors.full_messages.sort.must_equal [
-      'first_name is too long',
-      'initials is the wrong length',
-      'last_name is too short',
-      'middle_name is the wrong length'
-    ]
-    
-    @person.first_name  = "Lancelot"
-    @person.last_name   = "1234567890123456789012345678901"
-    @person.initials    = "LC"
-    @person.middle_name = "Will"
-    @person.must_be :valid?
-  end
-  
-  it "should validate that a column has the correct type for the schema column" do
-    p = model_class.call Sequel::Model do
-      columns :age, :d
-      self.raise_on_typecast_failure = false
-      validates_schema_type :age
-      validates_schema_type :d, :message=>'is a bad choice'
-      @db_schema = {:age=>{:type=>:integer}, :d=>{:type=>:date}}
-    end
-    
-    @person = p.new
-    @person.must_be :valid?
-
-    @person.age = 'a'
-    @person.wont_be :valid?
-    @person.errors.full_messages.must_equal ['age is not a valid integer']
-    @person.age = 1
-    @person.must_be :valid?
-
-    @person.d = 'a'
-    @person.wont_be :valid?
-    @person.errors.full_messages.must_equal ['d is a bad choice']
-    @person.d = Date.today
-    @person.must_be :valid?
-  end
-
-  it "should validate numericality of column" do
-    class ::Person < Sequel::Model
-      validations.clear
-      validates_numericality_of :age
-    end
-    
-    @person = Person.new :age => "Twenty"
-    @person.wont_be :valid?
-    @person.errors.full_messages.must_equal ['age is not a number']
-    
-    @person.age = 20
-    @person.must_be :valid?
-  end
-  
-  it "should validate the presence of a column" do
-    class ::Cow < Sequel::Model
-      validations.clear
-      validates_presence_of :name
-    end
-    
-    @cow = Cow.new
-    @cow.wont_be :valid?
-    @cow.errors.full_messages.must_equal ['name is not present']
-    
-    @cow.name = "Betsy"
-    @cow.must_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._fetch = proc do |sql|
-      case sql
-      when /count.*username = '0records'/
-        {:v => 0}
-      when /count.*username = '2records'/
-        {:v => 2}
-      when /count.*username = '1record'/
-        {:v => 1}
-      when /username = '1record'/
-        {:id => 3, :username => "1record", :password => "test"}
-      end
-    end
-    
-    @user = User.new(:username => "2records", :password => "anothertest")
-    @user.wont_be :valid?
-    @user.errors.full_messages.must_equal ['username is already taken']
-
-    @user = User.new(:username => "1record", :password => "anothertest")
-    @user.wont_be :valid?
-    @user.errors.full_messages.must_equal ['username is already taken']
-
-    @user = User.load(:id=>4, :username => "1record", :password => "anothertest")
-    @user.wont_be :valid?
-    @user.errors.full_messages.must_equal ['username is already taken']
-
-    @user = User.load(:id=>3, :username => "1record", :password => "anothertest")
-    @user.must_be :valid?
-    @user.errors.full_messages.must_equal []
-
-    @user = User.new(:username => "0records", :password => "anothertest")
-    @user.must_be :valid?
-    @user.errors.full_messages.must_equal []
-
-    User.db.sqls
-    @user = User.new(:password => "anothertest")
-    @user.must_be :valid?
-    @user.errors.full_messages.must_equal []
-    User.db.sqls.must_equal []
-  end
-  
-  it "should validate the uniqueness of multiple columns" do
-    class ::User < Sequel::Model
-      validations.clear
-      validates do
-        uniqueness_of [:username, :password]
-      end
-    end
-    User.dataset._fetch = proc do |sql|
-      case sql
-      when /count.*username = '0records'/
-        {:v => 0}
-      when /count.*username = '2records'/
-        {:v => 2}
-      when /count.*username = '1record'/
-        {:v => 1}
-      when /username = '1record'/
-        if sql =~ /password = 'anothertest'/
-          {:id => 3, :username => "1record", :password => "anothertest"}
-        else
-          {:id => 4, :username => "1record", :password => "test"}
-        end
-      end
-    end
-    
-    @user = User.new(:username => "2records", :password => "anothertest")
-    @user.wont_be :valid?
-    @user.errors.full_messages.must_equal ['username and password is already taken']
-
-    @user = User.new(:username => "1record", :password => "anothertest")
-    @user.wont_be :valid?
-    @user.errors.full_messages.must_equal ['username and password is already taken']
-
-    @user = User.load(:id=>4, :username => "1record", :password => "anothertest")
-    @user.wont_be :valid?
-    @user.errors.full_messages.must_equal ['username and password is already taken']
-
-    @user = User.load(:id=>3, :username => "1record", :password => "test")
-    @user.wont_be :valid?
-    @user.errors.full_messages.must_equal ['username and password is already taken']
-
-    @user = User.load(:id=>3, :username => "1record", :password => "anothertest")
-    @user.must_be :valid?
-    @user.errors.full_messages.must_equal []
-
-    @user = User.new(:username => "0records", :password => "anothertest")
-    @user.must_be :valid?
-    @user.errors.full_messages.must_equal []
-
-    User.db.sqls
-    @user = User.new(:password => "anothertest")
-    @user.must_be :valid?
-    @user.errors.full_messages.must_equal []
-    @user = User.new(:username => "0records")
-    @user.must_be :valid?
-    @user.errors.full_messages.must_equal []
-    @user = User.new
-    @user.must_be :valid?
-    @user.errors.full_messages.must_equal []
-    User.db.sqls.must_equal []
-  end
-  
-  it "should have a validates block that contains multiple validations" do
-    class ::Person < Sequel::Model
-      validations.clear
-      validates do
-        format_of :first_name, :with => /^[a-zA-Z]+$/
-        length_of :first_name, :maximum => 30
-      end
-    end
-
-    Person.validations[:first_name].size.must_equal 2
-    
-    @person = Person.new :first_name => "Lancelot99"
-    @person.valid?.must_equal false
-    
-    @person2 = Person.new :first_name => "Wayne"
-    @person2.valid?.must_equal true
-  end
-
-  it "should allow 'longhand' validations direcly within the model." do
-    class ::Person < Sequel::Model
-      validations.clear
-      validates_length_of :first_name, :maximum => 30
-    end
-    Person.validations.length.must_equal(1)
-  end
-
-  it "should define a has_validations? method which returns true if the model has validations, false otherwise" do
-    class ::Person < Sequel::Model
-      validations.clear
-      validates do
-        format_of :first_name, :with => /\w+/
-        length_of :first_name, :maximum => 30
-      end
-    end
-
-    class ::Smurf < Person
-      validations.clear
-    end
-
-    Person.validations.wont_be :empty?
-    Smurf.validations.must_be :empty?
-  end
-
-  it "should validate correctly instances initialized with string keys" do
-    class ::Can < Sequel::Model
-      validates_length_of :name, :minimum => 4
-    end
-    
-    Can.new('name' => 'ab').wont_be :valid?
-    Can.new('name' => 'abcd').must_be :valid?
-  end
-  
-end
-
-describe "Model#save" do
-  before do
-    @c = model_class.call Sequel::Model(:people) do
-      columns :id, :x
-
-      validates_each :x do |o, a, v|
-        o.errors.add(a, 'blah') unless v == 7
-      end
-    end
-    @m = @c.load(:id => 4, :x=>6)
-    DB.reset
-  end
-
-  it "should save only if validations pass" do
-    @m.raise_on_save_failure = false
-    @m.wont_be :valid?
-    @m.save
-    DB.sqls.must_be :empty?
-    
-    @m.x = 7
-    @m.must_be :valid?
-    @m.save.wont_equal false
-    DB.sqls.must_equal ['UPDATE people SET x = 7 WHERE (id = 4)']
-  end
-  
-  it "should skip validations if the :validate=>false option is used" do
-    @m.raise_on_save_failure = false
-    @m.wont_be :valid?
-    @m.save(:validate=>false)
-    DB.sqls.must_equal ['UPDATE people SET x = 6 WHERE (id = 4)']
-  end
-    
-  it "should raise error if validations fail and raise_on_save_faiure is true" do
-    proc{@m.save}.must_raise(Sequel::ValidationFailed)
-  end
-  
-  it "should return nil if validations fail and raise_on_save_faiure is false" do
-    @m.raise_on_save_failure = false
-    @m.save.must_equal nil
-  end
-end