sequel 3.21.0 → 3.31.0

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/thread_local_timezones_spec.rb

@@ -39,7 +39,27 @@ describe "Sequel thread_local_timezones extension" do
   end
     
   it "should be thread safe" do
-    [Thread.new{Sequel.thread_application_timezone = :utc; sleep 0.03; Sequel.application_timezone.should == :utc},
-     Thread.new{sleep 0.01; Sequel.thread_application_timezone = :local; sleep 0.01; Sequel.application_timezone.should == :local}].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 = :utc
+      q2.push nil
+      q.pop
+      tz1 = Sequel.application_timezone
+    end
+    t2 = Thread.new do
+      Sequel.thread_application_timezone = :local
+      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 == :utc
+    tz2.should == :local
   end
 end

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

@@ -2,9 +2,7 @@ require File.join(File.dirname(File.expand_path(__FILE__)), "spec_helper")
 
 describe Sequel::Model, "to_dot extension" do
   def dot(ds)
-    a = []
-    ds.send(:_to_dot, a, "", 0, ds, 0)
-    a[2..-1]
+    Sequel::ToDot.new(ds).instance_variable_get(:@dot)[4...-1]
   end
 
   before do
@@ -13,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
@@ -123,7 +120,7 @@ END
   end
 
   it "should handle SQL::Subscript" do
-    dot(@ds.select(:a.sql_subscript(1))).should == ["1 -> 2 [label=\"select\"];", "2 [label=\"Array\"];", "2 -> 3 [label=\"0\"];", "3 [label=\"Subscript: a\"];", "3 -> 4 [label=\"f\"];", "4 [label=\":a\"];", "3 -> 5 [label=\"sub\"];", "5 [label=\"Array\"];", "5 -> 6 [label=\"0\"];", "6 [label=\"1\"];"]
+    dot(@ds.select(:a.sql_subscript(1))).should == ["1 -> 2 [label=\"select\"];", "2 [label=\"Array\"];", "2 -> 3 [label=\"0\"];", "3 [label=\"Subscript\"];", "3 -> 4 [label=\"f\"];", "4 [label=\":a\"];", "3 -> 5 [label=\"sub\"];", "5 [label=\"Array\"];", "5 -> 6 [label=\"0\"];", "6 [label=\"1\"];"]
   end
 
   it "should handle SQL::WindowFunction" do
@@ -135,7 +132,7 @@ END
   end
 
   it "should handle JOIN ON" do
-    dot(@ds.from(:a).join(:d, :b=>:c)).should == ["1 -> 2 [label=\"from\"];", "2 [label=\"Array\"];", "2 -> 3 [label=\"0\"];", "3 [label=\":a\"];", "1 -> 4 [label=\"join\"];", "4 [label=\"Array\"];", "4 -> 5 [label=\"0\"];", "5 [label=\"INNER JOIN ON\"];", "5 -> 6 [label=\"table\"];", "6 [label=\":d\"];", "5 -> 7 [label=\"on\"];", "7 [label=\"Array\"];", "7 -> 8 [label=\"0\"];", "8 [label=\"Array\"];", "8 -> 9 [label=\"0\"];", "9 [label=\"QualifiedIdentifier\"];", "9 -> 10 [label=\"table\"];", "10 [label=\"\\\"d\\\"\"];", "9 -> 11 [label=\"column\"];", "11 [label=\"\\\"b\\\"\"];", "8 -> 12 [label=\"1\"];", "12 [label=\"QualifiedIdentifier\"];", "12 -> 13 [label=\"table\"];", "13 [label=\"\\\"a\\\"\"];", "12 -> 14 [label=\"column\"];", "14 [label=\"\\\"c\\\"\"];"]
+    dot(@ds.from(:a).join(:d, :b=>:c)).should == ["1 -> 2 [label=\"from\"];", "2 [label=\"Array\"];", "2 -> 3 [label=\"0\"];", "3 [label=\":a\"];", "1 -> 4 [label=\"join\"];", "4 [label=\"Array\"];", "4 -> 5 [label=\"0\"];", "5 [label=\"INNER JOIN ON\"];", "5 -> 6 [label=\"table\"];", "6 [label=\":d\"];", "5 -> 7 [label=\"on\"];", "7 [label=\"ComplexExpression: =\"];", "7 -> 8 [label=\"0\"];", "8 [label=\"QualifiedIdentifier\"];", "8 -> 9 [label=\"table\"];", "9 [label=\"\\\"d\\\"\"];", "8 -> 10 [label=\"column\"];", "10 [label=\"\\\"b\\\"\"];", "7 -> 11 [label=\"1\"];", "11 [label=\"QualifiedIdentifier\"];", "11 -> 12 [label=\"table\"];", "12 [label=\"\\\"a\\\"\"];", "11 -> 13 [label=\"column\"];", "13 [label=\"\\\"c\\\"\"];"]
   end
 
   it "should handle JOIN USING" 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)

data/spec/extensions/tree_spec.rb

@@ -7,26 +7,11 @@ describe Sequel::Model, "tree plugin" do
     c.class_eval do
       def self.name; 'Node'; end
       columns :id, :name, :parent_id, :i, :pi
+      plugin :tree, opts
     end
-    ds = c.dataset
-    class << ds
-      attr_accessor :row_sets
-      def fetch_rows(sql)
-        @db << sql
-        if rs = row_sets.shift
-          rs.each{|row| yield row}
-        end
-      end
-    end
-    c.plugin :tree, opts
     c
   end
 
-  def y(c, *hs)
-    ds = c.dataset
-    ds.row_sets = hs
-  end
-
   before do
     @c = klass
     @ds = @c.dataset
@@ -71,7 +56,7 @@ describe Sequel::Model, "tree plugin" do
   end
 
   it "should have roots return an array of the tree's roots" do
-    y(@c, [{:id=>1, :parent_id=>nil, :name=>'r'}])
+    @ds._fetch = [{:id=>1, :parent_id=>nil, :name=>'r'}]
     @c.roots.should == [@c.load(:id=>1, :parent_id=>nil, :name=>'r')]
     @db.sqls.should == ["SELECT * FROM nodes WHERE (parent_id IS NULL)"]
   end
@@ -81,14 +66,14 @@ describe Sequel::Model, "tree plugin" do
   end
 
   it "should have ancestors return the ancestors of the current node" do
-    y(@c, [{:id=>1, :parent_id=>5, :name=>'r'}], [{:id=>5, :parent_id=>nil, :name=>'r2'}])
+    @ds._fetch = [[{:id=>1, :parent_id=>5, :name=>'r'}], [{:id=>5, :parent_id=>nil, :name=>'r2'}]]
     @o.ancestors.should == [@c.load(:id=>1, :parent_id=>5, :name=>'r'), @c.load(:id=>5, :parent_id=>nil, :name=>'r2')]
     @db.sqls.should == ["SELECT * FROM nodes WHERE (nodes.id = 1) LIMIT 1",
       "SELECT * FROM nodes WHERE (nodes.id = 5) LIMIT 1"]
   end
 
   it "should have descendants return the descendants of the current node" do
-    y(@c, [{:id=>3, :parent_id=>2, :name=>'r'}, {:id=>4, :parent_id=>2, :name=>'r2'}], [{:id=>5, :parent_id=>4, :name=>'r3'}], [])
+    @ds._fetch = [[{:id=>3, :parent_id=>2, :name=>'r'}, {:id=>4, :parent_id=>2, :name=>'r2'}], [{:id=>5, :parent_id=>4, :name=>'r3'}], []]
     @o.descendants.should == [@c.load(:id=>3, :parent_id=>2, :name=>'r'), @c.load(:id=>4, :parent_id=>2, :name=>'r2'), @c.load(:id=>5, :parent_id=>4, :name=>'r3')] 
     @db.sqls.should == ["SELECT * FROM nodes WHERE (nodes.parent_id = 2)",
       "SELECT * FROM nodes WHERE (nodes.parent_id = 3)",
@@ -97,7 +82,7 @@ describe Sequel::Model, "tree plugin" do
   end
 
   it "should have root return the root of the current node" do
-    y(@c, [{:id=>1, :parent_id=>5, :name=>'r'}], [{:id=>5, :parent_id=>nil, :name=>'r2'}])
+    @ds._fetch = [[{:id=>1, :parent_id=>5, :name=>'r'}], [{:id=>5, :parent_id=>nil, :name=>'r2'}]]
     @o.root.should == @c.load(:id=>5, :parent_id=>nil, :name=>'r2')
     @db.sqls.should == ["SELECT * FROM nodes WHERE (nodes.id = 1) LIMIT 1",
       "SELECT * FROM nodes WHERE (nodes.id = 5) LIMIT 1"]
@@ -113,14 +98,14 @@ describe Sequel::Model, "tree plugin" do
   end
 
   it "should have self_and_siblings return the children of the current node's parent" do
-    y(@c, [{:id=>1, :parent_id=>3, :name=>'r'}], [{:id=>7, :parent_id=>1, :name=>'r2'}, @o.values.dup])
+    @ds._fetch = [[{:id=>1, :parent_id=>3, :name=>'r'}], [{:id=>7, :parent_id=>1, :name=>'r2'}, @o.values.dup]]
     @o.self_and_siblings.should == [@c.load(:id=>7, :parent_id=>1, :name=>'r2'), @o] 
     @db.sqls.should == ["SELECT * FROM nodes WHERE (nodes.id = 1) LIMIT 1",
       "SELECT * FROM nodes WHERE (nodes.parent_id = 1)"]
   end
 
   it "should have siblings return the children of the current node's parent, except for the current node" do
-    y(@c, [{:id=>1, :parent_id=>3, :name=>'r'}], [{:id=>7, :parent_id=>1, :name=>'r2'}, @o.values.dup])
+    @ds._fetch = [[{:id=>1, :parent_id=>3, :name=>'r'}], [{:id=>7, :parent_id=>1, :name=>'r2'}, @o.values.dup]]
     @o.siblings.should == [@c.load(:id=>7, :parent_id=>1, :name=>'r2')] 
     @db.sqls.should == ["SELECT * FROM nodes WHERE (nodes.id = 1) LIMIT 1",
       "SELECT * FROM nodes WHERE (nodes.parent_id = 1)"]
@@ -132,23 +117,23 @@ describe Sequel::Model, "tree plugin" do
     end
 
     it "should have root class method return the root" do
-      y(@c, [{:id=>1, :parent_id=>nil, :name=>'r'}])
+      @c.dataset._fetch = [{:id=>1, :parent_id=>nil, :name=>'r'}]
       @c.root.should == @c.load(:id=>1, :parent_id=>nil, :name=>'r')
     end
 
     it "prevents creating a second root" do
-      y(@c, [{:id=>1, :parent_id=>nil, :name=>'r'}])
+      @c.dataset._fetch = [{:id=>1, :parent_id=>nil, :name=>'r'}]
       lambda { @c.create }.should raise_error(Sequel::Plugins::Tree::TreeMultipleRootError)
     end
 
     it "errors when promoting an existing record to a second root" do
-      y(@c, [{:id=>1, :parent_id=>nil, :name=>'r'}])
+      @c.dataset._fetch = [{:id=>1, :parent_id=>nil, :name=>'r'}]
       n = @c.load(:id => 2, :parent_id => 1)
       lambda { n.update(:parent_id => nil) }.should raise_error(Sequel::Plugins::Tree::TreeMultipleRootError)
     end
 
     it "allows updating existing root" do
-      y(@c, [{:id=>1, :parent_id=>nil, :name=>'r'}])
+      @c.dataset._fetch = [{:id=>1, :parent_id=>nil, :name=>'r'}]
       lambda { @c.root.update(:name => 'fdsa') }.should_not raise_error
     end
   end

data/spec/extensions/typecast_on_load_spec.rb

@@ -2,22 +2,17 @@ require File.join(File.dirname(File.expand_path(__FILE__)), "spec_helper")
 
 describe Sequel::Model, "TypecastOnLoad plugin" do
   before do
-    @db = Sequel::Database.new({})
+    @db = Sequel.mock(:fetch=>{:id=>1, :b=>"1", :y=>"0"}, :columns=>[:id, :b, :y])
     def @db.schema(*args)
       [[:id, {}], [:y, {:type=>:boolean, :db_type=>'tinyint(1)'}], [:b, {:type=>:integer, :db_type=>'integer'}]]
     end
     @c = Class.new(Sequel::Model(@db[:items])) do
-      include(Module.new{def _refresh(ds); values[:b] = b.to_s; self; end})
       attr_accessor :bset
       def b=(x)
         self.bset = true
         super
       end
     end
-    @c.instance_eval do
-      @columns = [:id, :b, :y]
-      def columns; @columns; end
-    end
   end 
 
   specify "should call setter method with value when loading the object, for all given columns" do

data/spec/extensions/update_primary_key_spec.rb

@@ -9,57 +9,63 @@ describe "Sequel::Plugins::UpdatePrimaryKey" do
     @c.unrestrict_primary_key
     @o = @c.new
     @ds = @c.dataset
-    @ds.extend(Module.new do
-      attr_accessor :a
-      def fetch_rows(sql)
-        yield(a.dup)
-      end
-
-      def update(h)
-        if literal(opts[:where]) =~ /a = (\d)/ and $1.to_i == a[:a]
-          a.update(h)
-        end
-        super
-      end
-    end)
-    @ds.a = {:a=>1, :b=>3}
-    @ds2 = @ds.naked 
     MODEL_DB.reset
   end
 
   specify "should handle regular updates" do
+    @ds._fetch = [[{:a=>1, :b=>3}], [{:a=>1, :b=>4}], [{:a=>1, :b=>4}], [{:a=>1, :b=>5}], [{:a=>1, :b=>5}], [{:a=>1, :b=>6}], [{:a=>1, :b=>6}]]
     @c.first.update(:b=>4)
-    @ds2.all.should == [{:a=>1, :b=>4}]
+    @c.all.should == [@c.load(:a=>1, :b=>4)]
+    MODEL_DB.sqls.should == ["SELECT * FROM a LIMIT 1", "UPDATE a SET b = 4 WHERE (a = 1)", "SELECT * FROM a"]
     @c.first.set(:b=>5).save
-    @ds2.all.should == [{:a=>1, :b=>5}]
+    @c.all.should == [@c.load(:a=>1, :b=>5)]
+    MODEL_DB.sqls.should == ["SELECT * FROM a LIMIT 1", "UPDATE a SET b = 5 WHERE (a = 1)", "SELECT * FROM a"]
     @c.first.set(:b=>6).save(:b)
-    @ds2.all.should == [{:a=>1, :b=>6}]
+    @c.all.should == [@c.load(:a=>1, :b=>6)]
+    MODEL_DB.sqls.should == ["SELECT * FROM a LIMIT 1", "UPDATE a SET b = 6 WHERE (a = 1)", "SELECT * FROM a"]
   end
 
   specify "should handle updating the primary key field with another field" do
+    @ds._fetch = [[{:a=>1, :b=>3}], [{:a=>2, :b=>4}]]
     @c.first.update(:a=>2, :b=>4)
-    @ds2.all.should == [{:a=>2, :b=>4}]
+    @c.all.should == [@c.load(:a=>2, :b=>4)]
+    sqls = MODEL_DB.sqls
+    ["UPDATE a SET a = 2, b = 4 WHERE (a = 1)", "UPDATE a SET b = 4, a = 2 WHERE (a = 1)"].should include(sqls.slice!(1))
+    sqls.should == ["SELECT * FROM a LIMIT 1", "SELECT * FROM a"]
   end
 
   specify "should handle updating just the primary key field when saving changes" do
+    @ds._fetch = [[{:a=>1, :b=>3}], [{:a=>2, :b=>3}], [{:a=>2, :b=>3}], [{:a=>3, :b=>3}]]
     @c.first.update(:a=>2)
-    @ds2.all.should == [{:a=>2, :b=>3}]
+    @c.all.should == [@c.load(:a=>2, :b=>3)]
+    MODEL_DB.sqls.should == ["SELECT * FROM a LIMIT 1", "UPDATE a SET a = 2 WHERE (a = 1)", "SELECT * FROM a"]
     @c.first.set(:a=>3).save(:a)
-    @ds2.all.should == [{:a=>3, :b=>3}]
+    @c.all.should == [@c.load(:a=>3, :b=>3)]
+    MODEL_DB.sqls.should == ["SELECT * FROM a LIMIT 1", "UPDATE a SET a = 3 WHERE (a = 2)", "SELECT * FROM a"]
   end
 
   specify "should handle saving after modifying the primary key field with another field" do
+    @ds._fetch = [[{:a=>1, :b=>3}], [{:a=>2, :b=>4}]]
     @c.first.set(:a=>2, :b=>4).save
-    @ds2.all.should == [{:a=>2, :b=>4}]
+    @c.all.should == [@c.load(:a=>2, :b=>4)]
+    sqls = MODEL_DB.sqls
+    ["UPDATE a SET a = 2, b = 4 WHERE (a = 1)", "UPDATE a SET b = 4, a = 2 WHERE (a = 1)"].should include(sqls.slice!(1))
+    sqls.should == ["SELECT * FROM a LIMIT 1", "SELECT * FROM a"]
   end
 
   specify "should handle saving after modifying just the primary key field" do
+    @ds._fetch = [[{:a=>1, :b=>3}], [{:a=>2, :b=>3}]]
     @c.first.set(:a=>2).save
-    @ds2.all.should == [{:a=>2, :b=>3}]
+    @c.all.should == [@c.load(:a=>2, :b=>3)]
+    sqls = MODEL_DB.sqls
+    ["UPDATE a SET a = 2, b = 3 WHERE (a = 1)", "UPDATE a SET b = 3, a = 2 WHERE (a = 1)"].should include(sqls.slice!(1))
+    sqls.should == ["SELECT * FROM a LIMIT 1", "SELECT * FROM a"]
   end
 
   specify "should handle saving after updating the primary key" do
+    @ds._fetch = [[{:a=>1, :b=>3}], [{:a=>2, :b=>5}]]
     @c.first.update(:a=>2).update(:b=>4).set(:b=>5).save
-    @ds2.all.should == [{:a=>2, :b=>5}]
+    @c.all.should == [@c.load(:a=>2, :b=>5)]
+    MODEL_DB.sqls.should == ["SELECT * FROM a LIMIT 1", "UPDATE a SET a = 2 WHERE (a = 1)", "UPDATE a SET b = 4 WHERE (a = 2)", "UPDATE a SET b = 5 WHERE (a = 2)", "SELECT * FROM a"]
   end
 end