sequel 1.5.1 → 2.0.0

data/spec/base_spec.rb

@@ -240,10 +240,10 @@ end
 
 describe "Model.db=" do
   setup do
-    $db1 = Sequel::Database.new
-    $db2 = Sequel::Database.new
+    $db1 = MockDatabase.new
+    $db2 = MockDatabase.new
     
-    class BlueBlue < Sequel::Model
+    class BlueBlue < Sequel::Model(:items)
       set_dataset $db1[:blue]
     end
   end

data/spec/eager_loading_spec.rb

@@ -9,12 +9,25 @@ describe Sequel::Model, "#eager" do
       many_to_one :band, :class=>'EagerBand', :key=>:band_id
       one_to_many :tracks, :class=>'EagerTrack', :key=>:album_id
       many_to_many :genres, :class=>'EagerGenre', :left_key=>:album_id, :right_key=>:genre_id, :join_table=>:ag
+      one_to_many :good_tracks, :class=>'EagerTrack', :key=>:album_id do |ds|
+        ds.filter(:name=>'Good')
+      end
+      many_to_one :band_name, :class=>'EagerBand', :key=>:band_id, :select=>[:id, :name]
+      one_to_many :track_names, :class=>'EagerTrack', :key=>:album_id, :select=>[:id, :name]
+      many_to_many :genre_names, :class=>'EagerGenre', :left_key=>:album_id, :right_key=>:genre_id, :join_table=>:ag, :select=>[:id]
     end
 
     class EagerBand < Sequel::Model(:bands)
       columns :id
       one_to_many :albums, :class=>'EagerAlbum', :key=>:band_id, :eager=>:tracks
       many_to_many :members, :class=>'EagerBandMember', :left_key=>:band_id, :right_key=>:member_id, :join_table=>:bm
+      one_to_many :good_albums, :class=>'EagerAlbum', :key=>:band_id, :eager_block=>proc{|ds| ds.filter(:name=>'good')} do |ds|
+        ds.filter(:name=>'Good')
+      end
+      one_to_many :self_titled_albums, :class=>'EagerAlbum', :key=>:band_id, :allow_eager=>false do |ds|
+        ds.filter(:name=>name)
+      end
+      one_to_many :albums_by_name, :class=>'EagerAlbum', :key=>:band_id, :order=>:name, :allow_eager=>false
     end
     
     class EagerTrack < Sequel::Model(:tracks)
@@ -34,7 +47,11 @@ describe Sequel::Model, "#eager" do
     
     EagerAlbum.dataset.extend(Module.new {
       def fetch_rows(sql)
-        h = {:id => 1, :band_id=> 2}
+        h = if sql =~ /101/
+          {:id => 101, :band_id=> 101}
+        else
+          {:id => 1, :band_id=> 2}
+        end
         h.merge!(:x_foreign_key_x=>4) if sql =~ /ag\.genre_id/
         @db << sql
         yield h
@@ -46,7 +63,14 @@ describe Sequel::Model, "#eager" do
         h = {:id => 2}
         h.merge!(:x_foreign_key_x=>5) if sql =~ /bm\.member_id/
         @db << sql
-        yield h
+        case sql
+        when /id IN (101)/
+        when /id > 100/
+          yield({:id => 101})
+          yield({:id => 102})
+        else
+          yield h
+        end
       end
     })
     
@@ -82,7 +106,7 @@ describe Sequel::Model, "#eager" do
     a.size.should == 1
     a.first.should be_a_kind_of(EagerAlbum)
     a.first.values.should == {:id => 1, :band_id => 2}
-    MODEL_DB.sqls.should == ['SELECT * FROM albums', 'SELECT * FROM bands WHERE (id IN (2))']
+    MODEL_DB.sqls.should == ['SELECT * FROM albums', 'SELECT bands.* FROM bands WHERE (id IN (2))']
     a = a.first
     a.band.should be_a_kind_of(EagerBand)
     a.band.values.should == {:id => 2}
@@ -95,7 +119,7 @@ describe Sequel::Model, "#eager" do
     a.size.should == 1
     a.first.should be_a_kind_of(EagerAlbum)
     a.first.values.should == {:id => 1, :band_id => 2}
-    MODEL_DB.sqls.should == ['SELECT * FROM albums', 'SELECT * FROM tracks WHERE (album_id IN (1))']
+    MODEL_DB.sqls.should == ['SELECT * FROM albums', 'SELECT tracks.* FROM tracks WHERE (album_id IN (1))']
     a = a.first
     a.tracks.should be_a_kind_of(Array)
     a.tracks.size.should == 1
@@ -110,11 +134,7 @@ describe Sequel::Model, "#eager" do
     a.size.should == 1
     a.first.should be_a_kind_of(EagerAlbum)
     a.first.values.should == {:id => 1, :band_id => 2}
-    MODEL_DB.sqls.length.should == 2
-    MODEL_DB.sqls[0].should == 'SELECT * FROM albums'
-    ["SELECT genres.*, ag.album_id AS x_foreign_key_x FROM genres INNER JOIN ag ON (ag.genre_id = genres.id) AND (ag.album_id IN (1))",
-     "SELECT genres.*, ag.album_id AS x_foreign_key_x FROM genres INNER JOIN ag ON (ag.album_id IN (1)) AND (ag.genre_id = genres.id)"
-    ].should(include(MODEL_DB.sqls[1]))
+    MODEL_DB.sqls.should == ['SELECT * FROM albums', "SELECT genres.*, ag.album_id AS x_foreign_key_x FROM genres INNER JOIN ag ON ((ag.genre_id = genres.id) AND (ag.album_id IN (1)))"]
     a = a.first
     a.genres.should be_a_kind_of(Array)
     a.genres.size.should == 1
@@ -131,12 +151,9 @@ describe Sequel::Model, "#eager" do
     a.first.values.should == {:id => 1, :band_id => 2}
     MODEL_DB.sqls.length.should == 4
     MODEL_DB.sqls[0].should == 'SELECT * FROM albums'
-    MODEL_DB.sqls[1..-1].should(include('SELECT * FROM bands WHERE (id IN (2))'))
-    MODEL_DB.sqls[1..-1].should(include('SELECT * FROM tracks WHERE (album_id IN (1))'))
-    sqls = MODEL_DB.sqls[1..-1] - ['SELECT * FROM bands WHERE (id IN (2))', 'SELECT * FROM tracks WHERE (album_id IN (1))']
-    ["SELECT genres.*, ag.album_id AS x_foreign_key_x FROM genres INNER JOIN ag ON (ag.genre_id = genres.id) AND (ag.album_id IN (1))",
-     "SELECT genres.*, ag.album_id AS x_foreign_key_x FROM genres INNER JOIN ag ON (ag.album_id IN (1)) AND (ag.genre_id = genres.id)"
-    ].should(include(sqls[0]))
+    MODEL_DB.sqls[1..-1].should(include('SELECT bands.* FROM bands WHERE (id IN (2))'))
+    MODEL_DB.sqls[1..-1].should(include('SELECT tracks.* FROM tracks WHERE (album_id IN (1))'))
+    MODEL_DB.sqls[1..-1].should(include('SELECT genres.*, ag.album_id AS x_foreign_key_x FROM genres INNER JOIN ag ON ((ag.genre_id = genres.id) AND (ag.album_id IN (1)))'))
     a = a.first
     a.band.should be_a_kind_of(EagerBand)
     a.band.values.should == {:id => 2}
@@ -158,12 +175,10 @@ describe Sequel::Model, "#eager" do
     a.first.should be_a_kind_of(EagerTrack)
     a.first.values.should == {:id => 3, :album_id => 1}
     MODEL_DB.sqls.length.should == 4
-    MODEL_DB.sqls[0...-1].should == ['SELECT * FROM tracks', 
-                             'SELECT * FROM albums WHERE (id IN (1))',
-                             'SELECT * FROM bands WHERE (id IN (2))']
-    ["SELECT members.*, bm.band_id AS x_foreign_key_x FROM members INNER JOIN bm ON (bm.member_id = members.id) AND (bm.band_id IN (2))",
-     "SELECT members.*, bm.band_id AS x_foreign_key_x FROM members INNER JOIN bm ON (bm.band_id IN (2)) AND (bm.member_id = members.id)"
-    ].should(include(MODEL_DB.sqls[-1]))
+    MODEL_DB.sqls.should == ['SELECT * FROM tracks', 
+      'SELECT albums.* FROM albums WHERE (id IN (1))',
+      'SELECT bands.* FROM bands WHERE (id IN (2))',
+      "SELECT members.*, bm.band_id AS x_foreign_key_x FROM members INNER JOIN bm ON ((bm.member_id = members.id) AND (bm.band_id IN (2)))"]
     a = a.first
     a.album.should be_a_kind_of(EagerAlbum)
     a.album.values.should == {:id => 1, :band_id => 2}
@@ -183,8 +198,8 @@ describe Sequel::Model, "#eager" do
     a.first.should be_a_kind_of(EagerBand)
     a.first.values.should == {:id => 2}
     MODEL_DB.sqls.should == ['SELECT * FROM bands', 
-                             'SELECT * FROM albums WHERE (band_id IN (2))',
-                             'SELECT * FROM tracks WHERE (album_id IN (1))']
+                             'SELECT albums.* FROM albums WHERE (band_id IN (2))',
+                             'SELECT tracks.* FROM tracks WHERE (album_id IN (1))']
     a = a.first
     a.albums.should be_a_kind_of(Array)
     a.albums.size.should == 1
@@ -208,8 +223,8 @@ describe Sequel::Model, "#eager" do
     a = a.first
     a.albums
     MODEL_DB.sqls.should == ['SELECT * FROM bands', 
-                             'SELECT * FROM albums WHERE (band_id = 2)',
-                             'SELECT * FROM tracks WHERE (album_id IN (1))']
+                             'SELECT albums.* FROM albums WHERE (band_id = 2)',
+                             'SELECT tracks.* FROM tracks WHERE (album_id IN (1))']
     a.albums.should be_a_kind_of(Array)
     a.albums.size.should == 1
     a.albums.first.should be_a_kind_of(EagerAlbum)
@@ -228,11 +243,7 @@ describe Sequel::Model, "#eager" do
     a.size.should == 1
     a.first.should be_a_kind_of(EagerBandMember)
     a.first.values.should == {:id => 5}
-    MODEL_DB.sqls.length.should == 2
-    MODEL_DB.sqls[0].should == 'SELECT * FROM members'
-    ['SELECT bands.*, bm.member_id AS x_foreign_key_x FROM bands INNER JOIN bm ON (bm.band_id = bands.id) AND (bm.member_id IN (5)) ORDER BY id',
-     'SELECT bands.*, bm.member_id AS x_foreign_key_x FROM bands INNER JOIN bm ON (bm.member_id IN (5)) AND (bm.band_id = bands.id) ORDER BY id'
-    ].should(include(MODEL_DB.sqls[1]))
+    MODEL_DB.sqls.should == ['SELECT * FROM members', 'SELECT bands.*, bm.member_id AS x_foreign_key_x FROM bands INNER JOIN bm ON ((bm.band_id = bands.id) AND (bm.member_id IN (5))) ORDER BY id']
     a = a.first
     a.bands.should be_a_kind_of(Array)
     a.bands.size.should == 1
@@ -247,7 +258,7 @@ describe Sequel::Model, "#eager" do
     a.size.should == 1
     a.first.should be_a_kind_of(EagerAlbum)
     a.first.values.should == {:id => 1, :band_id => 2}
-    MODEL_DB.sqls.should == ['SELECT * FROM albums', 'SELECT * FROM tracks WHERE (album_id IN (1))']
+    MODEL_DB.sqls.should == ['SELECT * FROM albums', 'SELECT tracks.* FROM tracks WHERE (album_id IN (1))']
     a = a.first
     a.tracks.should be_a_kind_of(Array)
     a.tracks.size.should == 1
@@ -257,6 +268,64 @@ describe Sequel::Model, "#eager" do
     a.tracks.first.album.should == a
     MODEL_DB.sqls.length.should == 2
   end
+
+  it "should cache the negative lookup when eagerly loading a many_to_one association" do
+    a = EagerAlbum.eager(:band).filter(:id=>101).all
+    a.should be_a_kind_of(Array)
+    a.size.should == 1
+    a.first.should be_a_kind_of(EagerAlbum)
+    a.first.values.should == {:id => 101, :band_id => 101}
+    MODEL_DB.sqls.should == ['SELECT * FROM albums WHERE (id = 101)', 'SELECT bands.* FROM bands WHERE (id IN (101))']
+    a = a.first
+    a.instance_variable_get(:@band).should == :null
+    a.band.should == nil
+    MODEL_DB.sqls.length.should == 2
+  end
+  
+  it "should cache the negative lookup when eagerly loading a *_to_many associations" do
+    a = EagerBand.eager(:albums).filter('id > 100').all
+    a.should be_a_kind_of(Array)
+    a.size.should == 2
+    a.first.should be_a_kind_of(EagerBand)
+    a.first.values.should == {:id => 101}
+    a.last.values.should == {:id => 102}
+    MODEL_DB.sqls.should == ['SELECT * FROM bands WHERE (id > 100)', 'SELECT albums.* FROM albums WHERE (band_id IN (101, 102))', "SELECT tracks.* FROM tracks WHERE (album_id IN (101))"]
+    a.first.instance_variable_get(:@albums).should be_a_kind_of(Array)
+    a.first.albums.length.should == 1
+    a.first.albums.first.should be_a_kind_of(EagerAlbum)
+    a.last.instance_variable_get(:@albums).should == []
+    a.last.albums.should == []
+    MODEL_DB.sqls.length.should == 3
+  end
+  
+  it "should use the association's block when eager loading by default" do
+    EagerAlbum.eager(:good_tracks).all
+    MODEL_DB.sqls.should == ['SELECT * FROM albums', "SELECT tracks.* FROM tracks WHERE ((album_id IN (1)) AND (name = 'Good'))"]
+  end
+
+  it "should use the eager_block option when eager loading if given" do
+    EagerBand.eager(:good_albums).all
+    MODEL_DB.sqls.should == ['SELECT * FROM bands', "SELECT albums.* FROM albums WHERE ((band_id IN (2)) AND (name = 'good'))"]
+    MODEL_DB.sqls.clear
+    EagerBand.eager(:good_albums=>:good_tracks).all
+    MODEL_DB.sqls.should == ['SELECT * FROM bands', "SELECT albums.* FROM albums WHERE ((band_id IN (2)) AND (name = 'good'))", "SELECT tracks.* FROM tracks WHERE ((album_id IN (1)) AND (name = 'Good'))"]
+  end
+
+  it "should raise an error when attempting to eagerly load an association with the :allow_eager option set to false" do
+    proc{EagerBand.eager(:self_titled_albums).all}.should raise_error(Sequel::Error)
+    proc{EagerBand.eager(:albums_by_name).all}.should raise_error(Sequel::Error)
+  end
+
+  it "should respect the association's :select option" do
+    EagerAlbum.eager(:band_name).all
+    MODEL_DB.sqls.should == ['SELECT * FROM albums', "SELECT id, name FROM bands WHERE (id IN (2))"]
+    MODEL_DB.sqls.clear
+    EagerAlbum.eager(:track_names).all
+    MODEL_DB.sqls.should == ['SELECT * FROM albums', "SELECT id, name FROM tracks WHERE (album_id IN (1))"]
+    MODEL_DB.sqls.clear
+    EagerAlbum.eager(:genre_names).all
+    MODEL_DB.sqls.should == ['SELECT * FROM albums', "SELECT id, ag.album_id AS x_foreign_key_x FROM genres INNER JOIN ag ON ((ag.genre_id = genres.id) AND (ag.album_id IN (1)))"]
+  end
 end
 
 describe Sequel::Model, "#eager_graph" do
@@ -540,10 +609,8 @@ describe Sequel::Model, "#eager_graph" do
     a.genres.size.should == 1
     a.genres.first.should be_a_kind_of(GraphGenre)
     a.genres.first.values.should == {:id=>6}
-    MODEL_DB.sqls[0].should == 'SELECT albums.id, albums.band_id, tracks.id AS tracks_id, tracks.album_id FROM albums LEFT OUTER JOIN tracks ON (tracks.album_id = albums.id)'
-    ["SELECT genres.*, ag.album_id AS x_foreign_key_x FROM genres INNER JOIN ag ON (ag.genre_id = genres.id) AND (ag.album_id IN (1))",
-     "SELECT genres.*, ag.album_id AS x_foreign_key_x FROM genres INNER JOIN ag ON (ag.album_id IN (1)) AND (ag.genre_id = genres.id)"
-    ].should(include(MODEL_DB.sqls[1]))
+    MODEL_DB.sqls.should == ['SELECT albums.id, albums.band_id, tracks.id AS tracks_id, tracks.album_id FROM albums LEFT OUTER JOIN tracks ON (tracks.album_id = albums.id)',
+    "SELECT genres.*, ag.album_id AS x_foreign_key_x FROM genres INNER JOIN ag ON ((ag.genre_id = genres.id) AND (ag.album_id IN (1)))"]
   end
 
   it "should handle no associated records for a single many_to_one association" do
@@ -645,4 +712,34 @@ describe Sequel::Model, "#eager_graph" do
     a[3].album.band.members.last.should be_a_kind_of(GraphBandMember)
     a[3].album.band.members.last.values.should == {:id => 6}
   end
+
+  it "should respect the association's :graph_join_type option" do 
+    GraphAlbum.many_to_one :inner_band, :class=>'GraphBand', :key=>:band_id, :graph_join_type=>:inner
+    GraphAlbum.eager_graph(:inner_band).sql.should == 'SELECT albums.id, albums.band_id, inner_band.id AS inner_band_id, inner_band.vocalist_id FROM albums INNER JOIN bands inner_band ON (inner_band.id = albums.band_id)'
+
+    GraphAlbum.one_to_many :right_tracks, :class=>'GraphTrack', :key=>:album_id, :graph_join_type=>:right_outer
+    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 RIGHT OUTER JOIN tracks right_tracks ON (right_tracks.album_id = albums.id)'
+
+    GraphAlbum.many_to_many :inner_genres, :class=>'GraphGenre', :left_key=>:album_id, :right_key=>:genre_id, :join_table=>:ag, :graph_join_type=>:inner
+    GraphAlbum.eager_graph(:inner_genres).sql.should == 'SELECT albums.id, albums.band_id, inner_genres.id AS inner_genres_id FROM albums INNER JOIN ag ON (ag.album_id = albums.id) INNER JOIN genres inner_genres ON (inner_genres.id = ag.genre_id)'
+  end
+
+  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 active_band ON ((active_band.id = albums.band_id) AND (active_band.active = 't'))"
+
+    GraphAlbum.many_to_many :active_genres, :class=>'GraphGenre', :left_key=>:album_id, :right_key=>:genre_id, :join_table=>:ag, :graph_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) LEFT OUTER JOIN genres active_genres ON ((active_genres.id = ag.genre_id) AND ('t' = ag.active))"
+
+    GraphAlbum.many_to_one :active_band, :class=>'GraphBand', :key=>:band_id, :graph_conditions=>{:id=>(0..100)}
+    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 active_band ON ((active_band.id = albums.band_id) AND ((active_band.id >= 0) AND (active_band.id <= 100)))"
+  end
+
+  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 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 active_genres ON ((active_genres.id = ag.genre_id) AND ('t' = ag.active))"
+  end
 end

data/spec/hooks_spec.rb

@@ -3,20 +3,6 @@ require File.join(File.dirname(__FILE__), "spec_helper")
 describe "Model hooks" do
   before do
     MODEL_DB.reset
-
-    @hooks = [
-      :after_initialize,
-      :before_create,
-      :after_create,
-      :before_update,
-      :after_update,
-      :before_save,
-      :after_save,
-      :before_destroy,
-      :after_destroy
-    ]
-    
-    # @hooks.each {|h| Sequel::Model.class_def(h) {}}
   end
   
   specify "should be definable using def <hook name>" do
@@ -60,6 +46,47 @@ describe "Model hooks" do
     c.new.before_save
     $adds.should == ['hyiyie', 'byiyie']
   end
+
+  specify "should not be additive if the method or tag already exists" do
+    $adds = []
+    c = Class.new(Sequel::Model) 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) 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) 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) do
+      def bye; $adds << 'bye'; end
+      before_save(:bye){$adds << 'byiyie'}
+      before_save :bye
+    end
+    
+    e.new.before_save
+    $adds.should == ['bye']
+  end
   
   specify "should be inheritable" do
     # pending
@@ -155,12 +182,12 @@ describe "Model#before_create && Model#after_create" do
       columns :x
       no_primary_key
       
-      before_create {MODEL_DB << "BLAH before"}
       after_create {MODEL_DB << "BLAH after"}
     end
   end
   
   specify "should be called around new record creation" do
+    @c.before_create {MODEL_DB << "BLAH before"}
     @c.create(:x => 2)
     MODEL_DB.sqls.should == [
       'BLAH before',
@@ -168,6 +195,12 @@ describe "Model#before_create && Model#after_create" do
       'BLAH after'
     ]
   end
+
+  specify "should cancel the save if before_create returns false" do
+    @c.before_create{false}
+    @c.create(:x => 2).should == false
+    MODEL_DB.sqls.should == []
+  end
 end
 
 describe "Model#before_update && Model#after_update" do
@@ -175,12 +208,12 @@ describe "Model#before_update && Model#after_update" do
     MODEL_DB.reset
 
     @c = Class.new(Sequel::Model(:items)) do
-      before_update {MODEL_DB << "BLAH before"}
       after_update {MODEL_DB << "BLAH after"}
     end
   end
   
   specify "should be called around record update" do
+    @c.before_update {MODEL_DB << "BLAH before"}
     m = @c.load(:id => 2233)
     m.save
     MODEL_DB.sqls.should == [
@@ -189,6 +222,12 @@ describe "Model#before_update && Model#after_update" do
       'BLAH after'
     ]
   end
+
+  specify "should cancel the save if before_update returns false" do
+    @c.before_update{false}
+    @c.load(:id => 2233).save.should == false
+    MODEL_DB.sqls.should == []
+  end
 end
 
 describe "Model#before_save && Model#after_save" do
@@ -221,6 +260,12 @@ describe "Model#before_save && Model#after_save" do
       'BLAH after'
     ]
   end
+
+  specify "should cancel the save if before_save returns false" do
+    @c.before_save{false}
+    @c.load(:id => 2233).save.should == false
+    MODEL_DB.sqls.should == ["BLAH before"]
+  end
 end
 
 describe "Model#before_destroy && Model#after_destroy" do
@@ -228,7 +273,6 @@ describe "Model#before_destroy && Model#after_destroy" do
     MODEL_DB.reset
 
     @c = Class.new(Sequel::Model(:items)) do
-      before_destroy {MODEL_DB << "BLAH before"}
       after_destroy {MODEL_DB << "BLAH after"}
       
       def delete
@@ -237,7 +281,8 @@ describe "Model#before_destroy && Model#after_destroy" do
     end
   end
   
-  specify "should be called around record update" do
+  specify "should be called around record destruction" do
+    @c.before_destroy {MODEL_DB << "BLAH before"}
     m = @c.new(:id => 2233)
     m.destroy
     MODEL_DB.sqls.should == [
@@ -246,11 +291,66 @@ describe "Model#before_destroy && Model#after_destroy" do
       'BLAH after'
     ]
   end
+
+  specify "should cancel the destroy if before_destroy returns false" do
+    @c.before_destroy{false}
+    @c.load(:id => 2233).destroy.should == false
+    MODEL_DB.sqls.should == []
+  end
+end
+
+describe "Model#before_validation && Model#after_validation" do
+  setup do
+    MODEL_DB.reset
+
+    @c = Class.new(Sequel::Model(:items)) do
+      before_validation{MODEL_DB << "BLAH before"}
+      after_validation{MODEL_DB << "BLAH after"}
+
+      def self.validate(o)
+        o.errors[:id] << 'not valid' unless o[:id] == 2233
+      end
+      
+      def save!(*columns)
+        MODEL_DB << "CREATE BLAH"
+        self
+      end
+      columns :id
+    end
+  end
+  
+  specify "should be called around validation" do
+    m = @c.new(:id => 2233)
+    m.should be_valid
+    MODEL_DB.sqls.should == ['BLAH before', 'BLAH after']
+
+    MODEL_DB.sqls.clear
+    m = @c.new(:id => 22)
+    m.should_not be_valid
+    MODEL_DB.sqls.should == ['BLAH before', 'BLAH after']
+  end
+
+  specify "should be called when calling save" do
+    m = @c.new(:id => 2233)
+    m.save.should == m
+    MODEL_DB.sqls.should == ['BLAH before', 'BLAH after', 'CREATE BLAH']
+
+    MODEL_DB.sqls.clear
+    m = @c.new(:id => 22)
+    m.save.should == false
+    MODEL_DB.sqls.should == ['BLAH before', 'BLAH after']
+  end
+
+  specify "should cancel the save if before_validation returns false" do
+    @c.before_validation{false}
+    @c.load(:id => 2233).save.should == false
+    MODEL_DB.sqls.should == ["BLAH before"]
+  end
 end
 
-describe "Model#has_hooks?" do
+describe "Model.has_hooks?" do
   setup do
-    @c = Class.new(Sequel::Model)
+    @c = Class.new(Sequel::Model(:items))
   end
   
   specify "should return false if no hooks are defined" do