sequel 3.21.0 → 3.31.0

data/spec/extensions/migration_spec.rb

@@ -195,14 +195,14 @@ end
 
 describe "Sequel::IntegerMigrator" do
   before do
-    dbc = Class.new(MockDatabase) do
+    dbc = Class.new(Sequel::Mock::Database) do
       attr_reader :drops, :tables_created, :columns_created, :versions
       def initialize(*args)
         super
         @drops = []
         @tables_created = []
         @columns_created = []
-        @versions = {}
+        @versions = Hash.new{|h,k| h[k.to_sym]}
       end
   
       def version; versions.values.first || 0; end
@@ -211,8 +211,8 @@ describe "Sequel::IntegerMigrator" do
 
       def create_table(name, opts={}, &block)
         super
-        @columns_created << / \(?(\w+) integer.*\)?\z/.match(sqls.last)[1].to_sym
-        @tables_created << name
+        @columns_created << / \(?(\w+) integer.*\)?\z/.match(@sqls.last)[1].to_sym
+        @tables_created << name.to_sym
       end
       
       def dataset(opts={})
@@ -220,15 +220,15 @@ describe "Sequel::IntegerMigrator" do
         ds.extend(Module.new do
           def count; 1; end
           def columns; db.columns_created end
-          def insert(h); db.versions.merge!(h); db.sqls << insert_sql(h) end
-          def update(h); db.versions.merge!(h); db.sqls << update_sql(h) end
+          def insert(h); db.versions.merge!(h); db.run insert_sql(h) end
+          def update(h); db.versions.merge!(h); db.run update_sql(h) end
           def fetch_rows(sql); db.execute(sql); yield(db.versions) unless db.versions.empty? end
         end)
         ds
       end
 
       def table_exists?(name)
-        @tables_created.include?(name)
+        @tables_created.include?(name.to_sym)
       end
     end
     @db = dbc.new
@@ -250,7 +250,7 @@ describe "Sequel::IntegerMigrator" do
 
   specify "should add a column name if it doesn't already exist in the schema_info table" do
     @db.create_table(:schema_info){Integer :v}
-    @db.should_receive(:alter_table).with(:schema_info)
+    @db.should_receive(:alter_table).with('schema_info')
     Sequel::Migrator.apply(@db, @dirname)
   end
 
@@ -315,60 +315,63 @@ end
 
 describe "Sequel::TimestampMigrator" do
   before do
-    $sequel_migration_version = 0
-    $sequel_migration_files = []
-    @dsc = dsc = Class.new(MockDataset) do
+    sequel_migration_version = 0
+    @dsc = dsc = Class.new(Sequel::Mock::Dataset) do
+      self::FILES =[]
+      define_method(:sequel_migration_version){sequel_migration_version}
+      define_method(:sequel_migration_version=){|v| sequel_migration_version = v}
+
       def columns
         case opts[:from].first
-        when :schema_info
+        when :schema_info, 'schema_info'
           [:version]
-        when :schema_migrations
+        when :schema_migrations, 'schema_migrations'
           [:filename]
-        when :sm
+        when :sm, 'sm'
           [:fn]
         end
       end
 
       def fetch_rows(sql)
         case opts[:from].first
-        when :schema_info
-          yield({:version=>$sequel_migration_version})
-        when :schema_migrations
-          $sequel_migration_files.sort.each{|f| yield(:filename=>f)}
-        when :sm
-          $sequel_migration_files.sort.each{|f| yield(:fn=>f)}
+        when :schema_info, 'schema_info'
+          yield({:version=>sequel_migration_version})
+        when :schema_migrations, 'schema_migrations'
+          self.class::FILES.sort.each{|f| yield(:filename=>f)}
+        when :sm, 'sm'
+          self.class::FILES.sort.each{|f| yield(:fn=>f)}
         end
       end
 
       def insert(h={})
         case opts[:from].first
-        when :schema_info
-          $sequel_migration_version = h.values.first
-        when :schema_migrations, :sm
-          $sequel_migration_files << h.values.first
+        when :schema_info, 'schema_info'
+          self.sequel_migration_version = h.values.first
+        when :schema_migrations, :sm, 'schema_migrations', 'sm'
+          self.class::FILES << h.values.first
         end
       end
 
       def update(h={})
         case opts[:from].first
-        when :schema_info
-          $sequel_migration_version = h.values.first
+        when :schema_info, 'schema_info'
+          self.sequel_migration_version = h.values.first
         end
       end
 
       def delete
         case opts[:from].first
-        when :schema_migrations, :sm
-          $sequel_migration_files.delete(opts[:where].args.last)
+        when :schema_migrations, :sm, 'schema_migrations', 'sm'
+          self.class::FILES.delete(opts[:where].args.last)
         end
       end
     end
-    dbc = Class.new(MockDatabase) do
+    dbc = Class.new(Sequel::Mock::Database) do
       tables = {}
       define_method(:dataset){|*a| dsc.new(self, *a)}
-      define_method(:create_table){|name, *args| tables[name] = true}
-      define_method(:drop_table){|*names| names.each{|n| tables.delete(n)}}
-      define_method(:table_exists?){|name| tables.has_key?(name)}
+      define_method(:create_table){|name, *args| tables[name.to_sym] = true}
+      define_method(:drop_table){|*names| names.each{|n| tables.delete(n.to_sym)}}
+      define_method(:table_exists?){|name| tables.has_key?(name.to_sym)}
     end
     @db = dbc.new
     @m = Sequel::Migrator

data/spec/extensions/named_timezones_spec.rb

@@ -12,7 +12,7 @@ describe "Sequel named_timezones extension" do
   before do
     @tz_in = TZInfo::Timezone.get('America/Los_Angeles')
     @tz_out = TZInfo::Timezone.get('America/New_York')
-    @db = MockDatabase.new
+    @db = Sequel.mock
     @dt = DateTime.civil(2009,6,1,10,20,30,0)
     Sequel.application_timezone = 'America/Los_Angeles'
     Sequel.database_timezone = 'America/New_York'
@@ -66,8 +66,28 @@ describe "Sequel named_timezones extension" do
   end
   
   it "should work with the thread_local_timezones extension" do
-    [Thread.new{Sequel.thread_application_timezone = 'America/New_York'; sleep 0.03; Sequel.application_timezone.should == @tz_out},
-     Thread.new{sleep 0.01; Sequel.thread_application_timezone = 'America/Los_Angeles'; sleep 0.01; Sequel.application_timezone.should == @tz_in}].each{|x| x.join}
+    q, q1, q2 = Queue.new, Queue.new, Queue.new
+    tz1, tz2 = nil, nil
+    t1 = Thread.new do
+      Sequel.thread_application_timezone = 'America/New_York'
+      q2.push nil
+      q.pop
+      tz1 = Sequel.application_timezone
+    end
+    t2 = Thread.new do
+      Sequel.thread_application_timezone = 'America/Los_Angeles'
+      q2.push nil
+      q1.pop
+      tz2 = Sequel.application_timezone
+    end
+    q2.pop
+    q2.pop
+    q.push nil
+    q1.push nil
+    t1.join
+    t2.join
+    tz1.should == @tz_out
+    tz2.should == @tz_in
   end
 end
 end

data/spec/extensions/nested_attributes_spec.rb

@@ -1,46 +1,30 @@
 require File.join(File.dirname(File.expand_path(__FILE__)), "spec_helper")
 
 describe "NestedAttributes plugin" do
-  before do
-    mods = @mods = []
-    i = 0
-    gi = lambda{i}
-    ii = lambda{i+=1}
-    ds_mod = Module.new do
-      def empty?; false; end
-      define_method(:insert) do |h|
-        x = ii.call
-        mods << [:i, first_source, h, x]
-        x
-      end
-      define_method(:insert_select) do |h|
-        x = ii.call
-        mods << [:is, first_source, h, x]
-        h.merge(:id=>x)
-      end
-      define_method(:update) do |h|
-        mods << [:u, first_source, h, literal(opts[:where])]
-        1
-      end
-      define_method(:delete) do
-        mods << [:d, first_source, literal(opts[:where])]
-        1
-      end
-    end
-    db = Sequel::Database.new({})
-    db.meta_def(:dataset) do |*a|
-      x = super(*a)
-      x.extend(ds_mod)
-      x
+  def check_sqls(should, is)
+    if should.is_a?(Array)
+      should.should include(is)
+    else
+      should.should == is
     end
-    @c = Class.new(Sequel::Model(db))
+  end
+
+  def check_sql_array(*shoulds)
+    sqls = @db.sqls
+    shoulds.length.should == sqls.length
+    shoulds.zip(sqls){|s, i| check_sqls(s, i)}
+  end
+
+  before do
+    @db = Sequel.mock(:autoid=>1, :numrows=>1)
+    @c = Class.new(Sequel::Model(@db))
     @c.plugin :nested_attributes
     @Artist = Class.new(@c).set_dataset(:artists)
     @Album = Class.new(@c).set_dataset(:albums)
     @Tag = Class.new(@c).set_dataset(:tags)
-    [@Artist, @Album, @Tag].each do |m|
-      m.dataset.extend(ds_mod)
-    end
+    @Artist.plugin :skip_create_refresh
+    @Album.plugin :skip_create_refresh
+    @Tag.plugin :skip_create_refresh
     @Artist.columns :id, :name
     @Album.columns :id, :name, :artist_id
     @Tag.columns :id, :name
@@ -50,36 +34,44 @@ describe "NestedAttributes plugin" do
     @Album.many_to_many :tags, :class=>@Tag, :left_key=>:album_id, :right_key=>:tag_id, :join_table=>:at
     @Artist.nested_attributes :albums, :first_album, :destroy=>true, :remove=>true
     @Album.nested_attributes :artist, :tags, :destroy=>true, :remove=>true
+    @db.sqls
   end
   
   it "should support creating new many_to_one objects" do
     a = @Album.new({:name=>'Al', :artist_attributes=>{:name=>'Ar'}})
-    @mods.should == []
+    @db.sqls.should == []
     a.save
-    @mods.should == [[:is, :artists, {:name=>"Ar"}, 1], [:is, :albums, {:name=>"Al", :artist_id=>1}, 2]]
+    check_sql_array("INSERT INTO artists (name) VALUES ('Ar')",
+      ["INSERT INTO albums (name, artist_id) VALUES ('Al', 1)", "INSERT INTO albums (artist_id, name) VALUES (1, 'Al')"])
   end
   
   it "should support creating new one_to_one objects" do
     a = @Artist.new(:name=>'Ar')
     a.id = 1
     a.first_album_attributes = {:name=>'Al'}
-    @mods.should == []
+    @db.sqls.should == []
     a.save
-    @mods.should == [[:is, :artists, {:name=>"Ar", :id=>1}, 1], [:is, :albums, {:name=>"Al"}, 2], [:u, :albums, {:artist_id=>nil}, "((artist_id = 1) AND (id != 2))"], [:u, :albums, {:name=>"Al", :artist_id=>1}, "(id = 2)"]]
+    check_sql_array(["INSERT INTO artists (name, id) VALUES ('Ar', 1)", "INSERT INTO artists (id, name) VALUES (1, 'Ar')"],
+      "INSERT INTO albums (name) VALUES ('Al')",
+      "UPDATE albums SET artist_id = NULL WHERE ((artist_id = 1) AND (id != 2))",
+      ["UPDATE albums SET artist_id = 1, name = 'Al' WHERE (id = 2)", "UPDATE albums SET name = 'Al', artist_id = 1 WHERE (id = 2)"])
   end
   
   it "should support creating new one_to_many objects" do
     a = @Artist.new({:name=>'Ar', :albums_attributes=>[{:name=>'Al'}]})
-    @mods.should == []
+    @db.sqls.should == []
     a.save
-    @mods.should == [[:is, :artists, {:name=>"Ar"}, 1], [:is, :albums, {:name=>"Al", :artist_id=>1}, 2]]
+    check_sql_array("INSERT INTO artists (name) VALUES ('Ar')",
+      ["INSERT INTO albums (artist_id, name) VALUES (1, 'Al')", "INSERT INTO albums (name, artist_id) VALUES ('Al', 1)"])
   end
   
   it "should support creating new many_to_many objects" do
     a = @Album.new({:name=>'Al', :tags_attributes=>[{:name=>'T'}]})
-    @mods.should == []
+    @db.sqls.should == []
     a.save
-    @mods.should == [[:is, :albums, {:name=>"Al"}, 1], [:is, :tags, {:name=>"T"}, 2], [:i, :at, {:album_id=>1, :tag_id=>2}, 3]]
+    check_sql_array("INSERT INTO albums (name) VALUES ('Al')",
+      "INSERT INTO tags (name) VALUES ('T')",
+      ["INSERT INTO at (album_id, tag_id) VALUES (1, 2)", "INSERT INTO at (tag_id, album_id) VALUES (2, 1)"])
   end
   
   it "should add new objects to the cached association array as soon as the *_attributes= method is called" do
@@ -93,9 +85,9 @@ describe "NestedAttributes plugin" do
     ar = @Artist.load(:id=>20, :name=>'Ar')
     al.associations[:artist] = ar
     al.set(:artist_attributes=>{:id=>'20', :name=>'Ar2'})
-    @mods.should == []
+    @db.sqls.should == []
     al.save
-    @mods.should == [[:u, :albums, {:name=>"Al"}, '(id = 10)'], [:u, :artists, {:name=>"Ar2"}, '(id = 20)']]
+    @db.sqls.should == ["UPDATE albums SET name = 'Al' WHERE (id = 10)", "UPDATE artists SET name = 'Ar2' WHERE (id = 20)"]
   end
   
   it "should support updating one_to_one objects" do
@@ -103,9 +95,9 @@ describe "NestedAttributes plugin" do
     ar = @Artist.load(:id=>20, :name=>'Ar')
     ar.associations[:first_album] = al
     ar.set(:first_album_attributes=>{:id=>10, :name=>'Al2'})
-    @mods.should == []
+    @db.sqls.should == []
     ar.save
-    @mods.should == [[:u, :artists, {:name=>"Ar"}, '(id = 20)'], [:u, :albums, {:name=>"Al2"}, '(id = 10)']]
+    @db.sqls.should == ["UPDATE artists SET name = 'Ar' WHERE (id = 20)", "UPDATE albums SET name = 'Al2' WHERE (id = 10)"]
   end
   
   it "should support updating one_to_many objects" do
@@ -113,9 +105,9 @@ describe "NestedAttributes plugin" do
     ar = @Artist.load(:id=>20, :name=>'Ar')
     ar.associations[:albums] = [al]
     ar.set(:albums_attributes=>[{:id=>10, :name=>'Al2'}])
-    @mods.should == []
+    @db.sqls.should == []
     ar.save
-    @mods.should == [[:u, :artists, {:name=>"Ar"}, '(id = 20)'], [:u, :albums, {:name=>"Al2"}, '(id = 10)']]
+    @db.sqls.should == ["UPDATE artists SET name = 'Ar' WHERE (id = 20)", "UPDATE albums SET name = 'Al2' WHERE (id = 10)"]
   end
   
   it "should support updating many_to_many objects" do
@@ -123,9 +115,9 @@ describe "NestedAttributes plugin" do
     t = @Tag.load(:id=>20, :name=>'T')
     a.associations[:tags] = [t]
     a.set(:tags_attributes=>[{:id=>20, :name=>'T2'}])
-    @mods.should == []
+    @db.sqls.should == []
     a.save
-    @mods.should == [[:u, :albums, {:name=>"Al"}, '(id = 10)'], [:u, :tags, {:name=>"T2"}, '(id = 20)']]
+    @db.sqls.should == ["UPDATE albums SET name = 'Al' WHERE (id = 10)", "UPDATE tags SET name = 'T2' WHERE (id = 20)"]
   end
   
   it "should support removing many_to_one objects" do
@@ -133,9 +125,9 @@ describe "NestedAttributes plugin" do
     ar = @Artist.load(:id=>20, :name=>'Ar')
     al.associations[:artist] = ar
     al.set(:artist_attributes=>{:id=>'20', :_remove=>'1'})
-    @mods.should == []
+    @db.sqls.should == []
     al.save
-    @mods.should == [[:u, :albums, {:artist_id=>nil, :name=>'Al'}, '(id = 10)']]
+    check_sql_array(["UPDATE albums SET artist_id = NULL, name = 'Al' WHERE (id = 10)", "UPDATE albums SET name = 'Al', artist_id = NULL WHERE (id = 10)"])
   end
   
   it "should support removing one_to_one objects" do
@@ -143,10 +135,9 @@ describe "NestedAttributes plugin" do
     ar = @Artist.load(:id=>20, :name=>'Ar')
     ar.associations[:first_album] = al
     ar.set(:first_album_attributes=>{:id=>10, :_remove=>'t'})
-    @mods.should == []
+    @db.sqls.should == []
     ar.save
-    @mods.should == [[:u, :albums, {:artist_id=>nil}, "(artist_id = 20)"], [:u, :artists, {:name=>"Ar"}, "(id = 20)"]]
-    
+    @db.sqls.should == ["UPDATE albums SET artist_id = NULL WHERE (artist_id = 20)", "UPDATE artists SET name = 'Ar' WHERE (id = 20)"]
   end
   
   it "should support removing one_to_many objects" do
@@ -154,9 +145,12 @@ describe "NestedAttributes plugin" do
     ar = @Artist.load(:id=>20, :name=>'Ar')
     ar.associations[:albums] = [al]
     ar.set(:albums_attributes=>[{:id=>10, :_remove=>'t'}])
-    @mods.should == []
+    @db.sqls.should == []
+    @Album.dataset._fetch = {:id=>1}
     ar.save
-    @mods.should == [[:u, :albums, {:name=>"Al", :artist_id=>nil}, '(id = 10)'], [:u, :artists, {:name=>"Ar"}, '(id = 20)']]
+    check_sql_array("SELECT 1 AS one FROM albums WHERE ((albums.artist_id = 20) AND (id = 10)) LIMIT 1",
+      ["UPDATE albums SET artist_id = NULL, name = 'Al' WHERE (id = 10)", "UPDATE albums SET name = 'Al', artist_id = NULL WHERE (id = 10)"],
+      "UPDATE artists SET name = 'Ar' WHERE (id = 20)")
   end
   
   it "should support removing many_to_many objects" do
@@ -164,9 +158,9 @@ describe "NestedAttributes plugin" do
     t = @Tag.load(:id=>20, :name=>'T')
     a.associations[:tags] = [t]
     a.set(:tags_attributes=>[{:id=>20, :_remove=>true}])
-    @mods.should == []
+    @db.sqls.should == []
     a.save
-    @mods.should == [[:d, :at, '((album_id = 10) AND (tag_id = 20))'], [:u, :albums, {:name=>"Al"}, '(id = 10)']]
+    @db.sqls.should == ["DELETE FROM at WHERE ((album_id = 10) AND (tag_id = 20))", "UPDATE albums SET name = 'Al' WHERE (id = 10)"]
   end
   
   it "should support destroying many_to_one objects" do
@@ -174,9 +168,10 @@ describe "NestedAttributes plugin" do
     ar = @Artist.load(:id=>20, :name=>'Ar')
     al.associations[:artist] = ar
     al.set(:artist_attributes=>{:id=>'20', :_delete=>'1'})
-    @mods.should == []
+    @db.sqls.should == []
     al.save
-    @mods.should == [[:u, :albums, {:artist_id=>nil, :name=>'Al'}, '(id = 10)'], [:d, :artists, '(id = 20)']]
+    check_sql_array(["UPDATE albums SET artist_id = NULL, name = 'Al' WHERE (id = 10)", "UPDATE albums SET name = 'Al', artist_id = NULL WHERE (id = 10)"],
+      "DELETE FROM artists WHERE (id = 20)")
   end
   
   it "should support destroying one_to_one objects" do
@@ -184,9 +179,9 @@ describe "NestedAttributes plugin" do
     ar = @Artist.load(:id=>20, :name=>'Ar')
     ar.associations[:first_album] = al
     ar.set(:first_album_attributes=>{:id=>10, :_delete=>'t'})
-    @mods.should == []
+    @db.sqls.should == []
     ar.save
-    @mods.should == [[:u, :artists, {:name=>"Ar"}, "(id = 20)"], [:d, :albums, "(id = 10)"]]
+    @db.sqls.should == ["UPDATE artists SET name = 'Ar' WHERE (id = 20)", "DELETE FROM albums WHERE (id = 10)"]
   end
   
   it "should support destroying one_to_many objects" do
@@ -194,9 +189,9 @@ describe "NestedAttributes plugin" do
     ar = @Artist.load(:id=>20, :name=>'Ar')
     ar.associations[:albums] = [al]
     ar.set(:albums_attributes=>[{:id=>10, :_delete=>'t'}])
-    @mods.should == []
+    @db.sqls.should == []
     ar.save
-    @mods.should == [[:u, :artists, {:name=>"Ar"}, '(id = 20)'], [:d, :albums, '(id = 10)']]
+    @db.sqls.should == ["UPDATE artists SET name = 'Ar' WHERE (id = 20)", "DELETE FROM albums WHERE (id = 10)"]
   end
   
   it "should support destroying many_to_many objects" do
@@ -204,9 +199,9 @@ describe "NestedAttributes plugin" do
     t = @Tag.load(:id=>20, :name=>'T')
     a.associations[:tags] = [t]
     a.set(:tags_attributes=>[{:id=>20, :_delete=>true}])
-    @mods.should == []
+    @db.sqls.should == []
     a.save
-    @mods.should == [[:d, :at, '((album_id = 10) AND (tag_id = 20))'], [:u, :albums, {:name=>"Al"}, '(id = 10)'], [:d, :tags, '(id = 20)']]
+    @db.sqls.should == ["DELETE FROM at WHERE ((album_id = 10) AND (tag_id = 20))", "UPDATE albums SET name = 'Al' WHERE (id = 10)", "DELETE FROM tags WHERE (id = 20)"]
   end
   
   it "should support both string and symbol keys in nested attribute hashes" do
@@ -214,9 +209,9 @@ describe "NestedAttributes plugin" do
     t = @Tag.load(:id=>20, :name=>'T')
     a.associations[:tags] = [t]
     a.set('tags_attributes'=>[{'id'=>20, '_delete'=>true}])
-    @mods.should == []
+    @db.sqls.should == []
     a.save
-    @mods.should == [[:d, :at, '((album_id = 10) AND (tag_id = 20))'], [:u, :albums, {:name=>"Al"}, '(id = 10)'], [:d, :tags, '(id = 20)']]
+    @db.sqls.should == ["DELETE FROM at WHERE ((album_id = 10) AND (tag_id = 20))", "UPDATE albums SET name = 'Al' WHERE (id = 10)", "DELETE FROM tags WHERE (id = 20)"]
   end
   
   it "should support using a hash instead of an array for to_many nested attributes" do
@@ -224,9 +219,9 @@ describe "NestedAttributes plugin" do
     t = @Tag.load(:id=>20, :name=>'T')
     a.associations[:tags] = [t]
     a.set('tags_attributes'=>{'1'=>{'id'=>20, '_delete'=>true}})
-    @mods.should == []
+    @db.sqls.should == []
     a.save
-    @mods.should == [[:d, :at, '((album_id = 10) AND (tag_id = 20))'], [:u, :albums, {:name=>"Al"}, '(id = 10)'], [:d, :tags, '(id = 20)']]
+    @db.sqls.should == ["DELETE FROM at WHERE ((album_id = 10) AND (tag_id = 20))", "UPDATE albums SET name = 'Al' WHERE (id = 10)", "DELETE FROM tags WHERE (id = 20)"]
   end
   
   it "should only allow destroying associated objects if :destroy option is used in the nested_attributes call" do
@@ -263,9 +258,9 @@ describe "NestedAttributes plugin" do
     ar = @Artist.load(:id=>20, :name=>'Ar')
     ar.associations[:albums] = [al]
     ar.set(:albums_attributes=>[{:id=>30, :_delete=>'t'}])
-    @mods.should == []
+    @db.sqls.should == []
     ar.save
-    @mods.should == [[:u, :artists, {:name=>"Ar"}, '(id = 20)']]
+    @db.sqls.should == ["UPDATE artists SET name = 'Ar' WHERE (id = 20)"]
   end
   
   it "should not save if nested attribute is not valid and should include nested attribute validation errors in the main object's validation errors" do
@@ -276,10 +271,10 @@ describe "NestedAttributes plugin" do
       end
     end
     a = @Album.new(:name=>'Al', :artist_attributes=>{:name=>'Ar'})
-    @mods.should == []
+    @db.sqls.should == []
     proc{a.save}.should raise_error(Sequel::ValidationFailed)
     a.errors.full_messages.should == ['artist name cannot be Ar']
-    @mods.should == []
+    @db.sqls.should == []
     # Should preserve attributes
     a.artist.name.should == 'Ar'
   end
@@ -294,9 +289,10 @@ describe "NestedAttributes plugin" do
       end
     end
     a = @Album.new(:name=>'Al', :artist_attributes=>{:name=>'Ar'})
-    @mods.should == []
+    @db.sqls.should == []
     a.save
-    @mods.should == [[:is, :artists, {:name=>"Ar"}, 1], [:is, :albums, {:name=>"Al", :artist_id=>1}, 2]]
+    check_sql_array("INSERT INTO artists (name) VALUES ('Ar')",
+      ["INSERT INTO albums (artist_id, name) VALUES (1, 'Al')", "INSERT INTO albums (name, artist_id) VALUES ('Al', 1)"])
   end
   
   it "should not attempt to validate nested attributes if the :validate=>false option is passed to save" do
@@ -307,23 +303,25 @@ describe "NestedAttributes plugin" do
       end
     end
     a = @Album.new(:name=>'Al', :artist_attributes=>{:name=>'Ar'})
-    @mods.should == []
+    @db.sqls.should == []
     a.save(:validate=>false)
-    @mods.should == [[:is, :artists, {:name=>"Ar"}, 1], [:is, :albums, {:name=>"Al", :artist_id=>1}, 2]]
+    check_sql_array("INSERT INTO artists (name) VALUES ('Ar')",
+      ["INSERT INTO albums (artist_id, name) VALUES (1, 'Al')", "INSERT INTO albums (name, artist_id) VALUES ('Al', 1)"])
   end
   
   it "should not accept nested attributes unless explicitly specified" do
     @Artist.many_to_many :tags, :class=>@Tag, :left_key=>:album_id, :right_key=>:tag_id, :join_table=>:at
     proc{@Artist.create({:name=>'Ar', :tags_attributes=>[{:name=>'T'}]})}.should raise_error(Sequel::Error)
-    @mods.should == []
+    @db.sqls.should == []
   end
   
   it "should save when save_changes or update is called if nested attribute associated objects changed but there are no changes to the main object" do
     al = @Album.load(:id=>10, :name=>'Al')
     ar = @Artist.load(:id=>20, :name=>'Ar')
     al.associations[:artist] = ar
+    @db.sqls.should == []
     al.update(:artist_attributes=>{:id=>'20', :name=>'Ar2'})
-    @mods.should == [[:u, :artists, {:name=>"Ar2"}, '(id = 20)']]
+    @db.sqls.should == ["UPDATE artists SET name = 'Ar2' WHERE (id = 20)"]
   end
   
   it "should have a :limit option limiting the amount of entries" do
@@ -331,17 +329,25 @@ describe "NestedAttributes plugin" do
     arr = [{:name=>'T'}]
     proc{@Album.new({:name=>'Al', :tags_attributes=>arr*3})}.should raise_error(Sequel::Error)
     a = @Album.new({:name=>'Al', :tags_attributes=>arr*2})
-    @mods.should == []
+    @db.sqls.should == []
     a.save
-    @mods.should == [[:is, :albums, {:name=>"Al"}, 1], [:is, :tags, {:name=>"T"}, 2], [:i, :at, {:album_id=>1, :tag_id=>2}, 3], [:is, :tags, {:name=>"T"}, 4], [:i, :at, {:album_id=>1, :tag_id=>4}, 5]]
+    check_sql_array("INSERT INTO albums (name) VALUES ('Al')",
+      "INSERT INTO tags (name) VALUES ('T')",
+      ["INSERT INTO at (album_id, tag_id) VALUES (1, 2)", "INSERT INTO at (tag_id, album_id) VALUES (2, 1)"],
+      "INSERT INTO tags (name) VALUES ('T')",
+      ["INSERT INTO at (album_id, tag_id) VALUES (1, 4)", "INSERT INTO at (tag_id, album_id) VALUES (4, 1)"])
   end
   
   it "should accept a block that each hash gets passed to determine if it should be processed" do
     @Album.nested_attributes(:tags){|h| h[:name].empty?}
     a = @Album.new({:name=>'Al', :tags_attributes=>[{:name=>'T'}, {:name=>''}, {:name=>'T2'}]})
-    @mods.should == []
+    @db.sqls.should == []
     a.save
-    @mods.should == [[:is, :albums, {:name=>"Al"}, 1], [:is, :tags, {:name=>"T"}, 2], [:i, :at, {:album_id=>1, :tag_id=>2}, 3], [:is, :tags, {:name=>"T2"}, 4], [:i, :at, {:album_id=>1, :tag_id=>4}, 5]]
+    check_sql_array("INSERT INTO albums (name) VALUES ('Al')",
+      "INSERT INTO tags (name) VALUES ('T')",
+      ["INSERT INTO at (album_id, tag_id) VALUES (1, 2)", "INSERT INTO at (tag_id, album_id) VALUES (2, 1)"],
+      "INSERT INTO tags (name) VALUES ('T2')",
+      ["INSERT INTO at (album_id, tag_id) VALUES (1, 4)", "INSERT INTO at (tag_id, album_id) VALUES (4, 1)"])
   end
   
   it "should return objects created/modified in the internal methods" do
@@ -387,9 +393,12 @@ describe "NestedAttributes plugin" do
     t = @Tag.load(:id=>30, :name=>'T', :number=>10)
     al.associations[:tags] = [t]
     al.set(:tags_attributes=>[{:id=>30, :name=>'T2'}, {:name=>'T3'}])
-    @mods.should == []
+    @db.sqls.should == []
     al.save
-    @mods.should == [[:u, :albums, {:name=>'Al'}, '(id = 10)'], [:u, :tags, {:name=>'T2'}, '(id = 30)'], [:is, :tags, {:name=>"T3"}, 1], [:i, :at, {:album_id=>10, :tag_id=>1}, 2]]
+    check_sql_array("UPDATE albums SET name = 'Al' WHERE (id = 10)",
+      "UPDATE tags SET name = 'T2' WHERE (id = 30)",
+      "INSERT INTO tags (name) VALUES ('T3')",
+      ["INSERT INTO at (album_id, tag_id) VALUES (10, 1)", "INSERT INTO at (tag_id, album_id) VALUES (1, 10)"])
     proc{al.set(:tags_attributes=>[{:id=>30, :name=>'T2', :number=>3}])}.should raise_error(Sequel::Error)
     proc{al.set(:tags_attributes=>[{:name=>'T2', :number=>3}])}.should raise_error(Sequel::Error)
   end

data/spec/extensions/optimistic_locking_spec.rb

@@ -6,11 +6,8 @@ describe "optimistic_locking plugin" do
     end
     h = {1=>{:id=>1, :name=>'John', :lock_version=>2}}
     lv = @lv = "lock_version"
-    @c.dataset.quote_identifiers = false
-    @c.dataset.meta_def(:h){h}
-    @c.dataset.meta_def(:lv){lv}
-    @c.dataset.meta_def(:update) do |opts|
-      case update_sql(opts)
+    @c.dataset.numrows = proc do |sql|
+      case sql
       when /UPDATE people SET (name|#{lv}) = ('Jim'|'Bob'|\d+), (?:name|#{lv}) = ('Jim'|'Bob'|\d+) WHERE \(\(id = (\d+)\) AND \(#{lv} = (\d+)\)\)/
         name, nlv = $1 == 'name' ? [$2, $3] : [$3, $2]
         m = h[$4.to_i]
@@ -28,20 +25,6 @@ describe "optimistic_locking plugin" do
         else
           0
         end
-      else
-        puts update_sql(opts)
-      end
-    end
-    @c.dataset.instance_eval do
-      def fetch_rows(sql)
-        m = h[1].dup
-        v = m.delete(:lock_version)
-        m[lv.to_sym] = v
-        yield(m)
-      end
-    end
-    @c.dataset.meta_def(:delete) do
-      case delete_sql
       when /DELETE FROM people WHERE \(\(id = (\d+)\) AND \(#{lv} = (\d+)\)\)/
         m = h[$1.to_i]
         if m && m[lv.to_sym] == $2.to_i
@@ -51,9 +34,15 @@ describe "optimistic_locking plugin" do
           0
         end
       else
-        puts delete_sql
+        puts sql
       end
     end
+    @c.dataset._fetch = proc do |sql|
+      m = h[1].dup
+      v = m.delete(:lock_version)
+      m[lv.to_sym] = v
+      m
+    end
     @c.columns :id, :name, :lock_version
     @c.plugin :optimistic_locking
   end