sequel 3.21.0 → 3.31.0

data/spec/extensions/composition_spec.rb

@@ -48,9 +48,10 @@ describe "Composition plugin" do
     @c.composition :date, :composer=>proc{Date.new(year+1, month+2, day+3)}, :decomposer=>proc{[:year, :month, :day].each{|s| self.send("#{s}=", date.send(s) * 2)}}
     @o.date.should == Date.new(2, 4, 6)
     @o.save
-    MODEL_DB.sqls.last.should include("year = 4")
-    MODEL_DB.sqls.last.should include("month = 8")
-    MODEL_DB.sqls.last.should include("day = 12")
+    sql = MODEL_DB.sqls.last
+    sql.should include("year = 4")
+    sql.should include("month = 8")
+    sql.should include("day = 12")
   end
 
   it "should allow call super in composition getter and setter method definition in class" do
@@ -139,8 +140,9 @@ describe "Composition plugin" do
     @o.date.month.should == 6
     @o.date = c.new(3, 4)
     @o.save
-    MODEL_DB.sqls.last.should include("year = 6")
-    MODEL_DB.sqls.last.should include("month = 12")
+    sql = MODEL_DB.sqls.last
+    sql.should include("year = 6")
+    sql.should include("month = 12")
   end
 
   it ":mapping option should work with an array of two pairs of symbols" do
@@ -160,8 +162,9 @@ describe "Composition plugin" do
     @o.date.m.should == 6
     @o.date = c.new(3, 4)
     @o.save
-    MODEL_DB.sqls.last.should include("year = 6")
-    MODEL_DB.sqls.last.should include("month = 12")
+    sql = MODEL_DB.sqls.last
+    sql.should include("year = 6")
+    sql.should include("month = 12")
   end
 
   it ":mapping option :composer should return nil if all values are nil" do
@@ -173,9 +176,10 @@ describe "Composition plugin" do
     @c.composition :date, :mapping=>[:year, :month, :day]
     @o.date = nil
     @o.save
-    MODEL_DB.sqls.last.should include("year = NULL")
-    MODEL_DB.sqls.last.should include("month = NULL")
-    MODEL_DB.sqls.last.should include("day = NULL")
+    sql = MODEL_DB.sqls.last
+    sql.should include("year = NULL")
+    sql.should include("month = NULL")
+    sql.should include("day = NULL")
   end
 
   it "should work correctly with subclasses" do
@@ -184,8 +188,9 @@ describe "Composition plugin" do
     o = c.load(:id=>1, :year=>1, :month=>2, :day=>3)
     o.date.should == Date.new(1, 2, 3)
     o.save
-    MODEL_DB.sqls.last.should include("year = 1")
-    MODEL_DB.sqls.last.should include("month = 2")
-    MODEL_DB.sqls.last.should include("day = 3")
+    sql = MODEL_DB.sqls.last
+    sql.should include("year = 1")
+    sql.should include("month = 2")
+    sql.should include("day = 3")
   end
 end

data/spec/extensions/dataset_associations_spec.rb

@@ -0,0 +1,199 @@
+require File.join(File.dirname(File.expand_path(__FILE__)), "spec_helper")
+
+describe "Sequel::Plugins::DatasetAssociations" do
+  before do
+    @db = Sequel::Database.new
+    @Base = Class.new(Sequel::Model)
+    @Base.plugin :dataset_associations
+
+    @Artist = Class.new(@Base)
+    @Album = Class.new(@Base)
+    @Tag = Class.new(@Base)
+
+    @Artist.meta_def(:name){'Artist'}
+    @Album.meta_def(:name){'Album'}
+    @Tag.meta_def(:name){'Tag'}
+
+    @Artist.dataset = @db[:artists]
+    @Album.dataset = @db[:albums]
+    @Tag.dataset = @db[:tags]
+
+    @Artist.columns :id, :name
+    @Album.columns :id, :name, :artist_id
+    @Tag.columns :id, :name
+
+    @Artist.plugin :many_through_many
+    @Artist.one_to_many :albums, :class=>@Album
+    @Artist.one_to_one :first_album, :class=>@Album
+    @Album.many_to_one :artist, :class=>@Artist
+    @Album.many_to_many :tags, :class=>@Tag
+    @Tag.many_to_many :albums, :class=>@Album
+    @Artist.many_through_many :tags, [[:albums, :artist_id, :id], [:albums_tags, :album_id, :tag_id]], :class=>@Tag
+  end
+
+  it "should work for many_to_one associations" do
+    ds = @Album.artists
+    ds.should be_a_kind_of(Sequel::Dataset)
+    ds.model.should == @Artist
+    ds.sql.should == "SELECT * FROM artists WHERE (artists.id IN (SELECT albums.artist_id FROM albums))"
+  end
+
+  it "should work for one_to_many associations" do
+    ds = @Artist.albums
+    ds.should be_a_kind_of(Sequel::Dataset)
+    ds.model.should == @Album
+    ds.sql.should == "SELECT * FROM albums WHERE (albums.artist_id IN (SELECT artists.id FROM artists))"
+  end
+
+  it "should work for one_to_one associations" do
+    ds = @Artist.first_albums
+    ds.should be_a_kind_of(Sequel::Dataset)
+    ds.model.should == @Album
+    ds.sql.should == "SELECT * FROM albums WHERE (albums.artist_id IN (SELECT artists.id FROM artists))"
+  end
+
+  it "should work for many_to_many associations" do
+    ds = @Album.tags
+    ds.should be_a_kind_of(Sequel::Dataset)
+    ds.model.should == @Tag
+    ds.sql.should == "SELECT tags.* FROM tags WHERE (tags.id IN (SELECT albums_tags.tag_id FROM albums INNER JOIN albums_tags ON (albums_tags.album_id = albums.id)))"
+  end
+
+  it "should work for many_through_many associations" do
+    ds = @Artist.tags
+    ds.should be_a_kind_of(Sequel::Dataset)
+    ds.model.should == @Tag
+    ds.sql.should == "SELECT tags.* FROM tags WHERE (tags.id IN (SELECT albums_tags.tag_id FROM artists INNER JOIN albums ON (albums.artist_id = artists.id) INNER JOIN albums_tags ON (albums_tags.album_id = albums.id)))"
+  end
+
+  it "should have an associated method that takes an association symbol" do
+    ds = @Album.associated(:artist)
+    ds.should be_a_kind_of(Sequel::Dataset)
+    ds.model.should == @Artist
+    ds.sql.should == "SELECT * FROM artists WHERE (artists.id IN (SELECT albums.artist_id FROM albums))"
+  end
+
+  it "should raise an Error if an invalid association is given to associated" do
+    proc{@Album.associated(:foo)}.should raise_error(Sequel::Error)
+  end
+
+  it "should raise an Error if an unrecognized association type is used" do
+    @Album.association_reflection(:artist)[:type] = :foo
+    proc{@Album.artists}.should raise_error(Sequel::Error)
+  end
+
+  it "should work correctly when chaining" do
+    ds = @Artist.albums.tags
+    ds.should be_a_kind_of(Sequel::Dataset)
+    ds.model.should == @Tag
+    ds.sql.should == "SELECT tags.* FROM tags WHERE (tags.id IN (SELECT albums_tags.tag_id FROM albums INNER JOIN albums_tags ON (albums_tags.album_id = albums.id) WHERE (albums.artist_id IN (SELECT artists.id FROM artists))))"
+  end
+
+  it "should deal correctly with filters before the association method" do
+    @Artist.filter(:id=>1).albums.sql.should == "SELECT * FROM albums WHERE (albums.artist_id IN (SELECT artists.id FROM artists WHERE (id = 1)))"
+  end
+
+  it "should deal correctly with filters after the association method" do
+    @Artist.albums.filter(:id=>1).sql.should == "SELECT * FROM albums WHERE ((albums.artist_id IN (SELECT artists.id FROM artists)) AND (id = 1))"
+  end
+
+  it "should deal correctly with block on the association" do
+    @Artist.one_to_many :albums, :clone=>:albums do |ds| ds.filter(:id=>1..100) end
+    @Artist.albums.sql.should == "SELECT * FROM albums WHERE ((albums.artist_id IN (SELECT artists.id FROM artists)) AND (id >= 1) AND (id <= 100))"
+  end
+
+  it "should deal correctly with :conditions option on the association" do
+    @Artist.one_to_many :albums, :clone=>:albums, :conditions=>{:id=>1..100}
+    @Artist.albums.sql.should == "SELECT * FROM albums WHERE ((albums.artist_id IN (SELECT artists.id FROM artists)) AND (id >= 1) AND (id <= 100))"
+  end
+
+  it "should deal correctly with :distinct option on the association" do
+    @Artist.one_to_many :albums, :clone=>:albums, :distinct=>true
+    @Artist.albums.sql.should == "SELECT DISTINCT * FROM albums WHERE (albums.artist_id IN (SELECT artists.id FROM artists))"
+  end
+
+  it "should deal correctly with :eager option on the association" do
+    @Artist.one_to_many :albums, :clone=>:albums, :eager=>:tags
+    @Artist.albums.opts[:eager].should == {:tags=>nil}
+  end
+
+  it "should deal correctly with :eager_block option on the association, ignoring the association block" do
+    @Artist.one_to_many :albums, :clone=>:albums, :eager_block=>proc{|ds| ds.filter(:id=>1..100)} do |ds| ds.filter(:id=>2..200) end
+    @Artist.albums.sql.should == "SELECT * FROM albums WHERE ((albums.artist_id IN (SELECT artists.id FROM artists)) AND (id >= 1) AND (id <= 100))"
+  end
+
+  it "should deal correctly with :extend option on the association" do
+    @Artist.one_to_many :albums, :clone=>:albums, :extend=>Module.new{def foo(x) filter(:id=>x) end}
+    @Artist.albums.foo(1).sql.should == "SELECT * FROM albums WHERE ((albums.artist_id IN (SELECT artists.id FROM artists)) AND (id = 1))"
+  end
+
+  it "should deal correctly with :order option on the association" do
+    @Artist.one_to_many :albums, :clone=>:albums, :order=>:name
+    @Artist.albums.sql.should == "SELECT * FROM albums WHERE (albums.artist_id IN (SELECT artists.id FROM artists)) ORDER BY name"
+  end
+
+  it "should deal correctly with :select option on the association" do
+    @Artist.one_to_many :albums, :clone=>:albums, :select=>[:id, :name]
+    @Artist.albums.sql.should == "SELECT id, name FROM albums WHERE (albums.artist_id IN (SELECT artists.id FROM artists))"
+  end
+end
+
+describe "Sequel::Plugins::DatasetAssociations with composite keys" do
+  before do
+    @db = Sequel::Database.new
+    @Base = Class.new(Sequel::Model)
+    @Base.plugin :dataset_associations
+
+    @Artist = Class.new(@Base)
+    @Album = Class.new(@Base)
+    @Tag = Class.new(@Base)
+
+    @Artist.meta_def(:name){'Artist'}
+    @Album.meta_def(:name){'Album'}
+    @Tag.meta_def(:name){'Tag'}
+
+    @Artist.dataset = @db[:artists]
+    @Album.dataset = @db[:albums]
+    @Tag.dataset = @db[:tags]
+
+    @Artist.set_primary_key([:id1, :id2])
+    @Album.set_primary_key([:id1, :id2])
+    @Tag.set_primary_key([:id1, :id2])
+
+    @Artist.columns :id1, :id2, :name
+    @Album.columns :id1, :id2, :name, :artist_id1, :artist_id2
+    @Tag.columns :id1, :id2, :name
+
+    @Artist.plugin :many_through_many
+    @Artist.one_to_many :albums, :class=>@Album, :key=>[:artist_id1, :artist_id2]
+    @Artist.one_to_one :first_album, :class=>@Album, :key=>[:artist_id1, :artist_id2]
+    @Album.many_to_one :artist, :class=>@Artist, :key=>[:artist_id1, :artist_id2]
+    @Album.many_to_many :tags, :class=>@Tag, :left_key=>[:album_id1, :album_id2], :right_key=>[:tag_id1, :tag_id2]
+    @Tag.many_to_many :albums, :class=>@Album, :right_key=>[:album_id1, :album_id2], :left_key=>[:tag_id1, :tag_id2]
+    @Artist.many_through_many :tags, [[:albums, [:artist_id1, :artist_id2], [:id1, :id2]], [:albums_tags, [:album_id1, :album_id2], [:tag_id1, :tag_id2]]], :class=>@Tag
+  end
+
+  it "should work for many_to_one associations" do
+    @Album.artists.sql.should == "SELECT * FROM artists WHERE ((artists.id1, artists.id2) IN (SELECT albums.artist_id1, albums.artist_id2 FROM albums))"
+  end
+
+  it "should work for one_to_many associations" do
+    @Artist.albums.sql.should == "SELECT * FROM albums WHERE ((albums.artist_id1, albums.artist_id2) IN (SELECT artists.id1, artists.id2 FROM artists))"
+  end
+
+  it "should work for one_to_one associations" do
+    @Artist.first_albums.sql.should == "SELECT * FROM albums WHERE ((albums.artist_id1, albums.artist_id2) IN (SELECT artists.id1, artists.id2 FROM artists))"
+  end
+
+  it "should work for many_to_many associations" do
+    @Album.tags.sql.should == "SELECT tags.* FROM tags WHERE ((tags.id1, tags.id2) IN (SELECT albums_tags.tag_id1, albums_tags.tag_id2 FROM albums INNER JOIN albums_tags ON ((albums_tags.album_id1 = albums.id1) AND (albums_tags.album_id2 = albums.id2))))"
+  end
+
+  it "should work for many_through_many associations" do
+    @Artist.tags.sql.should == "SELECT tags.* FROM tags WHERE ((tags.id1, tags.id2) IN (SELECT albums_tags.tag_id1, albums_tags.tag_id2 FROM artists INNER JOIN albums ON ((albums.artist_id1 = artists.id1) AND (albums.artist_id2 = artists.id2)) INNER JOIN albums_tags ON ((albums_tags.album_id1 = albums.id1) AND (albums_tags.album_id2 = albums.id2))))"
+  end
+
+  it "should work correctly when chaining" do
+    @Artist.albums.tags.sql.should == "SELECT tags.* FROM tags WHERE ((tags.id1, tags.id2) IN (SELECT albums_tags.tag_id1, albums_tags.tag_id2 FROM albums INNER JOIN albums_tags ON ((albums_tags.album_id1 = albums.id1) AND (albums_tags.album_id2 = albums.id2)) WHERE ((albums.artist_id1, albums.artist_id2) IN (SELECT artists.id1, artists.id2 FROM artists))))"
+  end
+end

data/spec/extensions/defaults_setter_spec.rb

@@ -0,0 +1,64 @@
+require File.join(File.dirname(File.expand_path(__FILE__)), "spec_helper")
+
+describe "Sequel::Plugins::DefaultsSetter" do
+  before do
+    @db = db = Sequel::Database.new
+    @c = c = Class.new(Sequel::Model(db[:foo]))
+    @c.instance_variable_set(:@db_schema, {:a=>{}})
+    @c.plugin :defaults_setter
+    @c.columns :a
+    @pr = proc{|x| db.meta_def(:schema){|*| [[:a, {:ruby_default => x}]]}; c.dataset = c.dataset; c}
+  end
+
+  it "should set default value upon initialization" do
+    @pr.call(2).new.values.should == {:a=>2}
+  end
+
+  it "should not mark the column as modified" do
+    @pr.call(2).new.changed_columns.should == []
+  end
+
+  it "should not set a default of nil" do
+    @pr.call(nil).new.values.should == {}
+  end
+
+  it "should not override a given value" do
+    @pr.call(2)
+    @c.new('a'=>3).values.should == {:a=>3}
+    @c.new('a'=>nil).values.should == {:a=>nil}
+  end
+
+  it "should work correctly when subclassing" do
+    Class.new(@pr.call(2)).new.values.should == {:a=>2}
+  end
+
+  it "should contain the default values in default_values" do
+    @pr.call(2).default_values.should == {:a=>2}
+    @pr.call(nil).default_values.should == {}
+  end
+
+  it "should allow modifications of default values" do
+    @pr.call(2)
+    @c.default_values[:a] = 3
+    @c.new.values.should == {:a => 3}
+  end
+
+  it "should allow proc default values" do
+    @pr.call(2)
+    @c.default_values[:a] = proc{3}
+    @c.new.values.should == {:a => 3}
+  end
+
+  it "should have procs that set default values set them to nil" do
+    @pr.call(2)
+    @c.default_values[:a] = proc{nil}
+    @c.new.values.should == {:a => nil}
+  end
+
+  it "should work correctly on a model without a dataset" do
+    @pr.call(2)
+    c = Class.new(Sequel::Model(@db[:bar]))
+    c.plugin :defaults_setter
+    c.default_values.should == {:a=>2}
+  end
+end

data/spec/extensions/hook_class_methods_spec.rb

@@ -6,187 +6,185 @@ describe "Model hooks" do
   end
   
   specify "should be definable using a block" do
-    $adds = []
+    adds = []
     c = Class.new(Sequel::Model)
     c.class_eval do
-      before_save {$adds << 'hi'}
+      before_save{adds << 'hi'}
     end
     
     c.new.before_save
-    $adds.should == ['hi']
+    adds.should == ['hi']
   end
   
   specify "should be definable using a method name" do
-    $adds = []
+    adds = []
     c = Class.new(Sequel::Model)
     c.class_eval do
-      def bye; $adds << 'bye'; end
+      define_method(:bye){adds << 'bye'}
       before_save :bye
     end
     
     c.new.before_save
-    $adds.should == ['bye']
+    adds.should == ['bye']
   end
 
   specify "should be additive" do
-    $adds = []
+    adds = []
     c = Class.new(Sequel::Model)
     c.class_eval do
-      after_save {$adds << 'hyiyie'}
-      after_save {$adds << 'byiyie'}
+      after_save{adds << 'hyiyie'}
+      after_save{adds << 'byiyie'}
     end
 
     c.new.after_save
-    $adds.should == ['hyiyie', 'byiyie']
+    adds.should == ['hyiyie', 'byiyie']
   end
   
   specify "before hooks should run in reverse order" do
-    $adds = []
+    adds = []
     c = Class.new(Sequel::Model)
     c.class_eval do
-      before_save {$adds << 'hyiyie'}
-      before_save {$adds << 'byiyie'}
+      before_save{adds << 'hyiyie'}
+      before_save{adds << 'byiyie'}
     end
     
     c.new.before_save
-    $adds.should == ['byiyie', 'hyiyie']
+    adds.should == ['byiyie', 'hyiyie']
   end
 
   specify "should not be additive if the method or tag already exists" do
-    $adds = []
+    adds = []
     c = Class.new(Sequel::Model)
     c.class_eval do
-      def bye; $adds << 'bye'; end
+      define_method(:bye){adds << 'bye'}
       before_save :bye
       before_save :bye
     end
     
     c.new.before_save
-    $adds.should == ['bye']
+    adds.should == ['bye']
 
-    $adds = []
+    adds = []
     d = Class.new(Sequel::Model)
     d.class_eval do
-      before_save(:bye){$adds << 'hyiyie'}
-      before_save(:bye){$adds << 'byiyie'}
+      before_save(:bye){adds << 'hyiyie'}
+      before_save(:bye){adds << 'byiyie'}
     end
     
     d.new.before_save
-    $adds.should == ['byiyie']
+    adds.should == ['byiyie']
 
-    $adds = []
+    adds = []
     e = Class.new(Sequel::Model)
     e.class_eval do
-      def bye; $adds << 'bye'; end
+      define_method(:bye){adds << 'bye'}
       before_save :bye
-      before_save(:bye){$adds << 'byiyie'}
+      before_save(:bye){adds << 'byiyie'}
     end
     
     e.new.before_save
-    $adds.should == ['byiyie']
+    adds.should == ['byiyie']
 
-    $adds = []
+    adds = []
     e = Class.new(Sequel::Model)
     e.class_eval do
-      def bye; $adds << 'bye'; end
-      before_save(:bye){$adds << 'byiyie'}
+      define_method(:bye){adds << 'bye'}
+      before_save(:bye){adds << 'byiyie'}
       before_save :bye
     end
     
     e.new.before_save
-    $adds.should == ['bye']
+    adds.should == ['bye']
   end
   
   specify "should be inheritable" do
-    # pending
-    
-    $adds = []
+    adds = []
     a = Class.new(Sequel::Model)
     a.class_eval do
-      after_save {$adds << '123'}
+      after_save{adds << '123'}
     end
     
     b = Class.new(a)
     b.class_eval do
-      after_save {$adds << '456'}
-      after_save {$adds << '789'}
+      after_save{adds << '456'}
+      after_save{adds << '789'}
     end
     
     b.new.after_save
-    $adds.should == ['123', '456', '789']
+    adds.should == ['123', '456', '789']
   end
   
   specify "should be overridable in descendant classes" do
-    $adds = []
+    adds = []
     a = Class.new(Sequel::Model)
     a.class_eval do
-      before_save {$adds << '123'}
+      before_save{adds << '123'}
     end
     
     b = Class.new(a)
     b.class_eval do
-      def before_save; $adds << '456'; end
+      define_method(:before_save){adds << '456'}
     end
     
     a.new.before_save
-    $adds.should == ['123']
-    $adds = []
+    adds.should == ['123']
+    adds = []
     b.new.before_save
-    $adds.should == ['456']
+    adds.should == ['456']
   end
   
   specify "should stop processing if a before hook returns false" do
-    $flag = true
-    $adds = []
+    flag = true
+    adds = []
     
     a = Class.new(Sequel::Model)
     a.class_eval do
-      before_save {$adds << 'cruel'; $flag}
-      before_save {$adds << 'blah'; $flag}
+      before_save{adds << 'cruel'; flag}
+      before_save{adds << 'blah'; flag}
     end
     
     a.new.before_save
-    $adds.should == ['blah', 'cruel']
+    adds.should == ['blah', 'cruel']
 
     # chain should not break on nil
-    $adds = []
-    $flag = nil
+    adds = []
+    flag = nil
     a.new.before_save
-    $adds.should == ['blah', 'cruel']
+    adds.should == ['blah', 'cruel']
     
-    $adds = []
-    $flag = false
+    adds = []
+    flag = false
     a.new.before_save
-    $adds.should == ['blah']
+    adds.should == ['blah']
     
     b = Class.new(a)
     b.class_eval do
-      before_save {$adds << 'mau'}
+      before_save{adds << 'mau'}
     end
     
-    $adds = []
+    adds = []
     b.new.before_save
-    $adds.should == ['mau', 'blah']
+    adds.should == ['mau', 'blah']
   end
 end
 
 describe "Model#after_initialize" do
   specify "should be called after initialization" do
-    $values1 = nil
-    $reached_after_initialized = false
+    values1 = nil
+    reached_after_initialized = false
     
     a = Class.new(Sequel::Model)
     a.class_eval do
       columns :x, :y
       after_initialize do
-        $values1 = @values.clone
-        $reached_after_initialized = true
+        values1 = @values.clone
+        reached_after_initialized = true
       end
     end
     
     a.new(:x => 1, :y => 2)
-    $values1.should == {:x => 1, :y => 2}
-    $reached_after_initialized.should == true
+    values1.should == {:x => 1, :y => 2}
+    reached_after_initialized.should == true
   end
 end
 
@@ -206,11 +204,7 @@ describe "Model#before_create && Model#after_create" do
   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',
-      'INSERT INTO items (x) VALUES (2)',
-      'BLAH after'
-    ]
+    MODEL_DB.sqls.should == ['BLAH before', 'INSERT INTO items (x) VALUES (2)', 'BLAH after']
   end
 
   specify ".create should cancel the save and raise an error if before_create returns false and raise_on_save_failure is true" do
@@ -242,11 +236,7 @@ describe "Model#before_update && Model#after_update" do
     @c.before_update {MODEL_DB << "BLAH before"}
     m = @c.load(:id => 2233, :x=>123)
     m.save
-    MODEL_DB.sqls.should == [
-      'BLAH before',
-      'UPDATE items SET x = 123 WHERE (id = 2233)',
-      'BLAH after'
-    ]
+    MODEL_DB.sqls.should == ['BLAH before', 'UPDATE items SET x = 123 WHERE (id = 2233)', 'BLAH after']
   end
 
   specify "#save should cancel the save and raise an error if before_update returns false and raise_on_save_failure is true" do
@@ -279,22 +269,14 @@ describe "Model#before_save && Model#after_save" do
     @c.before_save {MODEL_DB << "BLAH before"}
     m = @c.load(:id => 2233, :x=>123)
     m.save
-    MODEL_DB.sqls.should == [
-      'BLAH before',
-      'UPDATE items SET x = 123 WHERE (id = 2233)',
-      'BLAH after'
-    ]
+    MODEL_DB.sqls.should == ['BLAH before', 'UPDATE items SET x = 123 WHERE (id = 2233)', 'BLAH after']
   end
   
   specify "should be called around record creation" do
     @c.before_save {MODEL_DB << "BLAH before"}
     @c.no_primary_key
     @c.create(:x => 2)
-    MODEL_DB.sqls.should == [
-      'BLAH before',
-      'INSERT INTO items (x) VALUES (2)',
-      'BLAH after'
-    ]
+    MODEL_DB.sqls.should == ['BLAH before', 'INSERT INTO items (x) VALUES (2)', 'BLAH after']
   end
 
   specify "#save should cancel the save and raise an error if before_save returns false and raise_on_save_failure is true" do
@@ -319,10 +301,6 @@ describe "Model#before_destroy && Model#after_destroy" do
     @c = Class.new(Sequel::Model(:items))
     @c.class_eval do
       after_destroy {MODEL_DB << "BLAH after"}
-      
-      def delete
-        MODEL_DB << "DELETE BLAH"
-      end
     end
   end
   
@@ -330,11 +308,7 @@ describe "Model#before_destroy && Model#after_destroy" do
     @c.before_destroy {MODEL_DB << "BLAH before"}
     m = @c.load(:id => 2233)
     m.destroy
-    MODEL_DB.sqls.should == [
-      'BLAH before',
-      'DELETE BLAH',
-      'BLAH after'
-    ]
+    MODEL_DB.sqls.should == ['BLAH before', "DELETE FROM items WHERE (id = 2233)", 'BLAH after']
   end
 
   specify "#destroy should cancel the destroy and raise an error if before_destroy returns false and raise_on_save_failure is true" do