sequel 4.49.0 → 5.0.0

data/spec/model/base_spec.rb

@@ -1,4 +1,4 @@
-require File.join(File.dirname(File.expand_path(__FILE__)), "spec_helper")
+require_relative "spec_helper"
 
 describe "Model attribute setters" do
   before do
@@ -118,72 +118,6 @@ describe Sequel::Model, "implicit table names" do
   end
 end
 
-describe Sequel::Model, ".def_dataset_method" do
-  before do
-    @c = Class.new(Sequel::Model(:items))
-  end
-  
-  deprecated "should add a method to the dataset and model if called with a block argument" do
-    @c.def_dataset_method(:return_3){3}
-    @c.return_3.must_equal 3
-    @c.dataset.return_3.must_equal 3
-  end
-
-  deprecated "should handle weird method names" do
-    @c.def_dataset_method(:"return 3"){3}
-    @c.send(:"return 3").must_equal 3
-    @c.dataset.send(:"return 3").must_equal 3
-  end
-
-  deprecated "should not add a model method if the model already responds to the method" do
-    @c.instance_eval do
-      def foo
-        1
-      end
-
-      private
-
-      def bar
-        2
-      end
-
-      def_dataset_method(:foo){3}
-      def_dataset_method(:bar){4}
-    end
-    @c.foo.must_equal 1
-    @c.dataset.foo.must_equal 3
-    @c.send(:bar).must_equal 2
-    @c.dataset.bar.must_equal 4
-  end
-
-  deprecated "should add all passed methods to the model if called without a block argument" do
-    @c.def_dataset_method(:return_3, :return_4)
-    proc{@c.return_3}.must_raise(NoMethodError)
-    proc{@c.return_4}.must_raise(NoMethodError)
-    @c.dataset = @c.dataset.with_extend do
-      def return_3; 3; end
-      def return_4; 4; end
-    end
-    @c.return_3.must_equal 3
-    @c.return_4.must_equal 4
-  end
-
-  deprecated "should cache calls and readd methods if set_dataset is used" do
-    @c.def_dataset_method(:return_3){3}
-    @c.set_dataset :items
-    @c.return_3.must_equal 3
-    @c.dataset.return_3.must_equal 3
-  end
-
-  deprecated "should readd methods to subclasses, if set_dataset is used in a subclass" do
-    @c.def_dataset_method(:return_3){3}
-    c = Class.new(@c)
-    c.set_dataset :items
-    c.return_3.must_equal 3
-    c.dataset.return_3.must_equal 3
-  end
-end
-
 describe Sequel::Model, ".dataset_module" do
   before do
     @c = Class.new(Sequel::Model(:items))
@@ -209,6 +143,11 @@ describe Sequel::Model, ".dataset_module" do
     @c.return_3.must_equal 3
   end
 
+  it "should add methods that can't be called with normal method syntax as class methods" do
+    @c.dataset_module.module_eval{define_method(:'return 3'){3}}
+    @c.send(:'return 3').must_equal 3
+  end
+
   it "should not add private or protected methods defined in the module to the class" do
     @c.dataset_module{private; def return_3() 3 end}
     @c.dataset_module{protected; def return_4() 4 end}
@@ -565,59 +504,21 @@ describe "Model.db=" do
   before do
     @db1 = Sequel.mock
     @db2 = Sequel.mock
-    
-    @m = Class.new(Sequel::Model(@db1[:blue].filter(:x=>1)))
+    @m = Class.new(Sequel::Model(@db1))
   end
   
-  deprecated "should affect the underlying dataset" do
+  it "should change database for model" do
     @m.db = @db2
-    
-    @m.dataset.db.must_equal @db2
-    @m.dataset.db.wont_equal @db1
+    @m.db.must_equal @db2
   end
 
-  deprecated "should keep the same dataset options" do
-    @m.db = @db2
-    @m.dataset.sql.must_equal 'SELECT * FROM blue WHERE (x = 1)'
+  it "should raise Error for model with existing dataset" do
+    @m.dataset = :table
+    proc{@m.db = @db2}.must_raise Sequel::Error
   end
 
   it "should use the database for subclasses" do
-    @m = Class.new(Sequel::Model)
-    @m.db = @db2
-    Class.new(@m).db.must_equal @db2
-  end
-end
-
-describe Sequel::Model, ".allowed_columns " do
-  before do
-    @c = Class.new(Sequel::Model(:blahblah)) do
-      columns :x, :y, :z
-    end
-    @c.strict_param_setting = false
-    @c.instance_variable_set(:@columns, [:x, :y, :z])
-    DB.reset
-  end
-  
-  deprecated "should set the allowed columns correctly" do
-    @c.allowed_columns.must_be_nil
-    @c.set_allowed_columns :x
-    @c.allowed_columns.must_equal [:x]
-    @c.set_allowed_columns :x, :y
-    @c.allowed_columns.must_equal [:x, :y]
-  end
-
-  deprecated "should only set allowed columns by default" do
-    @c.set_allowed_columns :x, :y
-    i = @c.new(:x => 1, :y => 2, :z => 3)
-    i.values.must_equal(:x => 1, :y => 2)
-    i.set(:x => 4, :y => 5, :z => 6)
-    i.values.must_equal(:x => 4, :y => 5)
-
-    @c.dataset = @c.dataset.with_fetch(:x => 7)
-    i = @c.new
-    i.update(:x => 7, :z => 9)
-    i.values.must_equal(:x => 7)
-    DB.sqls.must_equal ["INSERT INTO blahblah (x) VALUES (7)", "SELECT * FROM blahblah WHERE id = 10"]
+    Class.new(@m).db.must_equal @db1
   end
 end
 
@@ -676,13 +577,6 @@ describe Sequel::Model, ".strict_param_setting" do
     c = @c.new
     proc{c.set(:a=>1)}.must_raise(Sequel::MassAssignmentRestriction)
     proc{c.update(:a=>1)}.must_raise(Sequel::MassAssignmentRestriction)
-    deprecated do
-      @c.set_allowed_columns :x, :y
-      proc{c.set_all(:use_after_commit_rollback => false)}.must_raise(Sequel::MassAssignmentRestriction)
-      proc{c.set_only({:x=>1}, :y)}.must_raise(Sequel::MassAssignmentRestriction)
-      proc{c.update_all(:use_after_commit_rollback=>false)}.must_raise(Sequel::MassAssignmentRestriction)
-      proc{c.update_only({:x=>1}, :y)}.must_raise(Sequel::MassAssignmentRestriction)
-    end
   end
 
   it "should be disabled by strict_param_setting = false" do
@@ -835,16 +729,10 @@ describe "Model datasets #with_pk with #with_pk!" do
   it "should handle an array for composite primary keys" do
     @c.set_primary_key [:id1, :id2]
     @ds.with_pk([1, 2])
-    sqls = DB.sqls
-    ["SELECT * FROM a WHERE ((a.id1 = 1) AND (a.id2 = 2)) LIMIT 1",
-    "SELECT * FROM a WHERE ((a.id2 = 2) AND (a.id1 = 1)) LIMIT 1"].must_include(sqls.pop)
-    sqls.must_equal []
+    DB.sqls.must_equal ["SELECT * FROM a WHERE ((a.id1 = 1) AND (a.id2 = 2)) LIMIT 1"]
 
     @ds.with_pk!([1, 2])
-    sqls = DB.sqls
-    ["SELECT * FROM a WHERE ((a.id1 = 1) AND (a.id2 = 2)) LIMIT 1",
-    "SELECT * FROM a WHERE ((a.id2 = 2) AND (a.id1 = 1)) LIMIT 1"].must_include(sqls.pop)
-    sqls.must_equal []
+    DB.sqls.must_equal ["SELECT * FROM a WHERE ((a.id1 = 1) AND (a.id2 = 2)) LIMIT 1"]
   end
 
   it "should work with composite primary keys when called repeatedly on a frozen dataset with" do
@@ -852,10 +740,7 @@ describe "Model datasets #with_pk with #with_pk!" do
     @ds.freeze
     5.times do
       @ds.with_pk([1,2])
-      sqls = DB.sqls
-      ["SELECT * FROM a WHERE ((a.id1 = 1) AND (a.id2 = 2)) LIMIT 1",
-      "SELECT * FROM a WHERE ((a.id2 = 2) AND (a.id1 = 1)) LIMIT 1"].must_include(sqls.pop)
-      sqls.must_equal []
+      DB.sqls.must_equal ["SELECT * FROM a WHERE ((a.id1 = 1) AND (a.id2 = 2)) LIMIT 1"]
     end
   end
 
@@ -880,11 +765,6 @@ describe "Model datasets #with_pk with #with_pk!" do
     DB.sqls.must_equal ["SELECT * FROM a WHERE (a.id = 1) LIMIT 1"]
   end
 
-  deprecated "should not have #[] consider a string as a primary key lookup" do
-    @ds['foo'].must_equal @c.load(:id=>1)
-    DB.sqls.must_equal ["SELECT * FROM a WHERE (foo) LIMIT 1"]
-  end
-
   it "should not have #[] consider a literal string as a primary key lookup" do
     @ds[Sequel.lit('foo')].must_equal @c.load(:id=>1)
     DB.sqls.must_equal ["SELECT * FROM a WHERE (foo) LIMIT 1"]
@@ -906,6 +786,7 @@ describe "Model::include" do
     including_class = Class.new(Sequel::Model(:items)) do
       include(mod1, mod2)
     end
-    including_class.included_modules.must_include(mod1, mod2)
+    including_class.included_modules.must_include(mod1)
+    including_class.included_modules.must_include(mod2)
   end
 end

data/spec/model/class_dataset_methods_spec.rb

@@ -1,4 +1,4 @@
-require File.join(File.dirname(File.expand_path(__FILE__)), "spec_helper")
+require_relative "spec_helper"
 
 describe Sequel::Model, "class dataset methods"  do
   before do
@@ -9,10 +9,6 @@ describe Sequel::Model, "class dataset methods"  do
   end
 
   it "should call the dataset method of the same name with the same args" do
-    deprecated do
-      @c.<<({}).must_equal @d
-    end
-    @db.sqls.must_equal ["INSERT INTO items DEFAULT VALUES"]
     @c.all.must_equal [@c.load(:id=>1)]
     @db.sqls.must_equal ["SELECT * FROM items"]
     @c.avg(:id).must_equal 1
@@ -29,9 +25,6 @@ describe Sequel::Model, "class dataset methods"  do
     @c.except(@d, :from_self=>false).sql.must_equal "SELECT * FROM items EXCEPT SELECT * FROM items"
     @c.exclude(:a).sql.must_equal "SELECT * FROM items WHERE NOT a"
     @c.exclude_having(:a).sql.must_equal "SELECT * FROM items HAVING NOT a"
-    deprecated do
-      @c.exclude_where(:a).sql.must_equal "SELECT * FROM items WHERE NOT a"
-    end
     @c.fetch_rows("S"){|r| r.must_equal(:id=>1)}
     @db.sqls.must_equal ["S"]
     @c.filter(:a).sql.must_equal "SELECT * FROM items WHERE a"
@@ -57,13 +50,9 @@ describe Sequel::Model, "class dataset methods"  do
     @c.import([:id], [[1]])
     @db.sqls.must_equal ["BEGIN", "INSERT INTO items (id) VALUES (1)", "COMMIT"]
     @c.inner_join(@c.table_name).sql.must_equal "SELECT * FROM items INNER JOIN items"
-    @c.insert.must_equal 2
+    @c.insert.must_equal 1
     @db.sqls.must_equal ["INSERT INTO items DEFAULT VALUES"]
     @c.intersect(@d, :from_self=>false).sql.must_equal "SELECT * FROM items INTERSECT SELECT * FROM items"
-    deprecated do
-      @c.interval(:id).must_equal 1
-    end
-    @db.sqls.must_equal ["SELECT (max(id) - min(id)) AS interval FROM items LIMIT 1"]
     @c.join(@c.table_name).sql.must_equal "SELECT * FROM items INNER JOIN items"
     @c.join_table(:inner, @c.table_name).sql.must_equal "SELECT * FROM items INNER JOIN items"
     @c.last.must_equal @c.load(:id=>1)
@@ -109,9 +98,6 @@ describe Sequel::Model, "class dataset methods"  do
     @c.select_order_map(:id).must_equal [1]
     @db.sqls.must_equal ["SELECT id FROM items ORDER BY id"]
     @c.server(:a).opts[:server].must_equal :a
-    deprecated do
-      @c.set_graph_aliases(:a=>:b).opts[:graph_aliases].must_equal(:a=>[:b, :a])
-    end
     @c.single_record.must_equal @c.load(:id=>1)
     @db.sqls.must_equal ["SELECT * FROM items LIMIT 1"]
     @c.single_record!.must_equal @c.load(:id=>1)
@@ -148,10 +134,6 @@ describe Sequel::Model, "class dataset methods"  do
     sc.invert.sql.must_equal 'SELECT a FROM items WHERE NOT a GROUP BY a ORDER BY a LIMIT 2'
     sc.dataset = sc.dataset.with_fetch(:v1=>1, :v2=>2)
     @db.sqls
-    deprecated do
-      sc.range(:a).must_equal(1..2)
-    end
-    @db.sqls.must_equal ["SELECT min(a) AS v1, max(a) AS v2 FROM (SELECT a FROM items WHERE a GROUP BY a ORDER BY a LIMIT 2) AS t1 LIMIT 1"]
     sc.reverse.sql.must_equal 'SELECT a FROM items WHERE a GROUP BY a ORDER BY a DESC LIMIT 2'
     sc.reverse_order.sql.must_equal 'SELECT a FROM items WHERE a GROUP BY a ORDER BY a DESC LIMIT 2'
     sc.select_more(:a).sql.must_equal 'SELECT a, a FROM items WHERE a GROUP BY a ORDER BY a LIMIT 2'

data/spec/model/dataset_methods_spec.rb

@@ -1,4 +1,4 @@
-require File.join(File.dirname(File.expand_path(__FILE__)), "spec_helper")
+require_relative "spec_helper"
 
 describe Sequel::Model::DatasetMethods, "#destroy"  do
   before do
@@ -86,24 +86,6 @@ describe Sequel::Model::DatasetMethods  do
     @c.db.reset
   end
 
-  deprecated "#join_table should allow use to use a model class when joining" do
-    @c.join(Class.new(Sequel::Model(:categories)), :item_id => :id).sql.must_equal 'SELECT * FROM items INNER JOIN categories ON (categories.item_id = items.id)'
-  end
-
-  deprecated "#join_table should handle model classes that aren't simple selects using a subselect" do
-    @c.join(Class.new(Sequel::Model(DB[:categories].where(:foo=>1))), :item_id => :id).sql.must_equal 'SELECT * FROM items INNER JOIN (SELECT * FROM categories WHERE (foo = 1)) AS t1 ON (t1.item_id = items.id)'
-  end
-
-  deprecated "#graph should allow use to use a model class when joining" do
-    c = Class.new(Sequel::Model(:categories))
-    c.columns :id
-    @c.graph(c, :item_id => :id).sql.must_equal 'SELECT items.id, categories.id AS categories_id FROM items LEFT OUTER JOIN categories ON (categories.item_id = items.id)'
-  end
-
-  deprecated "#insert_sql should handle a single model instance as an argument" do
-    @c.dataset.insert_sql(@c.load(:id=>1)).must_equal 'INSERT INTO items (id) VALUES (1)'
-  end
-
   it "#first should handle no primary key" do
     @c.no_primary_key
     @c.first.must_be_kind_of(@c)
@@ -209,7 +191,6 @@ describe Sequel::Model::DatasetMethods, "#where_single_value"  do
 
   it "should return single value" do
     5.times do
-      a = []
       @c.only_id.where_single_value(:id=>1).must_equal 1
       @c.db.sqls.must_equal ['SELECT id FROM items WHERE (id = 1) LIMIT 1']
     end

data/spec/model/eager_loading_spec.rb

@@ -1,4 +1,4 @@
-require File.join(File.dirname(File.expand_path(__FILE__)), "spec_helper")
+require_relative "spec_helper"
 
 describe Sequel::Model, "#eager" do
   before do
@@ -1483,20 +1483,26 @@ describe Sequel::Model, "#eager_graph" do
     a.first.lgenre.must_equal sub.load(:id => 4)
   end
   
-  it "should correctly handle an aliased join table in many_to_many and one_through_one with conditions" do
+  it "should correctly handle an aliased join table in many_to_many and one_through_one with graph_conditions or graph_block" do
     c = Class.new(GraphAlbum)
-    c.many_to_many :genres, :clone=>:genres, :join_table=>Sequel[:ag].as(:ga), :conditions=>'true', :ignore_conditions_warning=> true
-    c.eager_graph(:genres).sql.must_equal 'SELECT albums.id, albums.band_id, genres.id AS genres_id FROM albums LEFT OUTER JOIN ag AS ga ON (ga.album_id = albums.id) LEFT OUTER JOIN genres ON (genres.id = ga.genre_id)'
-    c.many_to_many :genres, :clone=>:genres, :join_table=>Sequel[:ag].as(:ga), :conditions=>'true', :graph_block => proc{true}
-    c.eager_graph(:genres).sql.must_equal 'SELECT albums.id, albums.band_id, genres.id AS genres_id FROM albums LEFT OUTER JOIN ag AS ga ON (ga.album_id = albums.id) LEFT OUTER JOIN genres ON ((genres.id = ga.genre_id) AND \'t\')'
+    c.many_to_many :genres, :clone=>:genres, :join_table=>Sequel[:ag].as(:ga), :graph_conditions=>{:a=>:b}
+    c.eager_graph(:genres).sql.must_equal 'SELECT albums.id, albums.band_id, genres.id AS genres_id FROM albums LEFT OUTER JOIN ag AS ga ON (ga.album_id = albums.id) LEFT OUTER JOIN genres ON ((genres.id = ga.genre_id) AND (genres.a = ga.b))'
+    c.many_to_many :genres, :clone=>:genres, :join_table=>Sequel[:ag].as(:ga), :graph_block => proc{true}
+    c.eager_graph(:genres).sql.must_equal 'SELECT albums.id, albums.band_id, genres.id AS genres_id FROM albums LEFT OUTER JOIN ag AS ga ON (ga.album_id = albums.id) LEFT OUTER JOIN genres ON ((genres.id = ga.genre_id) AND (genres.a = ga.b) AND \'t\')'
   end
 
-  with_symbol_splitting "should correctly handle an aliased join table symbol in many_to_many and one_through_one with conditions" do
+  with_symbol_splitting "should correctly handle an aliased join table symbol in many_to_many and one_through_one with graph_conditions or graph_block" do
     c = Class.new(GraphAlbum)
-    c.many_to_many :genres, :clone=>:genres, :join_table=>:ag___ga, :conditions=>'true', :ignore_conditions_warning=> true
-    c.eager_graph(:genres).sql.must_equal 'SELECT albums.id, albums.band_id, genres.id AS genres_id FROM albums LEFT OUTER JOIN ag AS ga ON (ga.album_id = albums.id) LEFT OUTER JOIN genres ON (genres.id = ga.genre_id)'
-    c.many_to_many :genres, :clone=>:genres, :join_table=>:ag___ga, :conditions=>'true', :graph_block => proc{true}
-    c.eager_graph(:genres).sql.must_equal 'SELECT albums.id, albums.band_id, genres.id AS genres_id FROM albums LEFT OUTER JOIN ag AS ga ON (ga.album_id = albums.id) LEFT OUTER JOIN genres ON ((genres.id = ga.genre_id) AND \'t\')'
+    c.many_to_many :genres, :clone=>:genres, :join_table=>:ag___ga, :graph_conditions=>{:a=>:b}
+    c.eager_graph(:genres).sql.must_equal 'SELECT albums.id, albums.band_id, genres.id AS genres_id FROM albums LEFT OUTER JOIN ag AS ga ON (ga.album_id = albums.id) LEFT OUTER JOIN genres ON ((genres.id = ga.genre_id) AND (genres.a = ga.b))'
+    c.many_to_many :genres, :clone=>:genres, :join_table=>:ag___ga, :graph_block => proc{true}
+    c.eager_graph(:genres).sql.must_equal 'SELECT albums.id, albums.band_id, genres.id AS genres_id FROM albums LEFT OUTER JOIN ag AS ga ON (ga.album_id = albums.id) LEFT OUTER JOIN genres ON ((genres.id = ga.genre_id) AND (genres.a = ga.b) AND \'t\')'
+  end
+
+  it "should raise Error when using eager_graph with :conditions option that isn't a conditions specifier" do
+    c = Class.new(GraphAlbum)
+    c.many_to_many :genres, :clone=>:genres, :join_table=>Sequel[:ag].as(:ga), :conditions=>'true'
+    proc{c.eager_graph(:genres)}.must_raise Sequel::Error
   end
 
   with_symbol_splitting "should correctly handle an aliased join table symbol in many_to_many and one_through_one" do

data/spec/model/hooks_spec.rb

@@ -1,4 +1,4 @@
-require File.join(File.dirname(File.expand_path(__FILE__)), "spec_helper")
+require_relative "spec_helper"
 
 describe "Model#before_create && Model#after_create" do
   before do
@@ -17,14 +17,7 @@ describe "Model#before_create && Model#after_create" do
   it "should be called around new record creation" do
     @c.send(:define_method, :before_create){DB << "BLAH before"}
     @c.create(:x => 2)
-    DB.sqls.must_equal ['BLAH before', 'INSERT INTO items (x) VALUES (2)', 'BLAH after', 'SELECT * FROM items WHERE x = 2']
-  end
-
-  deprecated ".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.create(:x => 2)}.must_raise(Sequel::HookFailed)
-    DB.sqls.must_equal []
-    @c.load(:id => 2233).save
+    DB.sqls.must_equal ['BLAH before', 'INSERT INTO items (x) VALUES (2)', 'SELECT * FROM items WHERE x = 2', 'BLAH after']
   end
 
   it ".create should cancel the save and raise an error if before_create calls cancel_action and raise_on_save_failure is true" do
@@ -34,13 +27,6 @@ describe "Model#before_create && Model#after_create" do
     @c.load(:id => 2233).save
   end
 
-  deprecated ".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).must_be_nil
-    DB.sqls.must_equal []
-  end
-
   it ".create should cancel the save and return nil if before_create calls cancel_action and raise_on_save_failure is false" do
     @c.send(:define_method, :before_create){cancel_action}
     @c.raise_on_save_failure = false
@@ -67,32 +53,12 @@ describe "Model#before_update && Model#after_update" do
     DB.sqls.must_equal ['BLAH before', 'UPDATE items SET x = 123 WHERE (id = 2233)', 'BLAH after']
   end
 
-  deprecated "#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}.must_raise(Sequel::HookFailed)
-    DB.sqls.must_equal []
-  end
-
   it "#save should cancel the save and raise an error if before_update calls cancel_action and raise_on_save_failure is true" do
     @c.send(:define_method, :before_update){cancel_action}
     proc{@c.load(:id => 2233).save}.must_raise(Sequel::HookFailed)
     DB.sqls.must_equal []
   end
 
-  deprecated "#save should cancel the save and raise an error if before_update returns false and raise_on_failure option is true" do
-    @c.send(:define_method, :before_update){false}
-    @c.raise_on_save_failure = false
-    proc{@c.load(:id => 2233).save(:raise_on_failure => true)}.must_raise(Sequel::HookFailed)
-    DB.sqls.must_equal []
-  end
-
-  deprecated "#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.must_be_nil
-    DB.sqls.must_equal []
-  end
-
   it "#save should cancel the save and return nil if before_update calls cancel_action and raise_on_save_failure is false" do
     @c.send(:define_method, :before_update){cancel_action}
     @c.raise_on_save_failure = false
@@ -124,20 +90,7 @@ describe "Model#before_save && Model#after_save" do
     @c.set_primary_key :x
     @c.unrestrict_primary_key
     @c.create(:x => 2)
-    DB.sqls.must_equal ['BLAH before', 'INSERT INTO items (x) VALUES (2)', 'BLAH after', 'SELECT * FROM items WHERE x = 2']
-  end
-
-  deprecated "#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}.must_raise(Sequel::HookFailed)
-    DB.sqls.must_equal []
-  end
-
-  deprecated "#save should cancel the save and raise an error if before_save returns false and raise_on_failure option is true" do
-    @c.send(:define_method, :before_save){false}
-    @c.raise_on_save_failure = false
-    proc{@c.load(:id => 2233).save(:raise_on_failure => true)}.must_raise(Sequel::HookFailed)
-    DB.sqls.must_equal []
+    DB.sqls.must_equal ['BLAH before', 'INSERT INTO items (x) VALUES (2)', 'SELECT * FROM items WHERE x = 2', 'BLAH after']
   end
 
   it "#save should cancel the save and raise an error if before_save calls cancel_action and raise_on_failure option is true" do
@@ -147,13 +100,6 @@ describe "Model#before_save && Model#after_save" do
     DB.sqls.must_equal []
   end
 
-  deprecated "#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.must_be_nil
-    DB.sqls.must_equal []
-  end
-
   it "#save should cancel the save and return nil if before_save calls cancel_action and raise_on_save_failure is false" do
     @c.send(:define_method, :before_save){cancel_action}
     @c.raise_on_save_failure = false
@@ -185,32 +131,12 @@ describe "Model#before_destroy && Model#after_destroy" do
     DB.sqls.must_equal ['BLAH before', 'DELETE FROM items WHERE id = 2233', 'BLAH after']
   end
 
-  deprecated "#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}.must_raise(Sequel::HookFailed)
-    DB.sqls.must_equal []
-  end
-
   it "#destroy should cancel the destroy and raise an error if before_destroy calls cancel_action and raise_on_save_failure is true" do
     @c.send(:define_method, :before_destroy){cancel_action; true}
     proc{@c.load(:id => 2233).destroy}.must_raise(Sequel::HookFailed)
     DB.sqls.must_equal []
   end
 
-  deprecated "#destroy should cancel the destroy and raise an error if before_destroy returns false and raise_on_failure option is true" do
-    @c.send(:define_method, :before_destroy){false}
-    @c.raise_on_save_failure = false
-    proc{@c.load(:id => 2233).destroy(:raise_on_failure => true)}.must_raise(Sequel::HookFailed)
-    DB.sqls.must_equal []
-  end
-
-  deprecated "#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.must_be_nil
-    DB.sqls.must_equal []
-  end
-
   it "#destroy should cancel the destroy and return nil if before_destroy calls cancel_action and raise_on_save_failure is false" do
     @c.send(:define_method, :before_destroy){cancel_action; true}
     @c.raise_on_save_failure = false
@@ -257,32 +183,12 @@ describe "Model#before_validation && Model#after_validation" do
     DB.sqls.must_equal ['BLAH before', 'BLAH after']
   end
 
-  deprecated "#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}.must_raise(Sequel::HookFailed)
-    DB.sqls.must_equal []
-  end
-
-  deprecated "#save should cancel the save and raise an error if before_validation returns false and raise_on_failure option is true" do
-    @c.send(:define_method, :before_validation){false}
-    @c.raise_on_save_failure = false
-    proc{@c.load(:id => 2233).save(:raise_on_failure => true)}.must_raise(Sequel::HookFailed)
-    DB.sqls.must_equal []
-  end
-  
   it "#save should cancel the save and raise an error if before_validation calls cancel_action and raise_on_save_failure is true" do
     @c.send(:define_method, :before_validation){cancel_action}
     proc{@c.load(:id => 2233).save}.must_raise(Sequel::HookFailed)
     DB.sqls.must_equal []
   end
 
-  deprecated "#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.must_be_nil
-    DB.sqls.must_equal []
-  end
-
   it "#save should cancel the save and return nil if before_validation calls cancel_action and raise_on_save_failure is false" do
     @c.send(:define_method, :before_validation){cancel_action}
     @c.raise_on_save_failure = false
@@ -294,11 +200,6 @@ describe "Model#before_validation && Model#after_validation" do
     @c.send(:define_method, :before_validation){cancel_action}
     @c.load(:id => 2233).valid?.must_equal false
   end
-  
-  deprecated "#valid? should return false if before_validation returns false" do
-    @c.send(:define_method, :before_validation){false}
-    @c.load(:id => 2233).valid?.must_equal false
-  end
 end
 
 describe "Model around filters" do
@@ -318,7 +219,7 @@ describe "Model around filters" do
       end
     end
     @c.create(:x => 2)
-    DB.sqls.must_equal ['ac_before', 'INSERT INTO items (x) VALUES (2)', 'ac_after', "SELECT * FROM items WHERE id = 10"]
+    DB.sqls.must_equal ['ac_before', 'INSERT INTO items (x) VALUES (2)', "SELECT * FROM items WHERE id = 10", 'ac_after']
   end
 
   it "around_delete should be called around record destruction" do
@@ -364,7 +265,7 @@ describe "Model around filters" do
       end
     end
     @c.create(:x => 2)
-    DB.sqls.must_equal ['as_before', 'ac_before', 'INSERT INTO items (x) VALUES (2)', 'ac_after', 'as_after', "SELECT * FROM items WHERE id = 10"]
+    DB.sqls.must_equal ['as_before', 'ac_before', 'INSERT INTO items (x) VALUES (2)', "SELECT * FROM items WHERE id = 10", 'ac_after', 'as_after']
     @c.load(:id=>1, :x => 2).save
     DB.sqls.must_equal ['as_before', 'au_before', 'UPDATE items SET x = 2 WHERE (id = 1)', 'au_after', 'as_after']
   end
@@ -467,199 +368,3 @@ describe "Model around filters" do
     o.save.must_be_nil
   end
 end
-
-describe "Model#after_commit and #after_rollback" do
-  before do
-    @db = Sequel.mock(:servers=>{:test=>{}})
-    @m = Class.new(Sequel::Model(@db[:items])) do
-      attr_accessor :rb
-      def _delete
-      end
-      def after_save
-        db.execute('as')
-        raise Sequel::Rollback if rb
-      end
-      def after_commit
-        db.execute('ac')
-      end
-      def after_rollback
-        db.execute('ar')
-      end
-      def after_destroy
-        db.execute('ad')
-        raise Sequel::Rollback if rb
-      end
-      def after_destroy_commit
-        db.execute('adc')
-      end
-      def after_destroy_rollback
-        db.execute('adr')
-      end
-    end
-    @m.use_transactions = true
-    @o = @m.load({})
-    @db.sqls
-  end
-
-  deprecated "should call after_commit for save after the transaction commits if it commits" do
-    @o.save
-    @db.sqls.must_equal ['BEGIN', 'as', 'COMMIT', 'ac']
-  end
-
-  deprecated "should call after_rollback for save after the transaction rolls back if it rolls back" do
-    @o.rb = true
-    @o.save
-    @db.sqls.must_equal ['BEGIN', 'as', 'ROLLBACK', 'ar']
-  end
-
-  deprecated "should have after_commit respect any surrounding transactions" do
-    @db.transaction do
-      @o.save
-    end
-    @db.sqls.must_equal ['BEGIN', 'as', 'COMMIT', 'ac']
-  end
-
-  deprecated "should have after_rollback respect any surrounding transactions" do
-    @db.transaction do
-      @o.rb = true
-      @o.save
-    end
-    @db.sqls.must_equal ['BEGIN', 'as', 'ROLLBACK', 'ar']
-  end
-
-  deprecated "should have after_commit work with surrounding transactions and sharding" do
-    @db.transaction(:server=>:test) do
-      @o.save
-    end
-    @db.sqls.must_equal ['BEGIN -- test', 'BEGIN', 'as', 'COMMIT', 'ac', 'COMMIT -- test']
-  end
-
-  deprecated "should have after_rollback work with surrounding transactions and sharding" do
-    @db.transaction(:server=>:test) do
-      @o.rb = true
-      @o.save
-    end
-    @db.sqls.must_equal ['BEGIN -- test', 'BEGIN', 'as', 'ROLLBACK', 'ar', 'COMMIT -- test']
-  end
-
-  deprecated "should call after_destroy_commit for destroy after the transaction commits if it commits" do
-    @o.destroy
-    @db.sqls.must_equal ['BEGIN', 'ad', 'COMMIT', 'adc']
-  end
-
-  deprecated "should call after_destroy_rollback for destroy after the transaction rolls back if it rolls back" do
-    @o.rb = true
-    @o.destroy
-    @db.sqls.must_equal ['BEGIN', 'ad', 'ROLLBACK', 'adr']
-  end
-
-  deprecated "should have after_destroy_commit respect any surrounding transactions" do
-    @db.transaction do
-      @o.destroy
-    end
-    @db.sqls.must_equal ['BEGIN', 'ad', 'COMMIT', 'adc']
-  end
-
-  deprecated "should have after_destroy_rollback respect any surrounding transactions" do
-    @db.transaction do
-      @o.rb = true
-      @o.destroy
-    end
-    @db.sqls.must_equal ['BEGIN', 'ad', 'ROLLBACK', 'adr']
-  end
-
-  deprecated "should have after_destroy commit work with surrounding transactions and sharding" do
-    @db.transaction(:server=>:test) do
-      @o.destroy
-    end
-    @db.sqls.must_equal ['BEGIN -- test', 'BEGIN', 'ad', 'COMMIT', 'adc', 'COMMIT -- test']
-  end
-
-  deprecated "should have after_destroy_rollback work with surrounding transactions and sharding" do
-    @db.transaction(:server=>:test) do
-      @o.rb = true
-      @o.destroy
-    end
-    @db.sqls.must_equal ['BEGIN -- test', 'BEGIN', 'ad', 'ROLLBACK', 'adr', 'COMMIT -- test']
-  end
-
-  deprecated "should not call after_commit if use_after_commit_rollback is false" do
-    @o.use_after_commit_rollback = false
-    @o.save
-    @db.sqls.must_equal ['BEGIN', 'as', 'COMMIT']
-  end
-
-  deprecated "should not call after_rollback if use_after_commit_rollback is false" do
-    @o.use_after_commit_rollback = false
-    @o.rb = true
-    @o.save
-    @db.sqls.must_equal ['BEGIN', 'as', 'ROLLBACK']
-  end
-
-  deprecated "should not call after_destroy_commit if use_after_commit_rollback is false" do
-    @o.use_after_commit_rollback = false
-    @o.destroy
-    @db.sqls.must_equal ['BEGIN', 'ad', 'COMMIT']
-  end
-
-  deprecated "should not call after_destroy_rollback for save if use_after_commit_rollback is false" do
-    @o.use_after_commit_rollback = false
-    @o.rb = true
-    @o.destroy
-    @db.sqls.must_equal ['BEGIN', 'ad', 'ROLLBACK']
-  end
-
-  deprecated "should handle use_after_commit_rollback at the class level" do
-    @m.use_after_commit_rollback = false
-    @o.save
-    @db.sqls.must_equal ['BEGIN', 'as', 'COMMIT']
-  end
-
-  deprecated "should handle use_after_commit_rollback when subclassing" do
-    @m.use_after_commit_rollback = false
-    o = Class.new(@m).load({})
-    @db.sqls
-    o.save
-    @db.sqls.must_equal ['BEGIN', 'as', 'COMMIT']
-  end
-
-  deprecated "should handle use_after_commit_rollback when subclassing after loading" do
-    @m = Class.new(Sequel::Model(@db[:items]))
-    @m.use_transactions = true
-    o = @m.load({})
-    @db.sqls
-    o.save
-    @db.sqls.must_equal ['BEGIN', 'COMMIT']
-
-    c = Class.new(@m)
-    o = c.load({})
-    def o.after_commit; db.execute 'ac' end
-    @db.sqls
-    o.save
-    @db.sqls.must_equal ['BEGIN', 'COMMIT', 'ac']
-
-    o = c.load({})
-    @db.sqls
-    o.save
-    @db.sqls.must_equal ['BEGIN', 'COMMIT']
-
-    c.send(:define_method, :after_commit){db.execute 'ac'}
-    o = c.load({})
-    @db.sqls
-    o.save
-    @db.sqls.must_equal ['BEGIN', 'COMMIT', 'ac']
-
-    c = Class.new(@m)
-    c.send(:include, Module.new{def after_commit; db.execute 'ac'; end})
-    o = c.load({})
-    @db.sqls
-    o.save
-    @db.sqls.must_equal ['BEGIN', 'COMMIT', 'ac']
-
-    c.use_after_commit_rollback = false
-    o = c.load({})
-    @db.sqls
-    o.save
-    @db.sqls.must_equal ['BEGIN', 'COMMIT']
-  end
-end