sequel 3.48.0 → 4.0.0

data/spec/extensions/touch_spec.rb

@@ -15,7 +15,7 @@ describe "Touch plugin" do
     @Album.many_to_one :artist, :class=>@Artist
 
     @a = @Artist.load(:id=>1)
-    MODEL_DB.reset
+    DB.reset
   end
 
   specify "should default to using Time.now when setting the column values for model instances" do
@@ -23,45 +23,45 @@ describe "Touch plugin" do
     c.plugin :touch
     c.columns :id, :updated_at
     c.load(:id=>1).touch
-    MODEL_DB.sqls.first.should =~ /UPDATE a SET updated_at = '[-0-9 :.]+' WHERE \(id = 1\)/
+    DB.sqls.first.should =~ /UPDATE a SET updated_at = '[-0-9 :.]+' WHERE \(id = 1\)/
   end
 
   specify "should allow #touch instance method for updating the updated_at column" do
     @Artist.plugin :touch
     @a.touch
-    MODEL_DB.sqls.should == ["UPDATE artists SET updated_at = CURRENT_TIMESTAMP WHERE (id = 1)"]
+    DB.sqls.should == ["UPDATE artists SET updated_at = CURRENT_TIMESTAMP WHERE (id = 1)"]
   end
 
   specify "should have #touch take an argument for the column to touch" do
     @Artist.plugin :touch
     @a.touch(:modified_on)
-    MODEL_DB.sqls.should == ["UPDATE artists SET modified_on = CURRENT_TIMESTAMP WHERE (id = 1)"]
+    DB.sqls.should == ["UPDATE artists SET modified_on = CURRENT_TIMESTAMP WHERE (id = 1)"]
   end
 
   specify "should be able to specify the default column to touch in the plugin call using the :column option" do
     @Artist.plugin :touch, :column=>:modified_on
     @a.touch
-    MODEL_DB.sqls.should == ["UPDATE artists SET modified_on = CURRENT_TIMESTAMP WHERE (id = 1)"]
+    DB.sqls.should == ["UPDATE artists SET modified_on = CURRENT_TIMESTAMP WHERE (id = 1)"]
   end
 
   specify "should be able to specify the default column to touch using the touch_column model accessor" do
     @Artist.plugin :touch
     @Artist.touch_column = :modified_on
     @a.touch
-    MODEL_DB.sqls.should == ["UPDATE artists SET modified_on = CURRENT_TIMESTAMP WHERE (id = 1)"]
+    DB.sqls.should == ["UPDATE artists SET modified_on = CURRENT_TIMESTAMP WHERE (id = 1)"]
   end
 
   specify "should be able to specify the associations to touch in the plugin call using the :associations option" do
     @Artist.plugin :touch, :associations=>:albums
     @a.touch
-    MODEL_DB.sqls.should == ["UPDATE artists SET updated_at = CURRENT_TIMESTAMP WHERE (id = 1)",
+    DB.sqls.should == ["UPDATE artists SET updated_at = CURRENT_TIMESTAMP WHERE (id = 1)",
       "UPDATE albums SET updated_at = CURRENT_TIMESTAMP WHERE (albums.artist_id = 1)"]
   end
 
   specify "should be able to give an array to the :associations option specifying multiple associations" do
     @Album.plugin :touch, :associations=>[:artist, :followup_albums]
     @Album.load(:id=>4, :artist_id=>1).touch
-    sqls = MODEL_DB.sqls
+    sqls = DB.sqls
     sqls.shift.should == "UPDATE albums SET updated_at = CURRENT_TIMESTAMP WHERE (id = 4)"
     sqls.sort.should == ["UPDATE albums SET updated_at = CURRENT_TIMESTAMP WHERE (albums.original_album_id = 4)",
       "UPDATE artists SET updated_at = CURRENT_TIMESTAMP WHERE (artists.id = 1)"]
@@ -70,21 +70,21 @@ describe "Touch plugin" do
   specify "should be able to give a hash to the :associations option specifying the column to use for each association" do
     @Artist.plugin :touch, :associations=>{:albums=>:modified_on}
     @a.touch
-    MODEL_DB.sqls.should == ["UPDATE artists SET updated_at = CURRENT_TIMESTAMP WHERE (id = 1)",
+    DB.sqls.should == ["UPDATE artists SET updated_at = CURRENT_TIMESTAMP WHERE (id = 1)",
       "UPDATE albums SET modified_on = CURRENT_TIMESTAMP WHERE (albums.artist_id = 1)"]
   end
 
   specify "should default to using the touch_column as the default touch column for associations" do
     @Artist.plugin :touch, :column=>:modified_on, :associations=>:albums
     @a.touch
-    MODEL_DB.sqls.should == ["UPDATE artists SET modified_on = CURRENT_TIMESTAMP WHERE (id = 1)",
+    DB.sqls.should == ["UPDATE artists SET modified_on = CURRENT_TIMESTAMP WHERE (id = 1)",
       "UPDATE albums SET modified_on = CURRENT_TIMESTAMP WHERE (albums.artist_id = 1)"]
   end
 
   specify "should allow the mixed use of symbols and hashes inside an array for the :associations option" do
     @Album.plugin :touch, :associations=>[:artist, {:followup_albums=>:modified_on}]
     @Album.load(:id=>4, :artist_id=>1).touch
-    sqls = MODEL_DB.sqls
+    sqls = DB.sqls
     sqls.shift.should == "UPDATE albums SET updated_at = CURRENT_TIMESTAMP WHERE (id = 4)"
     sqls.sort.should == ["UPDATE albums SET modified_on = CURRENT_TIMESTAMP WHERE (albums.original_album_id = 4)",
       "UPDATE artists SET updated_at = CURRENT_TIMESTAMP WHERE (artists.id = 1)"]
@@ -94,7 +94,7 @@ describe "Touch plugin" do
     @Album.plugin :touch
     @Album.touch_associations(:artist, {:followup_albums=>:modified_on})
     @Album.load(:id=>4, :artist_id=>1).touch
-    sqls = MODEL_DB.sqls
+    sqls = DB.sqls
     sqls.shift.should == "UPDATE albums SET updated_at = CURRENT_TIMESTAMP WHERE (id = 4)"
     sqls.sort.should == ["UPDATE albums SET modified_on = CURRENT_TIMESTAMP WHERE (albums.original_album_id = 4)",
       "UPDATE artists SET updated_at = CURRENT_TIMESTAMP WHERE (artists.id = 1)"]
@@ -104,7 +104,7 @@ describe "Touch plugin" do
     @Album.plugin :touch
     @Album.touch_associations(:artist, {:followup_albums=>:modified_on})
     @Album.load(:id=>4, :artist_id=>1).destroy
-    sqls = MODEL_DB.sqls
+    sqls = DB.sqls
     sqls.shift.should == "DELETE FROM albums WHERE id = 4"
     sqls.sort.should == ["UPDATE albums SET modified_on = CURRENT_TIMESTAMP WHERE (albums.original_album_id = 4)",
       "UPDATE artists SET updated_at = CURRENT_TIMESTAMP WHERE (artists.id = 1)"]
@@ -113,7 +113,7 @@ describe "Touch plugin" do
   specify "should be able to touch many_to_one associations" do
     @Album.plugin :touch, :associations=>:artist
     @Album.load(:id=>3, :artist_id=>4).touch
-    MODEL_DB.sqls.should == ["UPDATE albums SET updated_at = CURRENT_TIMESTAMP WHERE (id = 3)",
+    DB.sqls.should == ["UPDATE albums SET updated_at = CURRENT_TIMESTAMP WHERE (id = 3)",
       "UPDATE artists SET updated_at = CURRENT_TIMESTAMP WHERE (artists.id = 4)"]
   end
 
@@ -121,7 +121,7 @@ describe "Touch plugin" do
     @Artist.one_to_one :album, :class=>@Album, :key=>:artist_id
     @Artist.plugin :touch, :associations=>:album
     @a.touch
-    MODEL_DB.sqls.should == ["UPDATE artists SET updated_at = CURRENT_TIMESTAMP WHERE (id = 1)",
+    DB.sqls.should == ["UPDATE artists SET updated_at = CURRENT_TIMESTAMP WHERE (id = 1)",
       "UPDATE albums SET updated_at = CURRENT_TIMESTAMP WHERE (albums.artist_id = 1)"]
   end
 
@@ -129,7 +129,7 @@ describe "Touch plugin" do
     @Artist.many_to_many :albums, :class=>@Album, :left_key=>:artist_id, :join_table=>:aa
     @Artist.plugin :touch, :associations=>:albums
     @a.touch
-    MODEL_DB.sqls.should == ["UPDATE artists SET updated_at = CURRENT_TIMESTAMP WHERE (id = 1)",
+    DB.sqls.should == ["UPDATE artists SET updated_at = CURRENT_TIMESTAMP WHERE (id = 1)",
       "SELECT albums.* FROM albums INNER JOIN aa ON ((aa.album_id = albums.id) AND (aa.artist_id = 1))",
       "UPDATE albums SET updated_at = CURRENT_TIMESTAMP WHERE (id = 1)"]
   end
@@ -139,7 +139,7 @@ describe "Touch plugin" do
     @Artist.many_through_many :albums, [[:aa, :artist_id, :album_id]], :class=>@Album
     @Artist.plugin :touch, :associations=>:albums
     @a.touch
-    MODEL_DB.sqls.should == ["UPDATE artists SET updated_at = CURRENT_TIMESTAMP WHERE (id = 1)",
+    DB.sqls.should == ["UPDATE artists SET updated_at = CURRENT_TIMESTAMP WHERE (id = 1)",
       "SELECT albums.* FROM albums INNER JOIN aa ON ((aa.album_id = albums.id) AND (aa.artist_id = 1))",
       "UPDATE albums SET updated_at = CURRENT_TIMESTAMP WHERE (id = 1)"]
   end
@@ -147,17 +147,17 @@ describe "Touch plugin" do
   specify "should handle touching many_to_one associations with no associated object" do
     @Album.plugin :touch, :associations=>:artist
     @Album.load(:id=>3, :artist_id=>nil).touch
-    MODEL_DB.sqls.should == ["UPDATE albums SET updated_at = CURRENT_TIMESTAMP WHERE (id = 3)"]
+    DB.sqls.should == ["UPDATE albums SET updated_at = CURRENT_TIMESTAMP WHERE (id = 3)"]
   end
 
   specify "should not update a column that doesn't exist" do
     @Album.plugin :touch, :column=>:x
     a = @Album.load(:id=>1)
     a.touch
-    MODEL_DB.sqls.should == []
+    DB.sqls.should == []
     a.artist_id = 1
     a.touch
-    MODEL_DB.sqls.should == ['UPDATE albums SET artist_id = 1 WHERE (id = 1)']
+    DB.sqls.should == ['UPDATE albums SET artist_id = 1 WHERE (id = 1)']
   end
 
   specify "should raise an error if given a column argument in touch that doesn't exist" do
@@ -174,21 +174,21 @@ describe "Touch plugin" do
     @Artist.plugin :touch
     c1 = Class.new(@Artist)
     c1.load(:id=>4).touch
-    MODEL_DB.sqls.should == ["UPDATE artists SET updated_at = CURRENT_TIMESTAMP WHERE (id = 4)"]
+    DB.sqls.should == ["UPDATE artists SET updated_at = CURRENT_TIMESTAMP WHERE (id = 4)"]
 
     c1.touch_column = :modified_on
     c1.touch_associations :albums
     c1.load(:id=>1).touch
-    MODEL_DB.sqls.should == ["UPDATE artists SET modified_on = CURRENT_TIMESTAMP WHERE (id = 1)",
+    DB.sqls.should == ["UPDATE artists SET modified_on = CURRENT_TIMESTAMP WHERE (id = 1)",
       "UPDATE albums SET modified_on = CURRENT_TIMESTAMP WHERE (albums.artist_id = 1)"]
 
     @a.touch
-    MODEL_DB.sqls.should == ["UPDATE artists SET updated_at = CURRENT_TIMESTAMP WHERE (id = 1)"]
+    DB.sqls.should == ["UPDATE artists SET updated_at = CURRENT_TIMESTAMP WHERE (id = 1)"]
 
     @Artist.plugin :touch, :column=>:modified_on, :associations=>:albums
     c2 = Class.new(@Artist)
     c2.load(:id=>4).touch
-    MODEL_DB.sqls.should == ["UPDATE artists SET modified_on = CURRENT_TIMESTAMP WHERE (id = 4)",
+    DB.sqls.should == ["UPDATE artists SET modified_on = CURRENT_TIMESTAMP WHERE (id = 4)",
       "UPDATE albums SET modified_on = CURRENT_TIMESTAMP WHERE (albums.artist_id = 4)"]
   end
 end

data/spec/extensions/tree_spec.rb

@@ -2,7 +2,7 @@ require File.join(File.dirname(File.expand_path(__FILE__)), "spec_helper")
 
 describe Sequel::Model, "tree plugin" do
   def klass(opts={})
-    @db = MODEL_DB
+    @db = DB
     c = Class.new(Sequel::Model(@db[:nodes]))
     c.class_eval do
       def self.name; 'Node'; end
@@ -68,8 +68,8 @@ describe Sequel::Model, "tree plugin" do
   it "should have ancestors return the ancestors of the current node" do
     @ds._fetch = [[{:id=>1, :parent_id=>5, :name=>'r'}], [{:id=>5, :parent_id=>nil, :name=>'r2'}]]
     @o.ancestors.should == [@c.load(:id=>1, :parent_id=>5, :name=>'r'), @c.load(:id=>5, :parent_id=>nil, :name=>'r2')]
-    @db.sqls.should == ["SELECT * FROM nodes WHERE (nodes.id = 1) LIMIT 1",
-      "SELECT * FROM nodes WHERE (nodes.id = 5) LIMIT 1"]
+    @db.sqls.should == ["SELECT * FROM nodes WHERE id = 1",
+      "SELECT * FROM nodes WHERE id = 5"]
   end
 
   it "should have descendants return the descendants of the current node" do
@@ -84,8 +84,8 @@ describe Sequel::Model, "tree plugin" do
   it "should have root return the root of the current node" do
     @ds._fetch = [[{:id=>1, :parent_id=>5, :name=>'r'}], [{:id=>5, :parent_id=>nil, :name=>'r2'}]]
     @o.root.should == @c.load(:id=>5, :parent_id=>nil, :name=>'r2')
-    @db.sqls.should == ["SELECT * FROM nodes WHERE (nodes.id = 1) LIMIT 1",
-      "SELECT * FROM nodes WHERE (nodes.id = 5) LIMIT 1"]
+    @db.sqls.should == ["SELECT * FROM nodes WHERE id = 1",
+      "SELECT * FROM nodes WHERE id = 5"]
   end
 
   it "should have root? return true for a root node and false for a child node" do
@@ -100,14 +100,14 @@ describe Sequel::Model, "tree plugin" do
   it "should have self_and_siblings return the children of the current node's parent" do
     @ds._fetch = [[{:id=>1, :parent_id=>3, :name=>'r'}], [{:id=>7, :parent_id=>1, :name=>'r2'}, @o.values.dup]]
     @o.self_and_siblings.should == [@c.load(:id=>7, :parent_id=>1, :name=>'r2'), @o] 
-    @db.sqls.should == ["SELECT * FROM nodes WHERE (nodes.id = 1) LIMIT 1",
+    @db.sqls.should == ["SELECT * FROM nodes WHERE id = 1",
       "SELECT * FROM nodes WHERE (nodes.parent_id = 1)"]
   end
 
   it "should have siblings return the children of the current node's parent, except for the current node" do
     @ds._fetch = [[{:id=>1, :parent_id=>3, :name=>'r'}], [{:id=>7, :parent_id=>1, :name=>'r2'}, @o.values.dup]]
     @o.siblings.should == [@c.load(:id=>7, :parent_id=>1, :name=>'r2')] 
-    @db.sqls.should == ["SELECT * FROM nodes WHERE (nodes.id = 1) LIMIT 1",
+    @db.sqls.should == ["SELECT * FROM nodes WHERE id = 1",
       "SELECT * FROM nodes WHERE (nodes.parent_id = 1)"]
   end
 

data/spec/extensions/typecast_on_load_spec.rb

@@ -31,10 +31,17 @@ describe Sequel::Model, "TypecastOnLoad plugin" do
     o.bset.should == true
   end
 
+  specify "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.should == {:id=>1, :b=>1, :y=>"0"}
+    o.bset.should == true
+  end
+
   specify "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.load(:id=>1, :b=>"1", :y=>"0")
+    o = @c.new(:b=>"1", :y=>"0")
     o.save.values.should == {:id=>1, :b=>1, :y=>"0"}
     o.bset.should == true
   end

data/spec/extensions/update_primary_key_spec.rb

@@ -8,27 +8,27 @@ describe "Sequel::Plugins::UpdatePrimaryKey" do
     @c.set_primary_key :a
     @c.unrestrict_primary_key
     @ds = @c.dataset
-    MODEL_DB.reset
+    DB.reset
   end
 
   specify "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.should == [@c.load(:a=>1, :b=>4)]
-    MODEL_DB.sqls.should == ["SELECT * FROM a LIMIT 1", "UPDATE a SET b = 4 WHERE (a = 1)", "SELECT * FROM a"]
+    DB.sqls.should == ["SELECT * FROM a LIMIT 1", "UPDATE a SET b = 4 WHERE (a = 1)", "SELECT * FROM a"]
     @c.first.set(:b=>5).save
     @c.all.should == [@c.load(:a=>1, :b=>5)]
-    MODEL_DB.sqls.should == ["SELECT * FROM a LIMIT 1", "UPDATE a SET b = 5 WHERE (a = 1)", "SELECT * FROM a"]
+    DB.sqls.should == ["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.should == [@c.load(:a=>1, :b=>6)]
-    MODEL_DB.sqls.should == ["SELECT * FROM a LIMIT 1", "UPDATE a SET b = 6 WHERE (a = 1)", "SELECT * FROM a"]
+    DB.sqls.should == ["SELECT * FROM a LIMIT 1", "UPDATE a SET b = 6 WHERE (a = 1)", "SELECT * FROM a"]
   end
 
   specify "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.should == [@c.load(:a=>2, :b=>4)]
-    sqls = MODEL_DB.sqls
+    sqls = DB.sqls
     ["UPDATE a SET a = 2, b = 4 WHERE (a = 1)", "UPDATE a SET b = 4, a = 2 WHERE (a = 1)"].should include(sqls.slice!(1))
     sqls.should == ["SELECT * FROM a LIMIT 1", "SELECT * FROM a"]
   end
@@ -37,17 +37,17 @@ describe "Sequel::Plugins::UpdatePrimaryKey" 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.should == [@c.load(:a=>2, :b=>3)]
-    MODEL_DB.sqls.should == ["SELECT * FROM a LIMIT 1", "UPDATE a SET a = 2 WHERE (a = 1)", "SELECT * FROM a"]
+    DB.sqls.should == ["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.should == [@c.load(:a=>3, :b=>3)]
-    MODEL_DB.sqls.should == ["SELECT * FROM a LIMIT 1", "UPDATE a SET a = 3 WHERE (a = 2)", "SELECT * FROM a"]
+    DB.sqls.should == ["SELECT * FROM a LIMIT 1", "UPDATE a SET a = 3 WHERE (a = 2)", "SELECT * FROM a"]
   end
 
   specify "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.should == [@c.load(:a=>2, :b=>4)]
-    sqls = MODEL_DB.sqls
+    sqls = DB.sqls
     ["UPDATE a SET a = 2, b = 4 WHERE (a = 1)", "UPDATE a SET b = 4, a = 2 WHERE (a = 1)"].should include(sqls.slice!(1))
     sqls.should == ["SELECT * FROM a LIMIT 1", "SELECT * FROM a"]
   end
@@ -56,7 +56,7 @@ describe "Sequel::Plugins::UpdatePrimaryKey" do
     @ds._fetch = [[{:a=>1, :b=>3}], [{:a=>2, :b=>3}]]
     @c.first.set(:a=>2).save
     @c.all.should == [@c.load(:a=>2, :b=>3)]
-    sqls = MODEL_DB.sqls
+    sqls = DB.sqls
     ["UPDATE a SET a = 2, b = 3 WHERE (a = 1)", "UPDATE a SET b = 3, a = 2 WHERE (a = 1)"].should include(sqls.slice!(1))
     sqls.should == ["SELECT * FROM a LIMIT 1", "SELECT * FROM a"]
   end
@@ -65,7 +65,7 @@ describe "Sequel::Plugins::UpdatePrimaryKey" 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.should == [@c.load(:a=>2, :b=>5)]
-    MODEL_DB.sqls.should == ["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"]
+    DB.sqls.should == ["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
 
   specify "should clear the associations cache of non-many_to_one associations when changing the primary key" do

data/spec/extensions/validation_class_methods_spec.rb

@@ -619,6 +619,12 @@ describe "Superclass validations" do
     o.valid?.should be_true
   end
   
+  specify "should have skip_superclass_validations? return whether superclass validations were skipped" do
+    @c2.skip_superclass_validations?.should == nil
+    @c2.skip_superclass_validations
+    @c2.skip_superclass_validations?.should == true
+  end
+
   specify "should be skipped if skip_superclass_validations is called" do
     @c2.skip_superclass_validations
 
@@ -764,41 +770,6 @@ describe Sequel::Model, "Validations" do
     @person.should be_valid
   end
   
-  qspecify "should validate that a column doesn't have a string value" do
-    p = model_class.call Sequel::Model do
-      columns :age, :price, :confirmed
-      self.raise_on_typecast_failure = false
-      validates_not_string :age
-      validates_not_string :confirmed
-      validates_not_string :price, :message=>'is not valid'
-      @db_schema = {:age=>{:type=>:integer}}
-    end
-    
-    @person = p.new
-    @person.should be_valid
-
-    @person.confirmed = 't'
-    @person.should_not be_valid
-    @person.errors.full_messages.should == ['confirmed is a string']
-    @person.confirmed = true
-    @person.should be_valid
-
-    @person.age = 'a'
-    @person.should_not be_valid
-    @person.errors.full_messages.should == ['age is not a valid integer']
-    @person.db_schema[:age][:type] = :datetime
-    @person.should_not be_valid
-    @person.errors.full_messages.should == ['age is not a valid datetime']
-    @person.age = 20
-    @person.should be_valid
-
-    @person.price = 'a'
-    @person.should_not be_valid
-    @person.errors.full_messages.should == ['price is not valid']
-    @person.price = 20
-    @person.should 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
@@ -1026,26 +997,26 @@ describe "Model#save" do
       end
     end
     @m = @c.load(:id => 4, :x=>6)
-    MODEL_DB.reset
+    DB.reset
   end
 
   specify "should save only if validations pass" do
     @m.raise_on_save_failure = false
     @m.should_not be_valid
     @m.save
-    MODEL_DB.sqls.should be_empty
+    DB.sqls.should be_empty
     
     @m.x = 7
     @m.should be_valid
     @m.save.should_not be_false
-    MODEL_DB.sqls.should == ['UPDATE people SET x = 7 WHERE (id = 4)']
+    DB.sqls.should == ['UPDATE people SET x = 7 WHERE (id = 4)']
   end
   
   specify "should skip validations if the :validate=>false option is used" do
     @m.raise_on_save_failure = false
     @m.should_not be_valid
     @m.save(:validate=>false)
-    MODEL_DB.sqls.should == ['UPDATE people SET x = 6 WHERE (id = 4)']
+    DB.sqls.should == ['UPDATE people SET x = 6 WHERE (id = 4)']
   end
     
   specify "should raise error if validations fail and raise_on_save_faiure is true" do

data/spec/extensions/validation_helpers_spec.rb

@@ -235,18 +235,6 @@ describe "Sequel::Plugins::ValidationHelpers" do
     @m.should_not be_valid
   end
 
-  qspecify "should support validates_not_string" do
-    @c.set_validations{validates_not_string(:value)}
-    @m.value = 123
-    @m.should be_valid
-    @m.value = '123'
-    @m.should_not be_valid
-    @m.errors.full_messages.should == ['value is a string']
-    @m.meta_def(:db_schema){{:value=>{:type=>:integer}}}
-    @m.should_not be_valid
-    @m.errors.full_messages.should == ['value is not a valid integer']
-  end
-
   specify "should support validates_schema_types" do
     @c.set_validations{validates_schema_types}
     @m.value = 123
@@ -332,12 +320,6 @@ describe "Sequel::Plugins::ValidationHelpers" do
     @m.errors.full_messages.should == ['value is not a valid integer or float']
   end
 
-  qspecify "should have validates_type skip nil values by default" do
-    @c.set_validations{validates_type([Integer, Float], :value)}
-    @m.value = nil
-    @m.should be_valid
-  end
-
   specify "should support validates_not_null" do
     @c.set_validations{validates_not_null(:value)}
     @m.should_not be_valid
@@ -374,7 +356,7 @@ describe "Sequel::Plugins::ValidationHelpers" do
   
   it "should support validates_unique with a single attribute" do
     @c.columns(:id, :username, :password)
-    @c.set_dataset MODEL_DB[:items]
+    @c.set_dataset DB[:items]
     @c.set_validations{validates_unique(:username)}
     @c.dataset._fetch = proc do |sql|
       case sql
@@ -390,10 +372,10 @@ describe "Sequel::Plugins::ValidationHelpers" do
     @user = @c.load(:id=>3, :username => "0records", :password => "anothertest")
     @user.should be_valid
 
-    MODEL_DB.sqls
+    DB.sqls
     @user = @c.new(:password => "anothertest")
     @user.should be_valid
-    MODEL_DB.sqls.should == []
+    DB.sqls.should == []
 
     @user = @c.new(:username => "1record", :password => "anothertest")
     @user.should_not be_valid
@@ -409,15 +391,15 @@ describe "Sequel::Plugins::ValidationHelpers" do
 
     @user = @c.load(:id=>1, :username => "0records", :password => "anothertest")
     @user.should be_valid
-    MODEL_DB.sqls.last.should == "SELECT count(*) AS count FROM items WHERE ((username = '0records') AND (id != 1)) LIMIT 1"
+    DB.sqls.last.should == "SELECT count(*) AS count FROM items WHERE ((username = '0records') AND (id != 1)) LIMIT 1"
     @user = @c.new(:username => "0records", :password => "anothertest")
     @user.should be_valid
-    MODEL_DB.sqls.last.should == "SELECT count(*) AS count FROM items WHERE (username = '0records') LIMIT 1"
+    DB.sqls.last.should == "SELECT count(*) AS count FROM items WHERE (username = '0records') LIMIT 1"
   end
   
   it "should support validates_unique with multiple attributes" do
     @c.columns(:id, :username, :password)
-    @c.set_dataset MODEL_DB[:items]
+    @c.set_dataset DB[:items]
     @c.set_validations{validates_unique([:username, :password])}
     @c.dataset._fetch = proc do |sql|
       case sql
@@ -433,7 +415,7 @@ describe "Sequel::Plugins::ValidationHelpers" do
     @user = @c.load(:id=>3, :username => "0records", :password => "anothertest")
     @user.should be_valid
 
-    MODEL_DB.sqls
+    DB.sqls
     @user = @c.new(:password => "anothertest")
     @user.should be_valid
     @user.errors.full_messages.should == []
@@ -443,7 +425,7 @@ describe "Sequel::Plugins::ValidationHelpers" do
     @user = @c.new
     @user.should be_valid
     @user.errors.full_messages.should == []
-    MODEL_DB.sqls.should == []
+    DB.sqls.should == []
 
     @user = @c.new(:username => "1record", :password => "anothertest")
     @user.should_not be_valid
@@ -459,76 +441,76 @@ describe "Sequel::Plugins::ValidationHelpers" do
 
     @user = @c.load(:id=>1, :username => "0records", :password => "anothertest")
     @user.should be_valid
-    MODEL_DB.sqls.last.should == "SELECT count(*) AS count FROM items WHERE ((username = '0records') AND (password = 'anothertest') AND (id != 1)) LIMIT 1"
+    DB.sqls.last.should == "SELECT count(*) AS count FROM items WHERE ((username = '0records') AND (password = 'anothertest') AND (id != 1)) LIMIT 1"
     @user = @c.new(:username => "0records", :password => "anothertest")
     @user.should be_valid
-    MODEL_DB.sqls.last.should == "SELECT count(*) AS count FROM items WHERE ((username = '0records') AND (password = 'anothertest')) LIMIT 1"
+    DB.sqls.last.should == "SELECT count(*) AS count FROM items WHERE ((username = '0records') AND (password = 'anothertest')) LIMIT 1"
   end
 
   it "should support validates_unique with a block" do
     @c.columns(:id, :username, :password)
-    @c.set_dataset MODEL_DB[:items]
+    @c.set_dataset DB[:items]
     @c.set_validations{validates_unique(:username){|ds| ds.filter(:active)}}
     @c.dataset._fetch = {:v=>0}
     
-    MODEL_DB.reset
+    DB.reset
     @c.new(:username => "0records", :password => "anothertest").should be_valid
     @c.load(:id=>3, :username => "0records", :password => "anothertest").should be_valid
-    MODEL_DB.sqls.should == ["SELECT count(*) AS count FROM items WHERE ((username = '0records') AND active) LIMIT 1",
+    DB.sqls.should == ["SELECT count(*) AS count FROM items WHERE ((username = '0records') AND active) LIMIT 1",
                     "SELECT count(*) AS count FROM items WHERE ((username = '0records') AND active AND (id != 3)) LIMIT 1"]
   end
 
   it "should support validates_unique with a custom filter" do
     @c.columns(:id, :username, :password)
-    @c.set_dataset MODEL_DB[:items]
+    @c.set_dataset DB[:items]
     @c.set_validations{validates_unique(:username, :where=>proc{|ds, obj, cols| ds.where(cols.map{|c| [Sequel.function(:lower, c), obj.send(c).downcase]})})}
     @c.dataset._fetch = {:v=>0}
     
-    MODEL_DB.reset
+    DB.reset
     @c.new(:username => "0RECORDS", :password => "anothertest").should be_valid
     @c.load(:id=>3, :username => "0RECORDS", :password => "anothertest").should be_valid
-    MODEL_DB.sqls.should == ["SELECT count(*) AS count FROM items WHERE (lower(username) = '0records') LIMIT 1",
+    DB.sqls.should == ["SELECT count(*) AS count FROM items WHERE (lower(username) = '0records') LIMIT 1",
                     "SELECT count(*) AS count FROM items WHERE ((lower(username) = '0records') AND (id != 3)) LIMIT 1"]
   end
 
   it "should support :only_if_modified option for validates_unique, and not check uniqueness for existing records if values haven't changed" do
     @c.columns(:id, :username, :password)
-    @c.set_dataset MODEL_DB[:items]
+    @c.set_dataset DB[:items]
     @c.set_validations{validates_unique([:username, :password], :only_if_modified=>true)}
     @c.dataset._fetch = {:v=>0}
     
-    MODEL_DB.reset
+    DB.reset
     @c.new(:username => "0records", :password => "anothertest").should be_valid
-    MODEL_DB.sqls.should == ["SELECT count(*) AS count FROM items WHERE ((username = '0records') AND (password = 'anothertest')) LIMIT 1"]
-    MODEL_DB.reset
+    DB.sqls.should == ["SELECT count(*) AS count FROM items WHERE ((username = '0records') AND (password = 'anothertest')) LIMIT 1"]
+    DB.reset
     m = @c.load(:id=>3, :username => "0records", :password => "anothertest")
     m.should be_valid
-    MODEL_DB.sqls.should == []
+    DB.sqls.should == []
 
     m.username = '1'
     m.should be_valid
-    MODEL_DB.sqls.should == ["SELECT count(*) AS count FROM items WHERE ((username = '1') AND (password = 'anothertest') AND (id != 3)) LIMIT 1"]
+    DB.sqls.should == ["SELECT count(*) AS count FROM items WHERE ((username = '1') AND (password = 'anothertest') AND (id != 3)) LIMIT 1"]
 
     m = @c.load(:id=>3, :username => "0records", :password => "anothertest")
-    MODEL_DB.reset
+    DB.reset
     m.password = '1'
     m.should be_valid
-    MODEL_DB.sqls.should == ["SELECT count(*) AS count FROM items WHERE ((username = '0records') AND (password = '1') AND (id != 3)) LIMIT 1"]
-    MODEL_DB.reset
+    DB.sqls.should == ["SELECT count(*) AS count FROM items WHERE ((username = '0records') AND (password = '1') AND (id != 3)) LIMIT 1"]
+    DB.reset
     m.username = '2'
     m.should be_valid
-    MODEL_DB.sqls.should == ["SELECT count(*) AS count FROM items WHERE ((username = '2') AND (password = '1') AND (id != 3)) LIMIT 1"]
+    DB.sqls.should == ["SELECT count(*) AS count FROM items WHERE ((username = '2') AND (password = '1') AND (id != 3)) LIMIT 1"]
   end
 
   it "should not attempt a database query if the underlying columns have validation errors" do
     @c.columns(:id, :username, :password)
-    @c.set_dataset MODEL_DB[:items]
+    @c.set_dataset DB[:items]
     @c.set_validations{errors.add(:username, 'foo'); validates_unique([:username, :password])}
     @c.dataset._fetch = {:v=>0}
     
-    MODEL_DB.reset
+    DB.reset
     m = @c.new(:username => "1", :password => "anothertest")
     m.should_not be_valid
-    MODEL_DB.sqls.should == []
+    DB.sqls.should == []
   end
 end