sequel 5.29.0 → 5.30.0

data/spec/extensions/force_encoding_spec.rb

@@ -1,126 +0,0 @@
-require_relative "spec_helper"
-
-describe "force_encoding plugin" do
-  before do
-    @c = Class.new(Sequel::Model)
-    @c.columns :id, :x
-    @c.plugin :force_encoding, 'UTF-8'
-    @e1 = Encoding.find('UTF-8')
-  end
-
-  it "should force encoding to given encoding on load" do
-    s = 'blah'.dup
-    s.force_encoding('US-ASCII')
-    o = @c.load(:id=>1, :x=>s)
-    o.x.must_equal 'blah'
-    o.x.encoding.must_equal @e1
-  end
-  
-  it "should force encoding to given encoding when setting column values" do
-    s = 'blah'.dup
-    s.force_encoding('US-ASCII')
-    o = @c.new(:x=>s)
-    o.x.must_equal 'blah'
-    o.x.encoding.must_equal @e1
-  end
-  
-  it "should not force encoding of blobs to given encoding on load" do
-    s = Sequel.blob('blah'.dup.force_encoding('BINARY'))
-    o = @c.load(:id=>1, :x=>s)
-    o.x.must_equal 'blah'
-    o.x.encoding.must_equal Encoding.find('BINARY')
-  end
-  
-  it "should not force encoding of blobs to given encoding when setting column values" do
-    s = Sequel.blob('blah'.dup.force_encoding('BINARY'))
-    o = @c.new(:x=>s)
-    o.x.must_equal 'blah'
-    o.x.encoding.must_equal Encoding.find('BINARY')
-  end
-  
-  it "should work correctly when given a frozen string" do
-    s = 'blah'.dup
-    s.force_encoding('US-ASCII')
-    s.freeze
-    o = @c.new(:x=>s)
-    o.x.must_equal 'blah'
-    o.x.encoding.must_equal @e1
-  end
-  
-  it "should have a forced_encoding class accessor" do
-    s = 'blah'.dup
-    s.force_encoding('US-ASCII')
-    @c.forced_encoding = 'Windows-1258'
-    o = @c.load(:id=>1, :x=>s)
-    o.x.must_equal 'blah'
-    o.x.encoding.must_equal Encoding.find('Windows-1258')
-  end
-  
-  it "should not force encoding if forced_encoding is nil" do
-    s = 'blah'.dup
-    s.force_encoding('US-ASCII')
-    @c.forced_encoding = nil
-    o = @c.load(:id=>1, :x=>s)
-    o.x.must_equal 'blah'
-    o.x.encoding.must_equal Encoding.find('US-ASCII')
-  end
-  
-  it "should work correctly when subclassing" do
-    c = Class.new(@c)
-    s = 'blah'.dup
-    s.force_encoding('US-ASCII')
-    o = c.load(:id=>1, :x=>s)
-    o.x.must_equal 'blah'
-    o.x.encoding.must_equal @e1
-    
-    c.plugin :force_encoding, 'UTF-16LE'
-    s = String.new
-    s.force_encoding('US-ASCII')
-    o = c.load(:id=>1, :x=>s)
-    o.x.must_equal ''
-    o.x.encoding.must_equal Encoding.find('UTF-16LE')
-    
-    @c.plugin :force_encoding, 'UTF-32LE'
-    s = String.new
-    s.force_encoding('US-ASCII')
-    o = @c.load(:id=>1, :x=>s)
-    o.x.must_equal ''
-    o.x.encoding.must_equal Encoding.find('UTF-32LE')
-    
-    s = String.new
-    s.force_encoding('US-ASCII')
-    o = c.load(:id=>1, :x=>s)
-    o.x.must_equal ''
-    o.x.encoding.must_equal Encoding.find('UTF-16LE')
-  end
-  
-  it "should work when saving new model instances" do
-    o = @c.new
-    @c.dataset = DB[:a].with_extend do
-      def first
-        s = 'blah'.dup
-        s.force_encoding('US-ASCII')
-        {:id=>1, :x=>s}
-      end
-    end
-    @c.instance_variable_set(:@fast_pk_lookup_sql, nil)
-    o.save
-    o.x.must_equal 'blah'
-    o.x.encoding.must_equal @e1
-  end
-  
-  it "should work when refreshing model instances" do
-    o = @c.load(:id=>1, :x=>'as'.dup)
-    @c.dataset = DB[:a].with_extend do
-      def first
-        s = 'blah'.dup
-        s.force_encoding('US-ASCII')
-        {:id=>1, :x=>s}
-      end
-    end
-    @c.instance_variable_set(:@fast_pk_lookup_sql, nil)
-    o.refresh
-    o.x.must_equal 'blah'
-    o.x.encoding.must_equal @e1
-  end
-end 

data/spec/extensions/freeze_datasets_spec.rb

@@ -1,31 +0,0 @@
-require_relative "spec_helper"
-
-describe "freeze_datasets extension" do
-  before do
-    @db = Sequel.mock.extension(:freeze_datasets)
-  end
-
-  it "should freeze datasets by default" do
-    @db.dataset.frozen?.must_equal true
-    @db.fetch('SQL').frozen?.must_equal true
-    @db.from(:table).frozen?.must_equal true
-    @db[:table].frozen?.must_equal true
-  end
-
-  it "should have dataset#dup return frozen dataset" do
-    @db.dataset.dup.frozen?.must_equal true
-  end
-
-  it "should cache Database#from calls with single symbol tables" do
-    @db.from(:foo).must_be_same_as @db.from(:foo)
-    @db.from(Sequel[:foo]).wont_be_same_as @db.from(Sequel[:foo])
-  end
-
-  it "should clear Database#from cache when modifying the schema" do
-    ds = @db.from(:foo)
-    ds.columns(:foo, :bar)
-    @db[:foo].columns.must_equal [:foo, :bar]
-    @db.create_table!(:foo){Integer :x}
-    @db[:foo].columns.wont_equal [:foo, :bar]
-  end
-end

data/spec/extensions/graph_each_spec.rb

@@ -1,113 +0,0 @@
-require_relative "spec_helper"
-
-describe Sequel::Dataset, " graphing" do
-  before do
-    @db = Sequel.mock(:columns=>proc do |sql|
-      case sql
-      when /points/
-        [:id, :x, :y]
-      when /lines/
-        [:id, :x, :y, :graph_id]
-      else
-        [:id, :name, :x, :y, :lines_x]
-      end
-    end).extension(:graph_each)
-    @ds1 = @db.from(:points)
-    @ds2 = @db.from(:lines)
-    @ds3 = @db.from(:graphs)
-    [@ds1, @ds2, @ds3].each{|ds| ds.columns}
-    @db.sqls
-  end
-
-  it "#graph_each should handle graph using currently selected columns as the basis for the selected columns in a new graph" do
-    @ds1.select(:id).graph(@ds2, :x=>:id).with_fetch(:id=>1, :lines_id=>2, :x=>3, :y=>4, :graph_id=>5).all.must_equal [{:points=>{:id=>1}, :lines=>{:id=>2, :x=>3, :y=>4, :graph_id=>5}}]
-
-    @ds1.select(:id, :x).graph(@ds2, :x=>:id).with_fetch(:id=>1, :x=>-1, :lines_id=>2, :lines_x=>3, :y=>4, :graph_id=>5).all.must_equal [{:points=>{:id=>1, :x=>-1}, :lines=>{:id=>2, :x=>3, :y=>4, :graph_id=>5}}]
-
-    @ds1.select(Sequel.identifier(:id), Sequel.qualify(:points, :x)).graph(@ds2, :x=>:id).with_fetch(:id=>1, :x=>-1, :lines_id=>2, :lines_x=>3, :y=>4, :graph_id=>5).all.must_equal [{:points=>{:id=>1, :x=>-1}, :lines=>{:id=>2, :x=>3, :y=>4, :graph_id=>5}}]
-
-    @ds1.select(Sequel.identifier(:id).qualify(:points), Sequel.identifier(:x).as(:y)).graph(@ds2, :x=>:id).with_fetch(:id=>1, :y=>-1, :lines_id=>2, :x=>3, :lines_y=>4, :graph_id=>5).all.must_equal [{:points=>{:id=>1, :y=>-1}, :lines=>{:id=>2, :x=>3, :y=>4, :graph_id=>5}}]
-
-    @ds1.select(:id, Sequel.identifier(:x).qualify(Sequel.identifier(:points)).as(Sequel.identifier(:y))).graph(@ds2, :x=>:id).with_fetch(:id=>1, :y=>-1, :lines_id=>2, :x=>3, :lines_y=>4, :graph_id=>5).all.must_equal [{:points=>{:id=>1, :y=>-1}, :lines=>{:id=>2, :x=>3, :y=>4, :graph_id=>5}}]
-  end
-
-  it "#graph_each should split the result set into component tables" do
-    @db.fetch = [[{:id=>1,:x=>2,:y=>3,:lines_id=>4,:lines_x=>5,:lines_y=>6,:graph_id=>7}],
-      [{:id=>1,:x=>2,:y=>3,:lines_id=>4,:lines_x=>5,:lines_y=>6,:graph_id=>7, :graphs_id=>8, :name=>9, :graphs_x=>10, :graphs_y=>11, :graphs_lines_x=>12}],
-      [{:id=>1,:x=>2,:y=>3,:lines_id=>4,:lines_x=>5,:lines_y=>6,:graph_id=>7, :graph_id_0=>8, :graph_x=>9, :graph_y=>10, :graph_graph_id=>11}]]
-
-    @ds1.graph(@ds2, :x=>:id).all.must_equal [{:points=>{:id=>1, :x=>2, :y=>3}, :lines=>{:id=>4, :x=>5, :y=>6, :graph_id=>7}}]
-    @ds1.graph(@ds2, :x=>:id).graph(@ds3, :id=>:graph_id).all.must_equal [{:points=>{:id=>1, :x=>2, :y=>3}, :lines=>{:id=>4, :x=>5, :y=>6, :graph_id=>7}, :graphs=>{:id=>8, :name=>9, :x=>10, :y=>11, :lines_x=>12}}]
-    @ds1.graph(@ds2, :x=>:id).graph(@ds2, {:y=>Sequel[:points][:id]}, :table_alias=>:graph).all.must_equal [{:points=>{:id=>1, :x=>2, :y=>3}, :lines=>{:id=>4, :x=>5, :y=>6, :graph_id=>7}, :graph=>{:id=>8, :x=>9, :y=>10, :graph_id=>11}}]
-  end
-
-  it "#graph_each should split the result set into component tables when using first" do
-    @db.fetch = [[{:id=>1,:x=>2,:y=>3,:lines_id=>4,:lines_x=>5,:lines_y=>6,:graph_id=>7}],
-      [{:id=>1,:x=>2,:y=>3,:lines_id=>4,:lines_x=>5,:lines_y=>6,:graph_id=>7, :graphs_id=>8, :name=>9, :graphs_x=>10, :graphs_y=>11, :graphs_lines_x=>12}],
-      [{:id=>1,:x=>2,:y=>3,:lines_id=>4,:lines_x=>5,:lines_y=>6,:graph_id=>7, :graph_id_0=>8, :graph_x=>9, :graph_y=>10, :graph_graph_id=>11}]]
-
-    @ds1.graph(@ds2, :x=>:id).first.must_equal(:points=>{:id=>1, :x=>2, :y=>3}, :lines=>{:id=>4, :x=>5, :y=>6, :graph_id=>7})
-    @ds1.graph(@ds2, :x=>:id).graph(@ds3, :id=>:graph_id).first.must_equal(:points=>{:id=>1, :x=>2, :y=>3}, :lines=>{:id=>4, :x=>5, :y=>6, :graph_id=>7}, :graphs=>{:id=>8, :name=>9, :x=>10, :y=>11, :lines_x=>12})
-    @ds1.graph(@ds2, :x=>:id).graph(@ds2, {:y=>Sequel[:points][:id]}, :table_alias=>:graph).first.must_equal(:points=>{:id=>1, :x=>2, :y=>3}, :lines=>{:id=>4, :x=>5, :y=>6, :graph_id=>7}, :graph=>{:id=>8, :x=>9, :y=>10, :graph_id=>11})
-  end
-
-  it "#graph_each should give a nil value instead of a hash when all values for a table are nil" do
-    @db.fetch = [[{:id=>1,:x=>2,:y=>3,:lines_id=>nil,:lines_x=>nil,:lines_y=>nil,:graph_id=>nil}],
-      [{:id=>1,:x=>2,:y=>3,:lines_id=>4,:lines_x=>5,:lines_y=>6,:graph_id=>7, :graphs_id=>nil, :name=>nil, :graphs_x=>nil, :graphs_y=>nil, :graphs_lines_x=>nil},
-      {:id=>2,:x=>4,:y=>5,:lines_id=>nil,:lines_x=>nil,:lines_y=>nil,:graph_id=>nil, :graphs_id=>nil, :name=>nil, :graphs_x=>nil, :graphs_y=>nil, :graphs_lines_x=>nil},
-      {:id=>3,:x=>5,:y=>6,:lines_id=>4,:lines_x=>5,:lines_y=>6,:graph_id=>7, :graphs_id=>7, :name=>8, :graphs_x=>9, :graphs_y=>10, :graphs_lines_x=>11},
-      {:id=>3,:x=>5,:y=>6,:lines_id=>7,:lines_x=>5,:lines_y=>8,:graph_id=>9, :graphs_id=>9, :name=>10, :graphs_x=>10, :graphs_y=>11, :graphs_lines_x=>12}]]
-
-    @ds1.graph(@ds2, :x=>:id).all.must_equal [{:points=>{:id=>1, :x=>2, :y=>3}, :lines=>nil}]
-    @ds1.graph(@ds2, :x=>:id).graph(@ds3, :id=>:graph_id).all.must_equal [{:points=>{:id=>1, :x=>2, :y=>3}, :lines=>{:id=>4, :x=>5, :y=>6, :graph_id=>7}, :graphs=>nil},
-      {:points=>{:id=>2, :x=>4, :y=>5}, :lines=>nil, :graphs=>nil},
-      {:points=>{:id=>3, :x=>5, :y=>6}, :lines=>{:id=>4, :x=>5, :y=>6, :graph_id=>7}, :graphs=>{:id=>7, :name=>8, :x=>9, :y=>10, :lines_x=>11}},
-      {:points=>{:id=>3, :x=>5, :y=>6}, :lines=>{:id=>7, :x=>5, :y=>8, :graph_id=>9}, :graphs=>{:id=>9, :name=>10, :x=>10, :y=>11, :lines_x=>12}}]
-  end
-
-  it "#graph_each should not give a nil value instead of a hash when any value for a table is false" do
-    @db.fetch = {:id=>1,:x=>2,:y=>3,:lines_id=>nil,:lines_x=>false,:lines_y=>nil,:graph_id=>nil}
-    @ds1.graph(@ds2, :x=>:id).all.must_equal [{:points=>{:id=>1, :x=>2, :y=>3}, :lines=>{:id=>nil, :x=>false, :y=>nil, :graph_id=>nil}}]
-  end
-
-  it "#graph_each should not included tables graphed with the :select => false option in the result set" do
-    @db.fetch = {:id=>1,:x=>2,:y=>3,:graphs_id=>8, :name=>9, :graphs_x=>10, :graphs_y=>11, :lines_x=>12}
-    @ds1.graph(:lines, {:x=>:id}, :select=>false).graph(:graphs, :id=>:graph_id).all.must_equal [{:points=>{:id=>1, :x=>2, :y=>3}, :graphs=>{:id=>8, :name=>9, :x=>10, :y=>11, :lines_x=>12}}]
-  end
-
-  it "#graph_each should only include the columns selected with #set_graph_aliases and #add_graph_aliases, if called" do
-    @db.fetch = [[{:x=>2,:y=>3}], [{:x=>2}], [{:x=>2, :q=>18}]]
-
-    @ds1.graph(:lines, :x=>:id).set_graph_aliases(:x=>[:points, :x], :y=>[:lines, :y]).all.must_equal [{:points=>{:x=>2}, :lines=>{:y=>3}}]
-    ds = @ds1.graph(:lines, :x=>:id).set_graph_aliases(:x=>[:points, :x])
-    ds.all.must_equal [{:points=>{:x=>2}, :lines=>nil}]
-    ds = ds.add_graph_aliases(:q=>[:points, :r, 18])
-    ds.all.must_equal [{:points=>{:x=>2, :r=>18}, :lines=>nil}]
-  end
-
-  it "#graph_each should correctly map values when #set_graph_aliases is used with a third argument for each entry" do
-    @db.fetch = [{:x=>2,:y=>3}]
-    @ds1.graph(:lines, :x=>:id).set_graph_aliases(:x=>[:points, :z1, 2], :y=>[:lines, :z2, Sequel.function(:random)]).all.must_equal [{:points=>{:z1=>2}, :lines=>{:z2=>3}}]
-  end
-
-  it "#graph_each should correctly map values when #set_graph_aliases is used with a single argument for each entry" do
-    @db.fetch = [{:x=>2,:y=>3}]
-    @ds1.graph(:lines, :x=>:id).set_graph_aliases(:x=>[:points], :y=>[:lines]).all.must_equal [{:points=>{:x=>2}, :lines=>{:y=>3}}]
-  end
-
-  it "#graph_each should correctly map values when #set_graph_aliases is used with a symbol for each entry" do
-    @db.fetch = [{:x=>2,:y=>3}]
-    @ds1.graph(:lines, :x=>:id).set_graph_aliases(:x=>:points, :y=>:lines).all.must_equal [{:points=>{:x=>2}, :lines=>{:y=>3}}]
-  end
-
-  it "#graph_each should run the row_proc for graphed datasets" do
-    @db.fetch = {:id=>1,:x=>2,:y=>3,:lines_id=>4,:lines_x=>5,:lines_y=>6,:graph_id=>7}
-    @ds1.with_row_proc(proc{|h| h.keys.each{|k| h[k] *= 2}; h}).graph(@ds2.with_row_proc(proc{|h| h.keys.each{|k| h[k] *= 3}; h}), :x=>:id).all.must_equal [{:points=>{:id=>2, :x=>4, :y=>6}, :lines=>{:id=>12, :x=>15, :y=>18, :graph_id=>21}}]
-  end
-
-  it "#with_sql_each should work normally if the dataset is not graphed" do
-    @db.fetch = {:x=>1}
-    @db.dataset.with_sql_each('SELECT 1 AS x'){|r| r.must_equal(:x=>1)}
-    @db.sqls.must_equal ['SELECT 1 AS x']
-  end
-end

data/spec/extensions/hook_class_methods_spec.rb

@@ -1,402 +0,0 @@
-require_relative "spec_helper"
-
-model_class = proc do |klass, &block|
-  c = Class.new(klass)
-  c.plugin :hook_class_methods
-  c.class_eval(&block) if block
-  c
-end
-
-describe Sequel::Model, "hook_class_methods plugin" do
-  before do
-    DB.reset
-  end
-  
-  it "should freeze hooks when freezing model class" do
-    c = model_class.call Sequel::Model do
-      before_save{adds << 'hi'}
-    end
-    c.freeze
-    hooks = c.instance_variable_get(:@hooks)
-    hooks.frozen?.must_equal true
-    hooks.values.all?(&:frozen?).must_equal true
-  end
-
-  deprecated ".hook_blocks method should yield each hook block" do
-    c = model_class.call Sequel::Model
-    a = []
-    c.hook_blocks(:before_save){|b| a << b}
-    a.must_equal []
-
-    pr = proc{adds << 'hi'}
-    c.before_save(&pr)
-    a = []
-    c.hook_blocks(:before_save){|b| a << b}
-    a.must_equal [pr]
-
-    c.before_save(&pr)
-    a = []
-    c.hook_blocks(:before_save){|b| a << b}
-    a.must_equal [pr, pr]
-
-    a = []
-    c.hook_blocks(:after_save){|b| a << b}
-    a.must_equal []
-  end
-
-  it "should be definable using a block" do
-    adds = []
-    c = model_class.call Sequel::Model do
-      before_save{adds << 'hi'}
-    end
-    
-    c.new.before_save
-    adds.must_equal ['hi']
-  end
-  
-  it "should be definable using a method name" do
-    adds = []
-    c = model_class.call Sequel::Model do
-      define_method(:bye){adds << 'bye'}
-      before_save :bye
-    end
-    
-    c.new.before_save
-    adds.must_equal ['bye']
-  end
-
-  it "should be additive" do
-    adds = []
-    c = model_class.call Sequel::Model do
-      after_save{adds << 'hyiyie'}
-      after_save{adds << 'byiyie'}
-    end
-
-    c.new.after_save
-    adds.must_equal ['hyiyie', 'byiyie']
-  end
-  
-  it "before hooks should run in reverse order" do
-    adds = []
-    c = model_class.call Sequel::Model do
-      before_save{adds << 'hyiyie'}
-      before_save{adds << 'byiyie'}
-    end
-    
-    c.new.before_save
-    adds.must_equal ['byiyie', 'hyiyie']
-  end
-
-  it "should not be additive if the method or tag already exists" do
-    adds = []
-    c = model_class.call Sequel::Model do
-      define_method(:bye){adds << 'bye'}
-      before_save :bye
-      before_save :bye
-    end
-    
-    c.new.before_save
-    adds.must_equal ['bye']
-
-    adds = []
-    d = model_class.call Sequel::Model do
-      before_save(:bye){adds << 'hyiyie'}
-      before_save(:bye){adds << 'byiyie'}
-    end
-    
-    d.new.before_save
-    adds.must_equal ['byiyie']
-
-    adds = []
-    e = model_class.call Sequel::Model do
-      define_method(:bye){adds << 'bye'}
-      before_save :bye
-      before_save(:bye){adds << 'byiyie'}
-    end
-    
-    e.new.before_save
-    adds.must_equal ['byiyie']
-
-    adds = []
-    e = model_class.call Sequel::Model do
-      define_method(:bye){adds << 'bye'}
-      before_save(:bye){adds << 'byiyie'}
-      before_save :bye
-    end
-    
-    e.new.before_save
-    adds.must_equal ['bye']
-  end
-  
-  it "should be inheritable" do
-    adds = []
-    a = model_class.call Sequel::Model 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.must_equal ['123', '456', '789']
-  end
-  
-  it "should be overridable in descendant classes" do
-    adds = []
-    a = model_class.call Sequel::Model do
-      before_save{adds << '123'}
-    end
-    
-    b = Class.new(a)
-    b.class_eval do
-      define_method(:before_save){adds << '456'}
-    end
-    
-    a.new.before_save
-    adds.must_equal ['123']
-    adds = []
-    b.new.before_save
-    adds.must_equal ['456']
-  end
-  
-  it "should stop processing if a before hook calls cancel_action" do
-    flag = true
-    adds = []
-    
-    a = model_class.call Sequel::Model(:items) do
-      before_save{adds << 'cruel'; cancel_action if flag == false}
-      before_save{adds << 'blah'; cancel_action if flag == false}
-    end
-    
-    a.raise_on_save_failure = false
-    a.new.save
-    adds.must_equal ['blah', 'cruel']
-
-    # chain should not break on nil
-    adds = []
-    flag = nil
-    a.new.save
-    adds.must_equal ['blah', 'cruel']
-    
-    adds = []
-    flag = false
-    a.new.save
-    adds.must_equal ['blah']
-    
-    b = Class.new(a)
-    b.class_eval do
-      before_save{adds << 'mau'}
-    end
-    
-    adds = []
-    b.new.save
-    adds.must_equal ['mau', 'blah']
-  end
-end
-
-describe "Model#before_create && Model#after_create" do
-  before do
-    DB.reset
-
-    @c = model_class.call Sequel::Model(:items)  do
-      columns :x
-      no_primary_key
-      
-      after_create {DB << "BLAH after"}
-    end
-  end
-  
-  it "should be called around new record creation" do
-    @c.before_create {DB << "BLAH before"}
-    @c.create(:x => 2)
-    DB.sqls.must_equal ['BLAH before', 'INSERT INTO items (x) VALUES (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
-    @c.before_create{cancel_action}
-    proc{@c.create(:x => 2)}.must_raise(Sequel::HookFailed)
-    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.before_create{cancel_action}
-    @c.raise_on_save_failure = false
-    @c.create(:x => 2).must_be_nil
-    DB.sqls.must_equal []
-  end
-end
-
-describe "Model#before_update && Model#after_update" do
-  before do
-    DB.reset
-
-    @c = model_class.call(Sequel::Model(:items)) do
-      after_update {DB << "BLAH after"}
-    end
-  end
-  
-  it "should be called around record update" do
-    @c.before_update {DB << "BLAH before"}
-    m = @c.load(:id => 2233, :x=>123)
-    m.save
-    DB.sqls.must_equal ['BLAH before', 'UPDATE items SET x = 123 WHERE (id = 2233)', 'BLAH after']
-  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.before_update{cancel_action}
-    proc{@c.load(:id => 2233).save}.must_raise(Sequel::HookFailed)
-    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.before_update{cancel_action}
-    @c.raise_on_save_failure = false
-    @c.load(:id => 2233).save.must_be_nil
-    DB.sqls.must_equal []
-  end
-end
-
-describe "Model#before_save && Model#after_save" do
-  before do
-    DB.reset
-
-    @c = model_class.call(Sequel::Model(:items)) do
-      columns :x
-      after_save {DB << "BLAH after"}
-    end
-  end
-  
-  it "should be called around record update" do
-    @c.before_save {DB << "BLAH before"}
-    m = @c.load(:id => 2233, :x=>123)
-    m.save
-    DB.sqls.must_equal ['BLAH before', 'UPDATE items SET x = 123 WHERE (id = 2233)', 'BLAH after']
-  end
-  
-  it "should be called around record creation" do
-    @c.before_save {DB << "BLAH before"}
-    @c.no_primary_key
-    @c.create(:x => 2)
-    DB.sqls.must_equal ['BLAH before', 'INSERT INTO items (x) VALUES (2)', 'BLAH after']
-  end
-
-  it "#save should cancel the save and raise an error if before_save calls cancel_action and raise_on_save_failure is true" do
-    @c.before_save{cancel_action}
-    proc{@c.load(:id => 2233).save}.must_raise(Sequel::HookFailed)
-    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.before_save{cancel_action}
-    @c.raise_on_save_failure = false
-    @c.load(:id => 2233).save.must_be_nil
-    DB.sqls.must_equal []
-  end
-end
-
-describe "Model#before_destroy && Model#after_destroy" do
-  before do
-    DB.reset
-
-    @c = model_class.call(Sequel::Model(:items)) do
-      after_destroy {DB << "BLAH after"}
-    end
-  end
-  
-  it "should be called around record destruction" do
-    @c.before_destroy {DB << "BLAH before"}
-    m = @c.load(:id => 2233)
-    m.destroy
-    DB.sqls.must_equal ['BLAH before', "DELETE FROM items WHERE id = 2233", 'BLAH after']
-  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.before_destroy{cancel_action}
-    proc{@c.load(:id => 2233).destroy}.must_raise(Sequel::HookFailed)
-    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.before_destroy{cancel_action}
-    @c.raise_on_save_failure = false
-    @c.load(:id => 2233).destroy.must_be_nil
-    DB.sqls.must_equal []
-  end
-end
-
-describe "Model#before_validation && Model#after_validation" do
-  before do
-    DB.reset
-
-    @c = model_class.call(Sequel::Model(:items)) do
-      plugin :validation_class_methods
-      after_validation{DB << "BLAH after"}
-
-      def self.validate(o)
-        o.errors.add(:id, 'not valid') unless o[:id] == 2233
-      end
-      columns :id
-    end
-  end
-  
-  it "should be called around validation" do
-    @c.before_validation{DB << "BLAH before"}
-    m = @c.load(:id => 2233)
-    m.must_be :valid?
-    DB.sqls.must_equal ['BLAH before', 'BLAH after']
-
-    DB.sqls.clear
-    m = @c.load(:id => 22)
-    m.wont_be :valid?
-    DB.sqls.must_equal ['BLAH before', 'BLAH after']
-  end
-
-  it "should be called when calling save" do
-    @c.before_validation{DB << "BLAH before"}
-    m = @c.load(:id => 2233, :x=>123)
-    m.save.must_equal m
-    DB.sqls.must_equal ['BLAH before', 'BLAH after', 'UPDATE items SET x = 123 WHERE (id = 2233)']
-
-    DB.sqls.clear
-    m = @c.load(:id => 22)
-    m.raise_on_save_failure = false
-    m.save.must_be_nil
-    DB.sqls.must_equal ['BLAH before', 'BLAH after']
-  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.before_validation{cancel_action}
-    proc{@c.load(:id => 2233).save}.must_raise(Sequel::HookFailed)
-    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.before_validation{cancel_action}
-    @c.raise_on_save_failure = false
-    @c.load(:id => 2233).save.must_be_nil
-    DB.sqls.must_equal []
-  end
-end
-
-describe "Model.has_hooks?" do
-  before do
-    @c = model_class.call(Sequel::Model(:items))
-  end
-  
-  it "should return false if no hooks are defined" do
-    @c.has_hooks?(:before_save).must_equal false
-  end
-  
-  it "should return true if hooks are defined" do
-    @c.before_save {'blah'}
-    @c.has_hooks?(:before_save).must_equal true
-  end
-  
-  it "should return true if hooks are inherited" do
-    @d = Class.new(@c)
-    @d.has_hooks?(:before_save).must_equal false
-  end
-end