sequel 5.28.0 → 5.33.0

data/spec/extensions/input_transformer_spec.rb

@@ -1,69 +0,0 @@
-require_relative "spec_helper"
-
-describe "Sequel::Plugins::InputTransformer" do
-  before do
-    @c = Class.new(Sequel::Model)
-    @c.columns :name, :b
-    @c.plugin(:input_transformer, :reverser){|v| v.is_a?(String) ? v.reverse : v}
-    @o = @c.new
-  end
-
-  it "should apply transformation to input" do
-    @o.name = ' name '
-    @o.name.must_equal ' eman '
-    @o.name = [1, 2, 3]
-    @o.name.must_equal [1, 2, 3]
-  end
-
-  it "should have working .input_transformer_order" do
-    @c.input_transformer_order.must_equal [:reverser]
-    @c.plugin(:input_transformer, :reverser2){|v| v.is_a?(String) ? v.reverse : v}
-    @c.input_transformer_order.must_equal [:reverser2, :reverser]
-  end
-
-  it "should not apply any transformers by default" do
-    c = Class.new(Sequel::Model)
-    c.columns :name, :b
-    c.plugin :input_transformer
-    c.new(:name => ' name ').name.must_equal ' name '
-  end
-
-  it "should allow skipping of columns using .skip_input_transformer" do
-    @c.skip_input_transformer :reverser, :name
-    v = ' name '
-    @o.name = v
-    @o.name.must_be_same_as(v)
-  end
-
-  it "should work correctly in subclasses" do
-    o = Class.new(@c).new
-    o.name = ' name '
-    o.name.must_equal ' eman '
-  end
-
-  it "should raise an error if adding input filter without name" do
-    proc{@c.add_input_transformer(nil){}}.must_raise(Sequel::Error)
-    proc{@c.plugin(:input_transformer){}}.must_raise(Sequel::Error)
-  end
-
-  it "should raise an error if adding input filter without block" do
-    proc{@c.add_input_transformer(:foo)}.must_raise(Sequel::Error)
-    proc{@c.plugin(:input_transformer, :foo)}.must_raise(Sequel::Error)
-  end
-
-  it "should apply multiple input transformers in reverse order of their call" do
-    @c.add_input_transformer(:add_bar){|v| v << 'bar'}
-    @c.add_input_transformer(:add_foo){|v| v << 'foo'}
-    @o.name = ' name '.dup
-    @o.name.must_equal 'raboof eman '
-  end
-
-  it "should freeze input transformers when freezing model class" do
-    @c.skip_input_transformer :reverser, :name
-    @c.freeze
-    @c.input_transformers.frozen?.must_equal true
-    skip = @c.instance_variable_get(:@skip_input_transformer_columns)
-    skip.frozen?.must_equal true
-    skip.values.all?(&:frozen?).must_equal true
-  end
-end

data/spec/extensions/insert_conflict_spec.rb

@@ -1,103 +0,0 @@
-require_relative "spec_helper"
-
-describe "insert_conflict plugin" do
-  def model_class(adapter)
-    db = Sequel.mock(:host=>adapter, :fetch=>{:id=>1, :s=>2}, :autoid=>1)
-    db.extend_datasets{def quote_identifiers?; false end}
-    model = Class.new(Sequel::Model)
-    model.dataset = db[:t]
-    model.columns :id, :s, :o
-    model.plugin :insert_conflict
-    db.sqls
-    model
-  end
-
-  def model_class_plugin_first(adapter)
-    model = Class.new(Sequel::Model)
-    model.plugin :insert_conflict
-    model = Class.new(model)
-    db = Sequel.mock(:host=>adapter, :fetch=>{:id=>1, :s=>2}, :autoid=>1)
-    db.extend_datasets{def quote_identifiers?; false end}
-    model.dataset = db[:t]
-    model.columns :id, :s, :o
-    db.sqls
-    model
-  end
-
-  it "should use INSERT ON CONFLICT when inserting on PostgreSQL" do
-    model = model_class(:postgres)
-    model.new(:s=>'A', :o=>1).insert_conflict.save
-    model.db.sqls.must_equal ["INSERT INTO t (s, o) VALUES ('A', 1) ON CONFLICT DO NOTHING RETURNING *"]
-
-    model.new(:s=>'A', :o=>1).insert_conflict(:target=>:s, :update => {:o => Sequel[:excluded][:o]}).save
-    model.db.sqls.must_equal ["INSERT INTO t (s, o) VALUES ('A', 1) ON CONFLICT (s) DO UPDATE SET o = excluded.o RETURNING *"]
-  end
-
-  it "should use INSERT ON CONFLICT when inserting on SQLITE" do
-    model = model_class(:sqlite)
-    model.new(:s=>'A', :o=>1).insert_conflict.save
-    model.db.sqls.must_equal ["INSERT INTO t (s, o) VALUES ('A', 1) ON CONFLICT DO NOTHING",
-      "SELECT * FROM t WHERE (id = 1) LIMIT 1"]
-
-    model.new(:s=>'A', :o=>1).insert_conflict(:target=>:s, :update => {:o => Sequel[:excluded][:o]}).save
-    model.db.sqls.must_equal ["INSERT INTO t (s, o) VALUES ('A', 1) ON CONFLICT (s) DO UPDATE SET o = excluded.o",
-      "SELECT * FROM t WHERE (id = 2) LIMIT 1"]
-  end
-
-  it "should raise Error if calling insert_conflict on a model instance that isn't new" do
-    m = model_class(:postgres).load(:s=>'A', :o=>1)
-    proc{m.insert_conflict}.must_raise Sequel::Error
-  end
-
-  it "should raise if loading plugin into a model class with a dataset that doesn't support insert_conflict" do
-    model = Class.new(Sequel::Model)
-    model.dataset = Sequel.mock[:t]
-    proc{model.plugin :insert_conflict}.must_raise Sequel::Error
-  end
-
-  it "should work if loading into a model class without a dataset on PostgreSQL" do
-    model = model_class_plugin_first(:postgres)
-    model.new(:s=>'A', :o=>1).insert_conflict.save
-    model.db.sqls.must_equal ["INSERT INTO t (s, o) VALUES ('A', 1) ON CONFLICT DO NOTHING RETURNING *"]
-
-    model.new(:s=>'A', :o=>1).insert_conflict(:target=>:s, :update => {:o => Sequel[:excluded][:o]}).save
-    model.db.sqls.must_equal ["INSERT INTO t (s, o) VALUES ('A', 1) ON CONFLICT (s) DO UPDATE SET o = excluded.o RETURNING *"]
-  end
-
-  it "should work if loading into a model class without a dataset on SQLITE" do
-    model = model_class_plugin_first(:sqlite)
-    model.new(:s=>'A', :o=>1).insert_conflict.save
-    model.db.sqls.must_equal ["INSERT INTO t (s, o) VALUES ('A', 1) ON CONFLICT DO NOTHING",
-      "SELECT * FROM t WHERE (id = 1) LIMIT 1"]
-
-    model.new(:s=>'A', :o=>1).insert_conflict(:target=>:s, :update => {:o => Sequel[:excluded][:o]}).save
-    model.db.sqls.must_equal ["INSERT INTO t (s, o) VALUES ('A', 1) ON CONFLICT (s) DO UPDATE SET o = excluded.o",
-      "SELECT * FROM t WHERE (id = 2) LIMIT 1"]
-  end
-
-  it "should work if the prepared_statements plugin is loaded before" do
-    db = Sequel.mock(:host=>'sqlite', :fetch=>{:id=>1, :s=>2}, :autoid=>1, :numrows=>1)
-    db.extend_datasets{def quote_identifiers?; false end}
-    model = Class.new(Sequel::Model)
-    model.dataset = db[:t]
-    model.columns :id, :s
-    model.plugin :prepared_statements
-    model.plugin :insert_conflict
-    db.sqls
-    model.create(:s=>'a').update(:s=>'b')
-    db.sqls.must_equal ["INSERT INTO t (s) VALUES ('a')", "SELECT * FROM t WHERE (id = 1) LIMIT 1", "UPDATE t SET s = 'b' WHERE (id = 1)"]
-  end
-
-  it "should work if the prepared_statements plugin is loaded after" do
-    db = Sequel.mock(:host=>'postgres', :fetch=>{:id=>1, :s=>2}, :autoid=>1, :numrows=>1)
-    db.extend_datasets{def quote_identifiers?; false end}
-    model = Class.new(Sequel::Model)
-    model.dataset = db[:t]
-    model.columns :id, :s
-    model.plugin :insert_conflict
-    model.plugin :prepared_statements
-    db.sqls
-    model.create(:s=>'a').update(:s=>'b')
-    db.sqls.must_equal ["INSERT INTO t (s) VALUES ('a') RETURNING *", "UPDATE t SET s = 'b' WHERE (id = 1)"]
-  end
-end

data/spec/extensions/insert_returning_select_spec.rb

@@ -1,72 +0,0 @@
-require_relative "spec_helper"
-
-describe "Sequel::Plugins::InsertReturningSelect" do
-  before do
-    @db = Sequel.mock(:fetch=>{:id=>1, :x=>2}, :autoid=>1)
-    @db.extend_datasets do
-      def supports_returning?(_) true end
-      def insert_select(*v) with_sql_first("#{insert_sql(*v)} RETURNING #{opts[:returning].map{|x| literal(x)}.join(', ')}") end
-    end
-    @Album = Class.new(Sequel::Model(@db[:albums].select(:id, :x)))
-    @Album.columns :id, :x
-    @db.sqls
-  end
-
-  it "should work if loaded into a model without a dataset that also uses the lazy_attributes or dataset associations plugins" do
-    c = Sequel::Model(@db)
-    c.plugin :insert_returning_select
-    c.columns :id, :x
-    c.plugin :lazy_attributes
-    c.plugin :dataset_associations
-
-    c.set_dataset @db[:albums].select(:id, :x)
-    c.plugin :lazy_attributes, :x
-    c.many_to_one :c, :key=>:id, :class=>c
-    @db.sqls
-
-    c.dataset.sql.must_equal 'SELECT id FROM albums'
-    c.create(:x=>2)
-    @db.sqls.must_equal ['INSERT INTO albums (x) VALUES (2) RETURNING id']
-    c.load(:id=>2).x
-    @db.sqls.must_equal ['SELECT albums.x FROM albums WHERE (id = 2) LIMIT 1']
-    c.dataset.cs.sql.must_equal "SELECT id FROM albums WHERE (albums.id IN (SELECT albums.id FROM albums))"
-  end
-
-  it "should add a returning clause when inserting using selected columns" do
-    @Album.plugin :insert_returning_select
-    @Album.create(:x=>2).must_equal @Album.load(:id=>1, :x=>2)
-    @db.sqls.must_equal ['INSERT INTO albums (x) VALUES (2) RETURNING id, x']
-  end
-
-  it "should not add a returning clause if selection does not consist of just columns" do
-    @Album.dataset = @Album.dataset.select_append(Sequel.as(1, :b))
-    @Album.plugin :insert_returning_select
-    @db.sqls.clear
-    @Album.create(:x=>2).must_equal @Album.load(:id=>1, :x=>2)
-    @db.sqls.must_equal ['INSERT INTO albums (x) VALUES (2)', 'SELECT id, x, 1 AS b FROM albums WHERE (id = 1) LIMIT 1']
-  end
-
-  it "should not add a returning clause if database doesn't support it" do
-    @db.extend_datasets{def supports_returning?(_) false end}
-    @Album.plugin :insert_returning_select
-    @Album.create(:x=>2).must_equal @Album.load(:id=>1, :x=>2)
-    @db.sqls.must_equal ['INSERT INTO albums (x) VALUES (2)', 'SELECT id, x FROM albums WHERE (id = 1) LIMIT 1']
-  end
-
-  it "should work correctly with subclasses" do
-    c = Class.new(Sequel::Model)
-    c.plugin :insert_returning_select
-    b = Class.new(c)
-    b.columns :id, :x
-    b.dataset = @db[:albums].select(:id, :x)
-    @db.sqls.clear
-    b.create(:x=>2).must_equal b.load(:id=>1, :x=>2)
-    @db.sqls.must_equal ['INSERT INTO albums (x) VALUES (2) RETURNING id, x']
-  end
-
-  it "should freeze instance_insert_dataset when freezing model class" do
-    @Album.plugin :insert_returning_select
-    @Album.freeze
-    @Album.instance_insert_dataset.frozen?.must_equal true
-  end
-end

data/spec/extensions/instance_filters_spec.rb

@@ -1,79 +0,0 @@
-require_relative "spec_helper"
-
-describe "instance_filters plugin" do
-  before do
-    @c = Class.new(Sequel::Model(:people))
-    @c.columns :id, :name, :num
-    @c.plugin :instance_filters
-    @p = @c.load(:id=>1, :name=>'John', :num=>1)
-    DB.sqls
-  end
-
-  it "should raise an error when updating a stale record" do
-    @p.update(:name=>'Bob')
-    DB.sqls.must_equal ["UPDATE people SET name = 'Bob' WHERE (id = 1)"]
-    @p.instance_filter(:name=>'Jim')
-    @p.instance_variable_set(:@this, @p.this.with_numrows(0))
-    proc{@p.update(:name=>'Joe')}.must_raise(Sequel::Plugins::InstanceFilters::Error)
-    DB.sqls.must_equal ["UPDATE people SET name = 'Joe' WHERE ((id = 1) AND (name = 'Jim'))"]
-  end 
-
-  it "should raise an error when destroying a stale record" do
-    @p.destroy
-    DB.sqls.must_equal ["DELETE FROM people WHERE id = 1"]
-    @p.instance_filter(:name=>'Jim')
-    @p.instance_variable_set(:@this, @p.this.with_numrows(0))
-    proc{@p.destroy}.must_raise(Sequel::Plugins::InstanceFilters::Error)
-    DB.sqls.must_equal ["DELETE FROM people WHERE ((id = 1) AND (name = 'Jim'))"]
-  end 
-  
-  it "should work when using the prepared_statements plugin" do
-    @c.plugin :prepared_statements
-
-    @p.update(:name=>'Bob')
-    DB.sqls.must_equal ["UPDATE people SET name = 'Bob' WHERE (id = 1)"]
-    @p.instance_filter(:name=>'Jim')
-    @p.instance_variable_set(:@this, @p.this.with_numrows(0))
-    proc{@p.update(:name=>'Joe')}.must_raise(Sequel::Plugins::InstanceFilters::Error)
-    DB.sqls.must_equal ["UPDATE people SET name = 'Joe' WHERE ((id = 1) AND (name = 'Jim'))"]
-
-    @p = @c.load(:id=>1, :name=>'John', :num=>1)
-    @p.instance_variable_set(:@this, @p.this.with_numrows(1))
-    @c.instance_variable_set(:@fast_instance_delete_sql, nil)
-    @p.destroy
-    DB.sqls.must_equal ["DELETE FROM people WHERE (id = 1)"]
-    @p.instance_filter(:name=>'Jim')
-    @p.instance_variable_set(:@this, @p.this.with_numrows(0))
-    proc{@p.destroy}.must_raise(Sequel::Plugins::InstanceFilters::Error)
-    DB.sqls.must_equal ["DELETE FROM people WHERE ((id = 1) AND (name = 'Jim'))"]
-    
-    @c.create.must_be_kind_of(@c)
-  end 
-  
-  it "should apply all instance filters" do
-    @p.instance_filter(:name=>'Jim')
-    @p.instance_filter{num > 2}
-    @p.update(:name=>'Bob')
-    DB.sqls.must_equal ["UPDATE people SET name = 'Bob' WHERE ((id = 1) AND (name = 'Jim') AND (num > 2))"]
-  end 
-
-  it "should drop instance filters after updating" do
-    @p.instance_filter(:name=>'Joe')
-    @p.update(:name=>'Joe')
-    DB.sqls.must_equal ["UPDATE people SET name = 'Joe' WHERE ((id = 1) AND (name = 'Joe'))"]
-    @p.update(:name=>'Bob')
-    DB.sqls.must_equal ["UPDATE people SET name = 'Bob' WHERE (id = 1)"]
-  end
-
-  it "shouldn't allow instance filters on frozen objects" do
-    @p.instance_filter(:name=>'Joe')
-    @p.freeze
-    proc{@p.instance_filter(:name=>'Jim')}.must_raise
-  end 
-
-  it "should have dup duplicate internal structures" do
-    @p.instance_filter(:name=>'Joe')
-    @p.dup.send(:instance_filters).must_equal @p.send(:instance_filters)
-    @p.dup.send(:instance_filters).wont_be_same_as(@p.send(:instance_filters))
-  end 
-end

data/spec/extensions/instance_hooks_spec.rb

@@ -1,246 +0,0 @@
-require_relative "spec_helper"
-
-describe "InstanceHooks plugin" do
-  def r(x=nil)
-    @r << x
-    yield if block_given?
-    x
-  end
-  
-  before do
-    @c = Class.new(Sequel::Model(:items))
-    @c.plugin :instance_hooks
-    @c.raise_on_save_failure = false
-    @o = @c.new
-    @x = @c.load({:id=>1})
-    @r = []
-  end
-  
-  it "should support before_create_hook and after_create_hook" do
-    @o.after_create_hook{r 1}
-    @o.before_create_hook{r 2}
-    @o.after_create_hook{r 3}
-    @o.before_create_hook{r 4}
-    @o.save.wont_equal nil
-    @r.must_equal [4, 2, 1, 3]
-  end
-
-  it "should cancel the save if before_create_hook block calls cancel_action" do
-    @o.after_create_hook{r 1}
-    @o.before_create_hook{r{@o.cancel_action}}
-    @o.before_create_hook{r 4}
-    @o.save.must_be_nil
-    @r.must_equal [4, nil]
-    @r.clear
-    @o.save.must_be_nil
-    @r.must_equal [4, nil]
-  end
-
-  it "should support before_update_hook and after_update_hook" do
-    @x.after_update_hook{r 1}
-    @x.before_update_hook{r 2}
-    @x.after_update_hook{r 3}
-    @x.before_update_hook{r 4}
-    @x.save.wont_equal nil
-    @r.must_equal [4, 2, 1, 3]
-    @x.save.wont_equal nil
-    @r.must_equal [4, 2, 1, 3]
-  end
-
-  it "should cancel the save if before_update_hook block calls cancel_action" do
-    @x.after_update_hook{r 1}
-    @x.before_update_hook{r{@x.cancel_action}}
-    @x.before_update_hook{r 4}
-    @x.save.must_be_nil
-    @r.must_equal [4, nil]
-    @r.clear
-    @x.save.must_be_nil
-    @r.must_equal [4, nil]
-  end
-
-  it "should support before_save_hook and after_save_hook" do
-    @o.after_save_hook{r 1}
-    @o.before_save_hook{r 2}
-    @o.after_save_hook{r 3}
-    @o.before_save_hook{r 4}
-    @o.save.wont_equal nil
-    @r.must_equal [4, 2, 1, 3]
-    @r.clear
-    
-    @x.after_save_hook{r 1}
-    @x.before_save_hook{r 2}
-    @x.after_save_hook{r 3}
-    @x.before_save_hook{r 4}
-    @x.save.wont_equal nil
-    @r.must_equal [4, 2, 1, 3]
-    @x.save.wont_equal nil
-    @r.must_equal [4, 2, 1, 3]
-  end
-
-  it "should cancel the save if before_save_hook block calls cancel_action" do
-    @x.after_save_hook{r 1}
-    @x.before_save_hook{r{@x.cancel_action}}
-    @x.before_save_hook{r 4}
-    @x.save.must_be_nil
-    @r.must_equal [4, nil]
-    @r.clear
-    
-    @x.after_save_hook{r 1}
-    @x.before_save_hook{r{@x.cancel_action}}
-    @x.before_save_hook{r 4}
-    @x.save.must_be_nil
-    @r.must_equal [4, nil]
-    @r.clear
-    @x.save.must_be_nil
-    @r.must_equal [4, nil]
-  end
-
-  it "should support before_destroy_hook and after_destroy_hook" do
-    @x.after_destroy_hook{r 1}
-    @x.before_destroy_hook{r 2}
-    @x.after_destroy_hook{r 3}
-    @x.before_destroy_hook{r 4}
-    @x.destroy.wont_equal nil
-    @r.must_equal [4, 2, 1, 3]
-  end
-
-  it "should cancel the destroy if before_destroy_hook block calls cancel_action" do
-    @x.after_destroy_hook{r 1}
-    @x.before_destroy_hook{r{@x.cancel_action}}
-    @x.before_destroy_hook{r 4}
-    @x.destroy.must_be_nil
-    @r.must_equal [4, nil]
-  end
-
-  it "should support before_validation_hook and after_validation_hook" do
-    @o.after_validation_hook{r 1}
-    @o.before_validation_hook{r 2}
-    @o.after_validation_hook{r 3}
-    @o.before_validation_hook{r 4}
-    @o.valid?.must_equal true
-    @r.must_equal [4, 2, 1, 3]
-  end
-
-  it "should cancel the save if before_validation_hook block calls cancel_action" do
-    @o.after_validation_hook{r 1}
-    @o.before_validation_hook{r{@o.cancel_action}}
-    @o.before_validation_hook{r 4}
-    @o.valid?.must_equal false
-    @r.must_equal [4, nil]
-    @r.clear
-    @o.valid?.must_equal false
-    @r.must_equal [4, nil]
-  end
-
-  it "should clear only related hooks on successful create" do
-    @o.after_destroy_hook{r 1}
-    @o.before_destroy_hook{r 2}
-    @o.after_update_hook{r 3}
-    @o.before_update_hook{r 4}
-    @o.before_save_hook{r 5}
-    @o.after_save_hook{r 6}
-    @o.before_create_hook{r 7}
-    @o.after_create_hook{r 8}
-    @o.save.wont_equal nil
-    @r.must_equal [5, 7, 8, 6]
-    @o.instance_variable_set(:@new, false)
-    @o.save.wont_equal nil
-    @r.must_equal [5, 7, 8, 6, 4, 3]
-    @o.save.wont_equal nil
-    @r.must_equal [5, 7, 8, 6, 4, 3]
-    @o.destroy
-    @r.must_equal [5, 7, 8, 6, 4, 3, 2, 1]
-  end
-
-  it "should clear only related hooks on successful update" do
-    @x.after_destroy_hook{r 1}
-    @x.before_destroy_hook{r 2}
-    @x.before_update_hook{r 3}
-    @x.after_update_hook{r 4}
-    @x.before_save_hook{r 5}
-    @x.after_save_hook{r 6}
-    @x.save.wont_equal nil
-    @r.must_equal [5, 3, 4, 6]
-    @x.save.wont_equal nil
-    @r.must_equal [5, 3, 4, 6]
-    @x.destroy
-    @r.must_equal [5, 3, 4, 6, 2, 1]
-  end
-
-  it "should clear only related hooks on successful destroy" do
-    @x.after_destroy_hook{r 1}
-    @x.before_destroy_hook{r 2}
-    @x.before_update_hook{r 3}
-    @x.before_save_hook{r 4}
-    @x.destroy
-    @r.must_equal [2, 1]
-    @x.save.wont_equal nil
-    @r.must_equal [2, 1, 4, 3]
-  end
-
-  it "should not clear validations hooks on successful save" do
-    @x.after_validation_hook{@x.errors.add(:id, 'a') if @x.id == 1; r 1}
-    @x.before_validation_hook{r 2}
-    @x.save.must_be_nil
-    @r.must_equal [2, 1]
-    @x.save.must_be_nil
-    @r.must_equal [2, 1, 2, 1]
-    @x.id = 2
-    @x.save.must_equal @x
-    @r.must_equal [2, 1, 2, 1, 2, 1]
-    @x.save.must_equal @x
-    @r.must_equal [2, 1, 2, 1, 2, 1]
-  end
-
-  it "should not allow addition of instance hooks to frozen instances" do
-    @x.after_destroy_hook{r 1}
-    @x.before_destroy_hook{r 2}
-    @x.before_update_hook{r 3}
-    @x.before_save_hook{r 4}
-    @x.freeze
-    proc{@x.after_destroy_hook{r 1}}.must_raise(Sequel::Error)
-    proc{@x.before_destroy_hook{r 2}}.must_raise(Sequel::Error)
-    proc{@x.before_update_hook{r 3}}.must_raise(Sequel::Error)
-    proc{@x.before_save_hook{r 4}}.must_raise(Sequel::Error)
-  end
-end
-
-describe "InstanceHooks plugin with transactions" do
-  before do
-    @db = Sequel.mock(:numrows=>1)
-    @c = Class.new(Sequel::Model(@db[:items])) do
-      attr_accessor :rb
-      def after_save
-        super
-        db.execute('as')
-        raise Sequel::Rollback if rb
-      end
-      def after_destroy
-        super
-        db.execute('ad')
-        raise Sequel::Rollback if rb
-      end
-    end
-    @c.use_transactions = true
-    @c.plugin :instance_hooks
-    @o = @c.load({:id=>1})
-    @or = @c.load({:id=>1})
-    @or.rb = true
-    @r = []
-    @db.sqls
-  end
-  
-  it "should have *_hook methods return self "do
-    @o.before_destroy_hook{r 1}.must_be_same_as(@o)
-    @o.before_validation_hook{r 1}.must_be_same_as(@o)
-    @o.before_save_hook{r 1}.must_be_same_as(@o)
-    @o.before_update_hook{r 1}.must_be_same_as(@o)
-    @o.before_create_hook{r 1}.must_be_same_as(@o)
-
-    @o.after_destroy_hook{r 1}.must_be_same_as(@o)
-    @o.after_validation_hook{r 1}.must_be_same_as(@o)
-    @o.after_save_hook{r 1}.must_be_same_as(@o)
-    @o.after_update_hook{r 1}.must_be_same_as(@o)
-    @o.after_create_hook{r 1}.must_be_same_as(@o)
-  end
-end