sequel 2.11.0 → 2.12.0

data/spec/{sequel_model → model}/caching_spec.rb

@@ -13,11 +13,13 @@ describe Sequel::Model, "caching" do
     @cache = cache
     
     @c = Class.new(Sequel::Model(:items))
-    @c.class_eval do
-      set_cache cache
-      def self.name; 'Item' end
+    deprec do
+      @c.class_eval do
+        set_cache cache
+        def self.name; 'Item' end
       
-      columns :name, :id
+        columns :name, :id
+      end
     end
     
     $cache_dataset_row = {:name => 'sharon', :id => 1}
@@ -145,31 +147,31 @@ describe Sequel::Model, "caching" do
   it "should delete the cache when writing to the database" do
     m = @c[1]
     @cache[m.cache_key].should == m
-    
-    m.update_values(:name => 'tutu')
+    m.name = 'hey'
+    m.save
     @cache.has_key?(m.cache_key).should be_false
-    $sqls.last.should == "UPDATE items SET name = 'tutu' WHERE (id = 1)"
-    
-    m = @c[1]
+    $sqls.last.should == "UPDATE items SET name = 'hey', id = 1 WHERE (id = 1)"
+
+    m = @c2[1]
     @cache[m.cache_key].should == m
     m.name = 'hey'
     m.save
     @cache.has_key?(m.cache_key).should be_false
     $sqls.last.should == "UPDATE items SET name = 'hey', id = 1 WHERE (id = 1)"
+  end
 
-    m = @c2[1]
+  deprec_specify "should delete the cache when using update_values" do
+    m = @c[1]
     @cache[m.cache_key].should == m
-    
     m.update_values(:name => 'tutu')
     @cache.has_key?(m.cache_key).should be_false
     $sqls.last.should == "UPDATE items SET name = 'tutu' WHERE (id = 1)"
     
     m = @c2[1]
     @cache[m.cache_key].should == m
-    m.name = 'hey'
-    m.save
+    m.update_values(:name => 'tutu')
     @cache.has_key?(m.cache_key).should be_false
-    $sqls.last.should == "UPDATE items SET name = 'hey', id = 1 WHERE (id = 1)"
+    $sqls.last.should == "UPDATE items SET name = 'tutu' WHERE (id = 1)"
   end
   
   it "should delete the cache when deleting the record" do

data/spec/{sequel_model → model}/eager_loading_spec.rb

@@ -1042,7 +1042,7 @@ describe Sequel::Model, "#eager_graph" do
 
   it "should respect the association's :conditions option" do 
     GraphAlbum.many_to_one :active_band, :class=>'GraphBand', :key=>:band_id, :conditions=>{:active=>true}
-    GraphAlbum.eager_graph(:active_band).sql.should == "SELECT albums.id, albums.band_id, active_band.id AS active_band_id, active_band.vocalist_id FROM albums LEFT OUTER JOIN bands AS active_band ON ((active_band.id = albums.band_id) AND (active_band.active = 't'))"
+    GraphAlbum.eager_graph(:active_band).sql.should == "SELECT albums.id, albums.band_id, active_band.id AS active_band_id, active_band.vocalist_id FROM albums LEFT OUTER JOIN bands AS active_band ON ((active_band.id = albums.band_id) AND (active_band.active IS TRUE))"
 
     GraphAlbum.one_to_many :right_tracks, :class=>'GraphTrack', :key=>:album_id, :conditions=>{:id=>(0..100)}
     GraphAlbum.eager_graph(:right_tracks).sql.should == 'SELECT albums.id, albums.band_id, right_tracks.id AS right_tracks_id, right_tracks.album_id FROM albums LEFT OUTER JOIN tracks AS right_tracks ON ((right_tracks.album_id = albums.id) AND ((right_tracks.id >= 0) AND (right_tracks.id <= 100)))'
@@ -1053,7 +1053,7 @@ describe Sequel::Model, "#eager_graph" do
 
   it "should respect the association's :graph_conditions option" do 
     GraphAlbum.many_to_one :active_band, :class=>'GraphBand', :key=>:band_id, :graph_conditions=>{:active=>true}
-    GraphAlbum.eager_graph(:active_band).sql.should == "SELECT albums.id, albums.band_id, active_band.id AS active_band_id, active_band.vocalist_id FROM albums LEFT OUTER JOIN bands AS active_band ON ((active_band.id = albums.band_id) AND (active_band.active = 't'))"
+    GraphAlbum.eager_graph(:active_band).sql.should == "SELECT albums.id, albums.band_id, active_band.id AS active_band_id, active_band.vocalist_id FROM albums LEFT OUTER JOIN bands AS active_band ON ((active_band.id = albums.band_id) AND (active_band.active IS TRUE))"
 
     GraphAlbum.one_to_many :right_tracks, :class=>'GraphTrack', :key=>:album_id, :graph_conditions=>{:id=>(0..100)}
     GraphAlbum.eager_graph(:right_tracks).sql.should == 'SELECT albums.id, albums.band_id, right_tracks.id AS right_tracks_id, right_tracks.album_id FROM albums LEFT OUTER JOIN tracks AS right_tracks ON ((right_tracks.album_id = albums.id) AND ((right_tracks.id >= 0) AND (right_tracks.id <= 100)))'
@@ -1064,7 +1064,7 @@ describe Sequel::Model, "#eager_graph" do
 
   it "should respect the association's :graph_join_table_conditions option" do 
     GraphAlbum.many_to_many :active_genres, :class=>'GraphGenre', :left_key=>:album_id, :right_key=>:genre_id, :join_table=>:ag, :graph_join_table_conditions=>{:active=>true}
-    GraphAlbum.eager_graph(:active_genres).sql.should == "SELECT albums.id, albums.band_id, active_genres.id AS active_genres_id FROM albums LEFT OUTER JOIN ag ON ((ag.album_id = albums.id) AND (ag.active = 't')) LEFT OUTER JOIN genres AS active_genres ON (active_genres.id = ag.genre_id)"
+    GraphAlbum.eager_graph(:active_genres).sql.should == "SELECT albums.id, albums.band_id, active_genres.id AS active_genres_id FROM albums LEFT OUTER JOIN ag ON ((ag.album_id = albums.id) AND (ag.active IS TRUE)) LEFT OUTER JOIN genres AS active_genres ON (active_genres.id = ag.genre_id)"
 
     GraphAlbum.many_to_many :active_genres, :class=>'GraphGenre', :left_key=>:album_id, :right_key=>:genre_id, :join_table=>:ag, :graph_conditions=>{true=>:active}, :graph_join_table_conditions=>{true=>:active}
     GraphAlbum.eager_graph(:active_genres).sql.should == "SELECT albums.id, albums.band_id, active_genres.id AS active_genres_id FROM albums LEFT OUTER JOIN ag ON ((ag.album_id = albums.id) AND ('t' = albums.active)) LEFT OUTER JOIN genres AS active_genres ON ((active_genres.id = ag.genre_id) AND ('t' = ag.active))"
@@ -1072,7 +1072,7 @@ describe Sequel::Model, "#eager_graph" do
 
   it "should respect the association's :graph_block option" do 
     GraphAlbum.many_to_one :active_band, :class=>'GraphBand', :key=>:band_id, :graph_block=>proc{|ja,lja,js| {:active.qualify(ja)=>true}}
-    GraphAlbum.eager_graph(:active_band).sql.should == "SELECT albums.id, albums.band_id, active_band.id AS active_band_id, active_band.vocalist_id FROM albums LEFT OUTER JOIN bands AS active_band ON ((active_band.id = albums.band_id) AND (active_band.active = 't'))"
+    GraphAlbum.eager_graph(:active_band).sql.should == "SELECT albums.id, albums.band_id, active_band.id AS active_band_id, active_band.vocalist_id FROM albums LEFT OUTER JOIN bands AS active_band ON ((active_band.id = albums.band_id) AND (active_band.active IS TRUE))"
 
     GraphAlbum.one_to_many :right_tracks, :class=>'GraphTrack', :key=>:album_id, :graph_block=>proc{|ja,lja,js| {:id.qualify(ja)=>(0..100)}}
     GraphAlbum.eager_graph(:right_tracks).sql.should == 'SELECT albums.id, albums.band_id, right_tracks.id AS right_tracks_id, right_tracks.album_id FROM albums LEFT OUTER JOIN tracks AS right_tracks ON ((right_tracks.album_id = albums.id) AND ((right_tracks.id >= 0) AND (right_tracks.id <= 100)))'
@@ -1083,7 +1083,7 @@ describe Sequel::Model, "#eager_graph" do
 
   it "should respect the association's :graph_join_block option" do 
     GraphAlbum.many_to_many :active_genres, :class=>'GraphGenre', :left_key=>:album_id, :right_key=>:genre_id, :join_table=>:ag, :graph_join_table_block=>proc{|ja,lja,js| {:active.qualify(ja)=>true}}
-    GraphAlbum.eager_graph(:active_genres).sql.should == "SELECT albums.id, albums.band_id, active_genres.id AS active_genres_id FROM albums LEFT OUTER JOIN ag ON ((ag.album_id = albums.id) AND (ag.active = 't')) LEFT OUTER JOIN genres AS active_genres ON (active_genres.id = ag.genre_id)"
+    GraphAlbum.eager_graph(:active_genres).sql.should == "SELECT albums.id, albums.band_id, active_genres.id AS active_genres_id FROM albums LEFT OUTER JOIN ag ON ((ag.album_id = albums.id) AND (ag.active IS TRUE)) LEFT OUTER JOIN genres AS active_genres ON (active_genres.id = ag.genre_id)"
 
     GraphAlbum.many_to_many :active_genres, :class=>'GraphGenre', :left_key=>:album_id, :right_key=>:genre_id, :join_table=>:ag, :graph_block=>proc{|ja,lja,js| {true=>:active.qualify(lja)}}, :graph_join_table_block=>proc{|ja,lja,js| {true=>:active.qualify(lja)}}
     GraphAlbum.eager_graph(:active_genres).sql.should == "SELECT albums.id, albums.band_id, active_genres.id AS active_genres_id FROM albums LEFT OUTER JOIN ag ON ((ag.album_id = albums.id) AND ('t' = albums.active)) LEFT OUTER JOIN genres AS active_genres ON ((active_genres.id = ag.genre_id) AND ('t' = ag.active))"
@@ -1091,7 +1091,7 @@ describe Sequel::Model, "#eager_graph" do
 
   it "should respect the association's :eager_grapher option" do 
     GraphAlbum.many_to_one :active_band, :class=>'GraphBand', :key=>:band_id, :eager_grapher=>proc{|ds, aa, ta| ds.graph(GraphBand, {:active=>true}, :table_alias=>aa, :join_type=>:inner)}
-    GraphAlbum.eager_graph(:active_band).sql.should == "SELECT albums.id, albums.band_id, active_band.id AS active_band_id, active_band.vocalist_id FROM albums INNER JOIN bands AS active_band ON (active_band.active = 't')"
+    GraphAlbum.eager_graph(:active_band).sql.should == "SELECT albums.id, albums.band_id, active_band.id AS active_band_id, active_band.vocalist_id FROM albums INNER JOIN bands AS active_band ON (active_band.active IS TRUE)"
 
     GraphAlbum.one_to_many :right_tracks, :class=>'GraphTrack', :key=>:album_id, :eager_grapher=>proc{|ds, aa, ta| ds.graph(GraphTrack, nil, :join_type=>:natural, :table_alias=>aa)}
     GraphAlbum.eager_graph(:right_tracks).sql.should == 'SELECT albums.id, albums.band_id, right_tracks.id AS right_tracks_id, right_tracks.album_id FROM albums NATURAL JOIN tracks AS right_tracks'
@@ -1102,7 +1102,7 @@ describe Sequel::Model, "#eager_graph" do
 
   it "should respect the association's :graph_only_conditions option" do 
     GraphAlbum.many_to_one :active_band, :class=>'GraphBand', :key=>:band_id, :graph_only_conditions=>{:active=>true}
-    GraphAlbum.eager_graph(:active_band).sql.should == "SELECT albums.id, albums.band_id, active_band.id AS active_band_id, active_band.vocalist_id FROM albums LEFT OUTER JOIN bands AS active_band ON (active_band.active = 't')"
+    GraphAlbum.eager_graph(:active_band).sql.should == "SELECT albums.id, albums.band_id, active_band.id AS active_band_id, active_band.vocalist_id FROM albums LEFT OUTER JOIN bands AS active_band ON (active_band.active IS TRUE)"
 
     GraphAlbum.one_to_many :right_tracks, :class=>'GraphTrack', :key=>:album_id, :graph_only_conditions=>nil, :graph_join_type=>:natural
     GraphAlbum.eager_graph(:right_tracks).sql.should == 'SELECT albums.id, albums.band_id, right_tracks.id AS right_tracks_id, right_tracks.album_id FROM albums NATURAL JOIN tracks AS right_tracks'
@@ -1113,7 +1113,7 @@ describe Sequel::Model, "#eager_graph" do
 
   it "should respect the association's :graph_join_table_only_conditions option" do 
     GraphAlbum.many_to_many :active_genres, :class=>'GraphGenre', :left_key=>:album_id, :right_key=>:genre_id, :join_table=>:ag, :graph_join_table_only_conditions=>{:active=>true}
-    GraphAlbum.eager_graph(:active_genres).sql.should == "SELECT albums.id, albums.band_id, active_genres.id AS active_genres_id FROM albums LEFT OUTER JOIN ag ON (ag.active = 't') LEFT OUTER JOIN genres AS active_genres ON (active_genres.id = ag.genre_id)"
+    GraphAlbum.eager_graph(:active_genres).sql.should == "SELECT albums.id, albums.band_id, active_genres.id AS active_genres_id FROM albums LEFT OUTER JOIN ag ON (ag.active IS TRUE) LEFT OUTER JOIN genres AS active_genres ON (active_genres.id = ag.genre_id)"
 
     GraphAlbum.many_to_many :active_genres, :class=>'GraphGenre', :left_key=>:album_id, :right_key=>:genre_id, :join_table=>:ag, :graph_only_conditions=>(:price + 2 > 100), :graph_join_table_only_conditions=>"active"
     GraphAlbum.eager_graph(:active_genres).sql.should == "SELECT albums.id, albums.band_id, active_genres.id AS active_genres_id FROM albums LEFT OUTER JOIN ag ON (active) LEFT OUTER JOIN genres AS active_genres ON ((price + 2) > 100)"

data/spec/model/hooks_spec.rb

@@ -0,0 +1,472 @@
+require File.join(File.dirname(__FILE__), "spec_helper")
+
+describe "Model hooks" do
+  before do
+    MODEL_DB.reset
+  end
+  
+  deprec_specify "should be definable using a block" do
+    $adds = []
+    c = Class.new(Sequel::Model)
+    c.class_eval do
+      before_save {$adds << 'hi'}
+    end
+    
+    c.new.before_save
+    $adds.should == ['hi']
+  end
+  
+  deprec_specify "should be definable using a method name" do
+    $adds = []
+    c = Class.new(Sequel::Model)
+    c.class_eval do
+      def bye; $adds << 'bye'; end
+      before_save :bye
+    end
+    
+    c.new.before_save
+    $adds.should == ['bye']
+  end
+
+  deprec_specify "should be additive" do
+    $adds = []
+    c = Class.new(Sequel::Model)
+    c.class_eval do
+      after_save {$adds << 'hyiyie'}
+      after_save {$adds << 'byiyie'}
+    end
+
+    c.new.after_save
+    $adds.should == ['hyiyie', 'byiyie']
+  end
+  
+  deprec_specify "before hooks should run in reverse order" do
+    $adds = []
+    c = Class.new(Sequel::Model)
+    c.class_eval do
+      before_save {$adds << 'hyiyie'}
+      before_save {$adds << 'byiyie'}
+    end
+    
+    c.new.before_save
+    $adds.should == ['byiyie', 'hyiyie']
+  end
+
+  deprec_specify "should not be additive if the method or tag already exists" do
+    $adds = []
+    c = Class.new(Sequel::Model)
+    c.class_eval do
+      def bye; $adds << 'bye'; end
+      before_save :bye
+      before_save :bye
+    end
+    
+    c.new.before_save
+    $adds.should == ['bye']
+
+    $adds = []
+    d = Class.new(Sequel::Model)
+    d.class_eval do
+      before_save(:bye){$adds << 'hyiyie'}
+      before_save(:bye){$adds << 'byiyie'}
+    end
+    
+    d.new.before_save
+    $adds.should == ['byiyie']
+
+    $adds = []
+    e = Class.new(Sequel::Model)
+    e.class_eval do
+      def bye; $adds << 'bye'; end
+      before_save :bye
+      before_save(:bye){$adds << 'byiyie'}
+    end
+    
+    e.new.before_save
+    $adds.should == ['byiyie']
+
+    $adds = []
+    e = Class.new(Sequel::Model)
+    e.class_eval do
+      def bye; $adds << 'bye'; end
+      before_save(:bye){$adds << 'byiyie'}
+      before_save :bye
+    end
+    
+    e.new.before_save
+    $adds.should == ['bye']
+  end
+  
+  deprec_specify "should be inheritable" do
+    $adds = []
+    a = Class.new(Sequel::Model)
+    a.class_eval do
+      after_save {$adds << '123'}
+    end
+    
+    b = Class.new(a)
+    b.class_eval do
+      after_save {$adds << '456'}
+      after_save {$adds << '789'}
+    end
+    
+    b.new.after_save
+    $adds.should == ['123', '456', '789']
+  end
+  
+  deprec_specify "should be overridable in descendant classes" do
+    $adds = []
+    a = Class.new(Sequel::Model)
+    a.class_eval do
+      before_save {$adds << '123'}
+    end
+    
+    b = Class.new(a)
+    b.class_eval do
+      def before_save; $adds << '456'; end
+    end
+    
+    a.new.before_save
+    $adds.should == ['123']
+    $adds = []
+    b.new.before_save
+    $adds.should == ['456']
+  end
+  
+  deprec_specify "should stop processing if a hook returns false" do
+    $flag = true
+    $adds = []
+    
+    a = Class.new(Sequel::Model)
+    a.class_eval do
+      after_save {$adds << 'blah'; $flag}
+      after_save {$adds << 'cruel'}
+    end
+    
+    a.new.after_save
+    $adds.should == ['blah', 'cruel']
+
+    # chain should not break on nil
+    $adds = []
+    $flag = nil
+    a.new.after_save
+    $adds.should == ['blah', 'cruel']
+    
+    $adds = []
+    $flag = false
+    a.new.after_save
+    $adds.should == ['blah']
+    
+    b = Class.new(a)
+    b.class_eval do
+      after_save {$adds << 'mau'}
+    end
+    
+    $adds = []
+    b.new.after_save
+    $adds.should == ['blah']
+  end
+end
+
+describe "Model#after_initialize" do
+  specify "should be called after initialization" do
+    $values1 = nil
+    $reached_after_initialized = false
+    
+    a = Class.new(Sequel::Model)
+    a.class_eval do
+      columns :x, :y
+      def after_initialize
+        $values1 = @values.clone
+        $reached_after_initialized = true
+      end
+    end
+    
+    a.new(:x => 1, :y => 2)
+    $values1.should == {:x => 1, :y => 2}
+    $reached_after_initialized.should == true
+  end
+end
+
+describe "Model#before_create && Model#after_create" do
+  before do
+    MODEL_DB.reset
+
+    @c = Class.new(Sequel::Model(:items))
+    @c.class_eval do
+      columns :x
+      no_primary_key
+      
+      def after_create
+        MODEL_DB << "BLAH after"
+      end
+    end
+  end
+  
+  specify "should be called around new record creation" do
+    @c.send(:define_method, :before_create){MODEL_DB << "BLAH before"}
+    @c.create(:x => 2)
+    MODEL_DB.sqls.should == [
+      'BLAH before',
+      'INSERT INTO items (x) VALUES (2)',
+      'BLAH after'
+    ]
+  end
+
+  specify ".create should cancel the save and raise an error if before_create returns false and raise_on_save_failure is true" do
+    @c.send(:define_method, :before_create){false}
+    proc{@c.load(:id => 2233).save}.should_not raise_error(Sequel::ValidationFailed)
+    proc{@c.create(:x => 2)}.should raise_error(Sequel::BeforeHookFailed)
+    MODEL_DB.sqls.should == []
+  end
+
+  specify ".create should cancel the save and return nil if before_create returns false and raise_on_save_failure is false" do
+    @c.send(:define_method, :before_create){false}
+    @c.raise_on_save_failure = false
+    @c.create(:x => 2).should == nil
+    MODEL_DB.sqls.should == []
+  end
+end
+
+describe "Model#before_update && Model#after_update" do
+  before do
+    MODEL_DB.reset
+
+    @c = Class.new(Sequel::Model(:items))
+    @c.class_eval do
+      def after_update; MODEL_DB << "BLAH after" end
+    end
+  end
+  
+  specify "should be called around record update" do
+    @c.send(:define_method, :before_update){MODEL_DB << "BLAH before"}
+    m = @c.load(:id => 2233)
+    m.save
+    MODEL_DB.sqls.should == [
+      'BLAH before',
+      'UPDATE items SET id = 2233 WHERE (id = 2233)',
+      'BLAH after'
+    ]
+  end
+
+  specify "#save should cancel the save and raise an error if before_update returns false and raise_on_save_failure is true" do
+    @c.send(:define_method, :before_update){false}
+    proc{@c.load(:id => 2233).save}.should_not raise_error(Sequel::ValidationFailed)
+    proc{@c.load(:id => 2233).save}.should raise_error(Sequel::BeforeHookFailed)
+    MODEL_DB.sqls.should == []
+  end
+
+  specify "#save should cancel the save and return nil if before_update returns false and raise_on_save_failure is false" do
+    @c.send(:define_method, :before_update){false}
+    @c.raise_on_save_failure = false
+    @c.load(:id => 2233).save.should == nil
+    MODEL_DB.sqls.should == []
+  end
+end
+
+describe "Model#before_save && Model#after_save" do
+  before do
+    MODEL_DB.reset
+
+    @c = Class.new(Sequel::Model(:items))
+    @c.class_eval do
+      columns :x
+      def after_save; MODEL_DB << "BLAH after" end
+    end
+  end
+  
+  specify "should be called around record update" do
+    @c.send(:define_method, :before_save){MODEL_DB << "BLAH before"}
+    m = @c.load(:id => 2233)
+    m.save
+    MODEL_DB.sqls.should == [
+      'BLAH before',
+      'UPDATE items SET id = 2233 WHERE (id = 2233)',
+      'BLAH after'
+    ]
+  end
+  
+  specify "should be called around record creation" do
+    @c.send(:define_method, :before_save){MODEL_DB << "BLAH before"}
+    @c.no_primary_key
+    @c.create(:x => 2)
+    MODEL_DB.sqls.should == [
+      'BLAH before',
+      'INSERT INTO items (x) VALUES (2)',
+      'BLAH after'
+    ]
+  end
+
+  specify "#save should cancel the save and raise an error if before_save returns false and raise_on_save_failure is true" do
+    @c.send(:define_method, :before_save){false}
+    proc{@c.load(:id => 2233).save}.should_not raise_error(Sequel::ValidationFailed)
+    proc{@c.load(:id => 2233).save}.should raise_error(Sequel::BeforeHookFailed)
+    MODEL_DB.sqls.should == []
+  end
+
+  specify "#save should cancel the save and return nil if before_save returns false and raise_on_save_failure is false" do
+    @c.send(:define_method, :before_save){false}
+    @c.raise_on_save_failure = false
+    @c.load(:id => 2233).save.should == nil
+    MODEL_DB.sqls.should == []
+  end
+end
+
+describe "Model#before_destroy && Model#after_destroy" do
+  before do
+    MODEL_DB.reset
+
+    @c = Class.new(Sequel::Model(:items))
+    @c.class_eval do
+      def after_destroy; MODEL_DB << "BLAH after"; end
+      
+      def delete
+        MODEL_DB << "DELETE BLAH"
+      end
+    end
+  end
+  
+  specify "should be called around record destruction" do
+    @c.send(:define_method, :before_destroy){MODEL_DB << "BLAH before"}
+    m = @c.load(:id => 2233)
+    m.destroy
+    MODEL_DB.sqls.should == [
+      'BLAH before',
+      'DELETE BLAH',
+      'BLAH after'
+    ]
+  end
+
+  specify "#destroy should cancel the destroy and raise an error if before_destroy returns false and raise_on_save_failure is true" do
+    @c.send(:define_method, :before_destroy){false}
+    proc{@c.load(:id => 2233).destroy}.should raise_error(Sequel::BeforeHookFailed)
+    MODEL_DB.sqls.should == []
+  end
+
+  specify "#destroy should cancel the destroy and return nil if before_destroy returns false and raise_on_save_failure is false" do
+    @c.send(:define_method, :before_destroy){false}
+    @c.raise_on_save_failure = false
+    @c.load(:id => 2233).destroy.should == nil
+    MODEL_DB.sqls.should == []
+  end
+end
+
+describe "Model#before_validation && Model#after_validation" do
+  before do
+    MODEL_DB.reset
+
+    @c = Class.new(Sequel::Model(:items))
+    @c.class_eval do
+      def after_validation; MODEL_DB << "BLAH after" end
+
+      def self.validate(o)
+        o.errors[:id] << 'not valid' unless o[:id] == 2233
+      end
+      columns :id
+    end
+  end
+  
+  specify "should be called around validation" do
+    @c.send(:define_method, :before_validation){MODEL_DB << "BLAH before"}
+    m = @c.load(:id => 2233)
+    m.should be_valid
+    MODEL_DB.sqls.should == ['BLAH before', 'BLAH after']
+
+    MODEL_DB.sqls.clear
+    m = @c.load(:id => 22)
+    m.should_not be_valid
+    MODEL_DB.sqls.should == ['BLAH before', 'BLAH after']
+  end
+
+  specify "should be called when calling save" do
+    @c.send(:define_method, :before_validation){MODEL_DB << "BLAH before"}
+    m = @c.load(:id => 2233)
+    m.save.should == m
+    MODEL_DB.sqls.should == ['BLAH before', 'BLAH after', 'UPDATE items SET id = 2233 WHERE (id = 2233)']
+
+    MODEL_DB.sqls.clear
+    m = @c.load(:id => 22)
+    m.raise_on_save_failure = false
+    m.save.should == nil
+    MODEL_DB.sqls.should == ['BLAH before', 'BLAH after']
+  end
+
+  specify "#save should cancel the save and raise an error if before_validation returns false and raise_on_save_failure is true" do
+    @c.send(:define_method, :before_validation){false}
+    proc{@c.load(:id => 2233).save}.should_not raise_error(Sequel::ValidationFailed)
+    proc{@c.load(:id => 2233).save}.should raise_error(Sequel::BeforeHookFailed)
+    MODEL_DB.sqls.should == []
+  end
+
+  specify "#save should cancel the save and return nil if before_validation returns false and raise_on_save_failure is false" do
+    @c.send(:define_method, :before_validation){false}
+    @c.raise_on_save_failure = false
+    @c.load(:id => 2233).save.should == nil
+    MODEL_DB.sqls.should == []
+  end
+end
+
+describe "Model.has_hooks?" do
+  before do
+    @c = Class.new(Sequel::Model(:items))
+  end
+  
+  deprec_specify "should return false if no hooks are defined" do
+    @c.has_hooks?(:before_save).should be_false
+  end
+  
+  deprec_specify "should return true if hooks are defined" do
+    @c.before_save {'blah'}
+    @c.has_hooks?(:before_save).should be_true
+  end
+  
+  deprec_specify "should return true if hooks are inherited" do
+    @d = Class.new(@c)
+    @d.has_hooks?(:before_save).should be_false
+  end
+end
+
+describe "Model#add_hook_type" do
+  before do
+    deprec do
+      class Foo < Sequel::Model(:items)
+        add_hook_type :before_bar, :after_bar
+
+        def bar
+          return :b if before_bar == false
+          return :a if after_bar == false
+          true
+        end
+      end
+    end
+    @f = Class.new(Foo)
+  end
+
+  deprec_specify "should have before_bar and after_bar class methods" do
+    @f.should respond_to(:before_bar)
+    @f.should respond_to(:before_bar)
+  end
+
+  deprec_specify "should have before_bar and after_bar instance methods" do
+    @f.new.should respond_to(:before_bar)
+    @f.new.should respond_to(:before_bar)
+  end
+
+  deprec_specify "it should return true for bar when before_bar and after_bar hooks are returing true" do
+    a = 1
+    @f.before_bar { a += 1}
+    @f.new.bar.should be_true
+    a.should == 2
+    @f.after_bar { a *= 2}
+    @f.new.bar.should be_true
+    a.should == 6
+  end
+
+  deprec_specify "it should return nil for bar when before_bar and after_bar hooks are returing false" do
+    @f.new.bar.should be_true
+    @f.after_bar { false }
+    @f.new.bar.should == :a
+    @f.before_bar { false }
+    @f.new.bar.should == :b
+  end
+end