sequel 3.29.0 → 3.30.0

data/spec/extensions/single_table_inheritance_spec.rb

@@ -3,9 +3,7 @@ require File.join(File.dirname(File.expand_path(__FILE__)), "spec_helper")
 describe Sequel::Model, "#sti_key" do
   before do
     class ::StiTest < Sequel::Model
-      def kind; self[:kind]; end 
-      def kind=(x); self[:kind] = x; end 
-      def _refresh(x); end 
+      columns :id, :kind, :blah
       plugin :single_table_inheritance, :kind
     end 
     class ::StiTestSub1 < StiTest
@@ -22,7 +20,7 @@ describe Sequel::Model, "#sti_key" do
   end
 
   specify "should have simple_table = nil" do
-    StiTest.simple_table.should == nil
+    StiTest.simple_table.should == "sti_tests"
     StiTestSub1.simple_table.should == nil
   end
   
@@ -30,15 +28,9 @@ describe Sequel::Model, "#sti_key" do
     StiTest.plugin :single_table_inheritance, :blah
     Object.send(:remove_const, :StiTestSub1)
     Object.send(:remove_const, :StiTestSub2)
-    class ::StiTestSub1 < StiTest
-    end 
-    class ::StiTestSub2 < StiTest
-    end 
-    def @ds.fetch_rows(sql)
-      yield({:blah=>'StiTest'})
-      yield({:blah=>'StiTestSub1'})
-      yield({:blah=>'StiTestSub2'})
-    end 
+    class ::StiTestSub1 < StiTest; end 
+    class ::StiTestSub2 < StiTest; end 
+    @ds._fetch = [{:blah=>'StiTest'}, {:blah=>'StiTestSub1'}, {:blah=>'StiTestSub2'}]
     StiTest.all.collect{|x| x.class}.should == [StiTest, StiTestSub1, StiTestSub2]
     StiTest.dataset.sql.should == "SELECT * FROM sti_tests"
     StiTestSub1.dataset.sql.should == "SELECT * FROM sti_tests WHERE (sti_tests.blah IN ('StiTestSub1'))"
@@ -46,29 +38,18 @@ describe Sequel::Model, "#sti_key" do
   end 
   
   it "should return rows with the correct class based on the polymorphic_key value" do
-    def @ds.fetch_rows(sql)
-      yield({:kind=>'StiTest'})
-      yield({:kind=>'StiTestSub1'})
-      yield({:kind=>'StiTestSub2'})
-    end 
+    @ds._fetch = [{:kind=>'StiTest'}, {:kind=>'StiTestSub1'}, {:kind=>'StiTestSub2'}]
     StiTest.all.collect{|x| x.class}.should == [StiTest, StiTestSub1, StiTestSub2]
   end 
 
   it "should return rows with the correct class for subclasses based on the polymorphic_key value" do
-    class ::StiTestSub1Sub < StiTestSub1
-    end 
-    ds = StiTestSub1.dataset
-    def ds.fetch_rows(sql)
-      yield({:kind=>'StiTestSub1'})
-      yield({:kind=>'StiTestSub1Sub'})
-    end 
+    class ::StiTestSub1Sub < StiTestSub1; end 
+    StiTestSub1.dataset._fetch = [{:kind=>'StiTestSub1'}, {:kind=>'StiTestSub1Sub'}]
     StiTestSub1.all.collect{|x| x.class}.should == [StiTestSub1, StiTestSub1Sub]
   end 
 
   it "should fallback to the main class if the given class does not exist" do
-    def @ds.fetch_rows(sql)
-      yield({:kind=>'StiTestSub3'})
-    end
+    @ds._fetch = {:kind=>'StiTestSub3'}
     StiTest.all.collect{|x| x.class}.should == [StiTest]
   end
 
@@ -79,10 +60,7 @@ describe Sequel::Model, "#sti_key" do
       Object
     end
     StiTest.plugin :single_table_inheritance, :kind
-    def @ds.fetch_rows(sql)
-      yield({:kind=>''})
-      yield({:kind=>nil})
-    end
+    @ds._fetch = [{:kind=>''}, {:kind=>nil}]
     StiTest.all.collect{|x| x.class}.should == [StiTest, StiTest]
     called.should == false
   end
@@ -91,19 +69,19 @@ describe Sequel::Model, "#sti_key" do
     StiTest.new.save
     StiTestSub1.new.save
     StiTestSub2.new.save
-    MODEL_DB.sqls.should == ["INSERT INTO sti_tests (kind) VALUES ('StiTest')", "INSERT INTO sti_tests (kind) VALUES ('StiTestSub1')", "INSERT INTO sti_tests (kind) VALUES ('StiTestSub2')"]
+    MODEL_DB.sqls.should == ["INSERT INTO sti_tests (kind) VALUES ('StiTest')", "SELECT * FROM sti_tests WHERE (id = 10) LIMIT 1", "INSERT INTO sti_tests (kind) VALUES ('StiTestSub1')", "SELECT * FROM sti_tests WHERE ((sti_tests.kind IN ('StiTestSub1')) AND (id = 10)) LIMIT 1", "INSERT INTO sti_tests (kind) VALUES ('StiTestSub2')", "SELECT * FROM sti_tests WHERE ((sti_tests.kind IN ('StiTestSub2')) AND (id = 10)) LIMIT 1"]
   end
 
   it "should have the before_create hook not override an existing value" do
     StiTest.create(:kind=>'StiTestSub1')
-    MODEL_DB.sqls.should == ["INSERT INTO sti_tests (kind) VALUES ('StiTestSub1')"]
+    MODEL_DB.sqls.should == ["INSERT INTO sti_tests (kind) VALUES ('StiTestSub1')", "SELECT * FROM sti_tests WHERE (id = 10) LIMIT 1"]
   end
 
   it "should have the before_create hook handle columns with the same name as existing method names" do
     StiTest.plugin :single_table_inheritance, :type
     StiTest.columns :id, :type
     StiTest.create
-    MODEL_DB.sqls.should == ["INSERT INTO sti_tests (type) VALUES ('StiTest')"]
+    MODEL_DB.sqls.should == ["INSERT INTO sti_tests (type) VALUES ('StiTest')", "SELECT * FROM sti_tests WHERE (id = 10) LIMIT 1"]
   end
 
   it "should add a filter to model datasets inside subclasses hook to only retreive objects with the matching key" do
@@ -129,7 +107,7 @@ describe Sequel::Model, "#sti_key" do
     before do
       class ::StiTest2 < Sequel::Model
         columns :id, :kind
-        def _refresh(x); end
+        def _save_refresh; end
       end
     end
     after do

data/spec/extensions/spec_helper.rb

@@ -17,70 +17,15 @@ def skip_warn(s)
   warn "Skipping test of #{s}" if ENV["SKIPPED_TEST_WARN"]
 end
 
-class MockDataset < Sequel::Dataset
-  def insert(*args)
-    @db.execute insert_sql(*args)
-  end
-  
-  def update(*args)
-    @db.execute update_sql(*args)
-    1
-  end
-  
-  def delete(*args)
-    @db.execute delete_sql(*args)
-    1
-  end
-  
-  def fetch_rows(sql)
-    return if sql =~ /information_schema/
-    @db.execute(sql)
-    yield({:id => 1, :x => 1})
-  end
-
-  def quoted_identifier(c)
-    "\"#{c}\""
-  end
-end
-
-class MockDatabase < Sequel::Database
-  @@quote_identifiers = false
-  self.identifier_input_method = nil
-  self.identifier_output_method = nil
-  attr_reader :sqls
-
-  def connect(opts)
-    Object.new
-  end
-  
-  def execute(sql, opts={})
-    @sqls ||= []
-    @sqls << sql
-  end
-  
-  def new_sqls
-    s = sqls
-    reset
-    s
-  end
-
-  def reset
-    @sqls = []
-  end
-
-  def schema(table_name, opts)
-    [[:id, {:primary_key=>true}]]
-  end
-
-  def transaction(opts={}); yield; end
-  
-  def dataset(opts=nil); MockDataset.new(self, opts); end
-end
+Sequel.quote_identifiers = false
+Sequel.identifier_input_method = nil
+Sequel.identifier_output_method = nil
 
 class << Sequel::Model
+  attr_writer :db_schema
   alias orig_columns columns
   def columns(*cols)
-    return @columns if cols.empty?
+    return super if cols.empty?
     define_method(:columns){cols}
     @dataset.instance_variable_set(:@columns, cols) if @dataset
     def_column_accessor(*cols)
@@ -88,10 +33,11 @@ class << Sequel::Model
     @db_schema = {}
     cols.each{|c| @db_schema[c] = {}}
   end
-  def simple_table
-    nil
-  end
 end
 
-Sequel::Model.db = MODEL_DB = MockDatabase.new
 Sequel::Model.use_transactions = false
+
+db = Sequel.mock(:fetch=>{:id => 1, :x => 1}, :numrows=>1, :autoid=>proc{|sql| 10})
+def db.schema(*) [[:id, {:primary_key=>true}]] end
+def db.reset() sqls end
+Sequel::Model.db = MODEL_DB = db

data/spec/extensions/sql_expr_spec.rb

@@ -4,86 +4,46 @@ describe "Sequel sql_expr extension" do
   specify "Object#sql_expr should wrap the object in a GenericComplexExpression" do
     o = Object.new
     s = o.sql_expr
-    s.should be_a_kind_of(Sequel::SQL::GenericComplexExpression)
-    s.op.should == :NOOP
-    s.args.should == [o]
-    (s+1).should be_a_kind_of(Sequel::SQL::NumericExpression)
-    (s & true).should be_a_kind_of(Sequel::SQL::BooleanExpression)
-    (s < 1).should be_a_kind_of(Sequel::SQL::BooleanExpression)
-    s.sql_subscript(1).should be_a_kind_of(Sequel::SQL::Subscript)
-    s.like('a').should be_a_kind_of(Sequel::SQL::BooleanExpression)
-    s.as(:a).should be_a_kind_of(Sequel::SQL::AliasedExpression)
-    s.cast(Integer).should be_a_kind_of(Sequel::SQL::Cast)
-    s.desc.should be_a_kind_of(Sequel::SQL::OrderedExpression)
-    s.sql_string.should be_a_kind_of(Sequel::SQL::StringExpression)
+    s.should == Sequel::SQL::GenericComplexExpression.new(:NOOP, o)
+    (s+1).should == Sequel::SQL::NumericExpression.new(:+, s, 1)
+    (s & true).should == Sequel::SQL::BooleanExpression.new(:AND, s, true)
+    (s < 1).should == Sequel::SQL::BooleanExpression.new(:<, s, 1)
+    s.sql_subscript(1).should == Sequel::SQL::Subscript.new(s, [1])
+    s.like('a').should == Sequel::SQL::BooleanExpression.new(:LIKE, s, 'a')
+    s.as(:a).should == Sequel::SQL::AliasedExpression.new(s, :a)
+    s.cast(Integer).should == Sequel::SQL::Cast.new(s, Integer)
+    s.desc.should == Sequel::SQL::OrderedExpression.new(s, true)
+    s.sql_string.should == Sequel::SQL::StringExpression.new(:NOOP, s)
   end
 
   specify "Numeric#sql_expr should wrap the object in a NumericExpression" do
-    [1, 2.0, 2^40, BigDecimal.new('1.0')].each do |o|
-      s = o.sql_expr
-      s.should be_a_kind_of(Sequel::SQL::NumericExpression)
-      s.op.should == :NOOP
-      s.args.should == [o]
+    [1, 2.0, 2^70, BigDecimal.new('1.0')].each do |o|
+      o.sql_expr.should == Sequel::SQL::NumericExpression.new(:NOOP, o)
     end
   end
 
   specify "String#sql_expr should wrap the object in a StringExpression" do
-    o = ""
-    s = o.sql_expr
-    s.should be_a_kind_of(Sequel::SQL::StringExpression)
-    s.op.should == :NOOP
-    s.args.should == [o]
+    "".sql_expr.should == Sequel::SQL::StringExpression.new(:NOOP, "")
   end
 
   specify "NilClass, TrueClass, and FalseClass#sql_expr should wrap the object in a BooleanExpression" do
     [nil, true, false].each do |o|
-      s = o.sql_expr
-      s.should be_a_kind_of(Sequel::SQL::BooleanExpression)
-      s.op.should == :NOOP
-      s.args.should == [o]
+      o.sql_expr.should == Sequel::SQL::BooleanExpression.new(:NOOP, o)
     end
   end
 
   specify "Proc#sql_expr should should treat the object as a virtual row block" do
-    s = proc{a}.sql_expr
-    s.should be_a_kind_of(Sequel::SQL::Identifier)
-    s.value.should == :a
-
-    s = proc{a__b}.sql_expr
-    s.should be_a_kind_of(Sequel::SQL::QualifiedIdentifier)
-    s.table.should == "a"
-    s.column.should == "b"
-
-    s = proc{a(b)}.sql_expr
-    s.should be_a_kind_of(Sequel::SQL::Function)
-    s.f.should == :a
-    s.args.length.should == 1
-    s.args.first.should be_a_kind_of(Sequel::SQL::Identifier)
-    s.args.first.value.should == :b
+    proc{a}.sql_expr.should == Sequel::SQL::Identifier.new(:a)
+    proc{a__b}.sql_expr.should == Sequel::SQL::QualifiedIdentifier.new('a', 'b')
+    proc{a(b)}.sql_expr.should == Sequel::SQL::Function.new(:a, Sequel::SQL::Identifier.new(:b))
   end
 
   specify "Proc#sql_expr should should wrap the object in a GenericComplexExpression if the object is not already an expression" do
-    s = proc{1}.sql_expr
-    s.should be_a_kind_of(Sequel::SQL::GenericComplexExpression)
-    s.op.should == :NOOP
-    s.args.should == [1]
+    proc{1}.sql_expr.should == Sequel::SQL::GenericComplexExpression.new(:NOOP, 1)
   end
 
   specify "Proc#sql_expr should should convert a hash or array of two element arrays to a BooleanExpression" do
-    s = proc{{a=>b}}.sql_expr
-    s.should be_a_kind_of(Sequel::SQL::BooleanExpression)
-    s.op.should == :"="
-    s.args.first.should be_a_kind_of(Sequel::SQL::Identifier)
-    s.args.first.value.should == :a
-    s.args.last.should be_a_kind_of(Sequel::SQL::Identifier)
-    s.args.last.value.should == :b
-
-    s = proc{[[a,b]]}.sql_expr
-    s.should be_a_kind_of(Sequel::SQL::BooleanExpression)
-    s.op.should == :"="
-    s.args.first.should be_a_kind_of(Sequel::SQL::Identifier)
-    s.args.first.value.should == :a
-    s.args.last.should be_a_kind_of(Sequel::SQL::Identifier)
-    s.args.last.value.should == :b
+    proc{{a=>b}}.sql_expr.should == Sequel::SQL::BooleanExpression.new(:'=', Sequel::SQL::Identifier.new(:a), Sequel::SQL::Identifier.new(:b))
+    proc{[[a,b]]}.sql_expr.should == Sequel::SQL::BooleanExpression.new(:'=', Sequel::SQL::Identifier.new(:a), Sequel::SQL::Identifier.new(:b))
   end
 end

data/spec/extensions/tactical_eager_loading_spec.rb

@@ -7,23 +7,13 @@ describe "Sequel::Plugins::TacticalEagerLoading" do
       columns :id, :parent_id
       many_to_one :parent, :class=>self
       one_to_many :children, :class=>self, :key=>:parent_id
-      ds = dataset
-      def ds.fetch_rows(sql)
-        execute(sql)
-        where = @opts[:where]
-        if !where
-          yield(:id=>1, :parent_id=>101)
-          yield(:id=>2, :parent_id=>102)
-          yield(:id=>101, :parent_id=>nil)
-          yield(:id=>102, :parent_id=>nil)
-        elsif where.args.first.column == :id
-          Array(where.args.last).each do |x|
-            yield(:id=>x, :parent_id=>nil)
-          end
-        elsif where.args.first.column == :parent_id
-          Array(where.args.last).each do |x|
-            yield(:id=>x-100, :parent_id=>x) if x > 100
-          end
+      dataset._fetch = proc do |sql|
+        if sql !~ /WHERE/
+          [{:id=>1, :parent_id=>101}, {:id=>2, :parent_id=>102}, {:id=>101, :parent_id=>nil}, {:id=>102, :parent_id=>nil}]
+        elsif sql =~ /WHERE.*\bid IN \(([\d, ]*)\)/
+          $1.split(', ').map{|x| {:id=>x.to_i, :parent_id=>nil}}
+        elsif sql =~ /WHERE.*\bparent_id IN \(([\d, ]*)\)/
+          $1.split(', ').map{|x| {:id=>x.to_i - 100, :parent_id=>x.to_i} if x.to_i > 100}.compact
         end
       end
     end
@@ -49,9 +39,9 @@ describe "Sequel::Plugins::TacticalEagerLoading" do
     ts = @c.all
     MODEL_DB.sqls.length.should == 1
     ts.map{|x| x.parent}.should == [ts[2], ts[3], nil, nil]
-    MODEL_DB.sqls.length.should == 2
+    MODEL_DB.sqls.length.should == 1
     ts.map{|x| x.children}.should == [[], [], [ts[0]], [ts[1]]]
-    MODEL_DB.sqls.length.should == 3
+    MODEL_DB.sqls.length.should == 1
   end
 
   it "association getter methods should not eagerly load the association if the association is cached" do

data/spec/extensions/timestamps_spec.rb

@@ -13,9 +13,10 @@ describe "Sequel::Plugins::Timestamps" do
     @c.class_eval do
       columns :id, :created_at, :updated_at
       plugin :timestamps
+      def _save_refresh(*) end
       db.reset
-      def _refresh(ds); self end
     end
+    @c.dataset.autoid = nil
   end 
   after do
     Sequel.datetime_class = Time
@@ -40,8 +41,9 @@ describe "Sequel::Plugins::Timestamps" do
   it "should use the same value for the creation and update timestamps when creating if the :update_on_create option is given" do
     @c.plugin :timestamps, :update_on_create=>true
     o = @c.create
-    @c.db.sqls.length.should == 1
-    @c.db.sqls.first.should =~ /INSERT INTO t \((creat|updat)ed_at, (creat|updat)ed_at\) VALUES \('2009-08-01', '2009-08-01'\)/
+    sqls = @c.db.sqls
+    sqls.shift.should =~ /INSERT INTO t \((creat|updat)ed_at, (creat|updat)ed_at\) VALUES \('2009-08-01', '2009-08-01'\)/
+    sqls.should == []
     o.created_at.should === o.updated_at
   end
 
@@ -50,8 +52,7 @@ describe "Sequel::Plugins::Timestamps" do
     c.class_eval do
       columns :id, :c
       plugin :timestamps, :create=>:c
-      db.reset
-      def _refresh(ds); self end
+      def _save_refresh(*) end
     end
     o = c.create
     c.db.sqls.should == ["INSERT INTO t (c) VALUES ('2009-08-01')"]
@@ -64,7 +65,6 @@ describe "Sequel::Plugins::Timestamps" do
       columns :id, :u
       plugin :timestamps, :update=>:u
       db.reset
-      def _refresh(ds); self end
     end
     o = c.load(:id=>1).save
     c.db.sqls.should == ["UPDATE t SET u = '2009-08-01' WHERE (id = 1)"]

data/spec/extensions/to_dot_spec.rb

@@ -11,14 +11,13 @@ describe Sequel::Model, "to_dot extension" do
   end
 
   it "should output a string suitable for input to the graphviz dot program" do
-    @ds.to_dot.should == (<<END
+    @ds.to_dot.should == (<<END).strip
 digraph G {
 0 [label="self"];
 0 -> 1 [label=""];
 1 [label="Dataset"];
 }
 END
-).strip
   end
 
   it "should handle an empty dataset" do

data/spec/extensions/touch_spec.rb

@@ -2,9 +2,7 @@ require File.join(File.dirname(File.expand_path(__FILE__)), "spec_helper")
 
 describe "Touch plugin" do
   before do
-    @c = Class.new(Sequel::Model) do
-      def _refresh(*); end 
-    end
+    @c = Class.new(Sequel::Model)
     p = proc{def touch_instance_value; touch_association_value; end}
     @Artist = Class.new(@c, &p).set_dataset(:artists)
     @Album = Class.new(@c, &p).set_dataset(:albums)
@@ -63,8 +61,9 @@ describe "Touch plugin" do
   specify "should be able to give an array to the :associations option specifying multiple associations" do
     @Album.plugin :touch, :associations=>[:artist, :followup_albums]
     @Album.load(:id=>4, :artist_id=>1).touch
-    MODEL_DB.sqls.shift.should == "UPDATE albums SET updated_at = CURRENT_TIMESTAMP WHERE (id = 4)"
-    MODEL_DB.sqls.sort.should == ["UPDATE albums SET updated_at = CURRENT_TIMESTAMP WHERE (albums.original_album_id = 4)",
+    sqls = MODEL_DB.sqls
+    sqls.shift.should == "UPDATE albums SET updated_at = CURRENT_TIMESTAMP WHERE (id = 4)"
+    sqls.sort.should == ["UPDATE albums SET updated_at = CURRENT_TIMESTAMP WHERE (albums.original_album_id = 4)",
       "UPDATE artists SET updated_at = CURRENT_TIMESTAMP WHERE (artists.id = 1)"]
   end
 
@@ -85,8 +84,9 @@ describe "Touch plugin" do
   specify "should allow the mixed use of symbols and hashes inside an array for the :associations option" do
     @Album.plugin :touch, :associations=>[:artist, {:followup_albums=>:modified_on}]
     @Album.load(:id=>4, :artist_id=>1).touch
-    MODEL_DB.sqls.shift.should == "UPDATE albums SET updated_at = CURRENT_TIMESTAMP WHERE (id = 4)"
-    MODEL_DB.sqls.sort.should == ["UPDATE albums SET modified_on = CURRENT_TIMESTAMP WHERE (albums.original_album_id = 4)",
+    sqls = MODEL_DB.sqls
+    sqls.shift.should == "UPDATE albums SET updated_at = CURRENT_TIMESTAMP WHERE (id = 4)"
+    sqls.sort.should == ["UPDATE albums SET modified_on = CURRENT_TIMESTAMP WHERE (albums.original_album_id = 4)",
       "UPDATE artists SET updated_at = CURRENT_TIMESTAMP WHERE (artists.id = 1)"]
   end
 
@@ -94,8 +94,9 @@ describe "Touch plugin" do
     @Album.plugin :touch
     @Album.touch_associations(:artist, {:followup_albums=>:modified_on})
     @Album.load(:id=>4, :artist_id=>1).touch
-    MODEL_DB.sqls.shift.should == "UPDATE albums SET updated_at = CURRENT_TIMESTAMP WHERE (id = 4)"
-    MODEL_DB.sqls.sort.should == ["UPDATE albums SET modified_on = CURRENT_TIMESTAMP WHERE (albums.original_album_id = 4)",
+    sqls = MODEL_DB.sqls
+    sqls.shift.should == "UPDATE albums SET updated_at = CURRENT_TIMESTAMP WHERE (id = 4)"
+    sqls.sort.should == ["UPDATE albums SET modified_on = CURRENT_TIMESTAMP WHERE (albums.original_album_id = 4)",
       "UPDATE artists SET updated_at = CURRENT_TIMESTAMP WHERE (artists.id = 1)"]
   end
 
@@ -103,8 +104,9 @@ describe "Touch plugin" do
     @Album.plugin :touch
     @Album.touch_associations(:artist, {:followup_albums=>:modified_on})
     @Album.load(:id=>4, :artist_id=>1).destroy
-    MODEL_DB.sqls.shift.should == "DELETE FROM albums WHERE (id = 4)"
-    MODEL_DB.sqls.sort.should == ["UPDATE albums SET modified_on = CURRENT_TIMESTAMP WHERE (albums.original_album_id = 4)",
+    sqls = MODEL_DB.sqls
+    sqls.shift.should == "DELETE FROM albums WHERE (id = 4)"
+    sqls.sort.should == ["UPDATE albums SET modified_on = CURRENT_TIMESTAMP WHERE (albums.original_album_id = 4)",
       "UPDATE artists SET updated_at = CURRENT_TIMESTAMP WHERE (artists.id = 1)"]
   end
 
@@ -133,18 +135,15 @@ describe "Touch plugin" do
     c1 = Class.new(@Artist)
     c1.load(:id=>4).touch
     MODEL_DB.sqls.should == ["UPDATE artists SET updated_at = CURRENT_TIMESTAMP WHERE (id = 4)"]
-    MODEL_DB.reset
 
     c1.touch_column = :modified_on
     c1.touch_associations :albums
     c1.load(:id=>1).touch
     MODEL_DB.sqls.should == ["UPDATE artists SET modified_on = CURRENT_TIMESTAMP WHERE (id = 1)",
       "UPDATE albums SET modified_on = CURRENT_TIMESTAMP WHERE (albums.artist_id = 1)"]
-    MODEL_DB.reset
 
     @a.touch
     MODEL_DB.sqls.should == ["UPDATE artists SET updated_at = CURRENT_TIMESTAMP WHERE (id = 1)"]
-    MODEL_DB.reset
 
     @Artist.plugin :touch, :column=>:modified_on, :associations=>:albums
     c2 = Class.new(@Artist)