sequel 3.21.0 → 3.32.0

data/spec/extensions/lazy_attributes_spec.rb

@@ -1,8 +1,9 @@
 require File.join(File.dirname(File.expand_path(__FILE__)), "spec_helper")
+require 'yaml'
 
 describe "Sequel::Plugins::LazyAttributes" do
   before do
-    @db = MockDatabase.new
+    @db = Sequel.mock
     @db.meta_def(:schema){|*a| [[:id, {:type=>:integer}], [:name,{:type=>:string}]]}
     class ::LazyAttributesModel < Sequel::Model(@db[:la])
       plugin :lazy_attributes
@@ -10,27 +11,23 @@ describe "Sequel::Plugins::LazyAttributes" do
       meta_def(:columns){[:id, :name]}
       lazy_attributes :name
       meta_def(:columns){[:id]}
-      ds = dataset
-      def ds.fetch_rows(sql)
-        execute(sql)
-        select = @opts[:select]
-        where = @opts[:where]
-        block = @mod_block || proc{|s| s}
-        if !where
-          if select.include?(:name)
-            yield(block[:id=>1, :name=>'1'])
-            yield(block[:id=>2, :name=>'2'])
+      dataset._fetch = proc do |sql|
+        if sql !~ /WHERE/
+          if sql =~ /name/
+            [{:id=>1, :name=>'1'}, {:id=>2, :name=>'2'}]
           else
-            yield(:id=>1)
-            yield(:id=>2)
+            [{:id=>1}, {:id=>2}]
           end
         else
-          i = where.args.last
-          Array(i).each do |x|
+          if sql =~ /id IN \(([\d, ]+)\)/
+            $1.split(', ')
+          elsif sql =~ /id = (\d)/
+            [$1]
+          end.map do |x|
             if sql =~ /SELECT name FROM/
-              yield(block[:name=>x.to_s])
+              {:name=>x.to_s}
             else
-              yield(block[:id=>x, :name=>x.to_s])
+              {:id=>x.to_i, :name=>x.to_s}
             end
           end
         end
@@ -38,7 +35,7 @@ describe "Sequel::Plugins::LazyAttributes" do
     end
     @c = ::LazyAttributesModel
     @ds = LazyAttributesModel.dataset
-    @db.reset
+    @db.sqls
   end
   after do
     Object.send(:remove_const, :LazyAttributesModel)
@@ -136,7 +133,7 @@ describe "Sequel::Plugins::LazyAttributes" do
 
   it "should work with the serialization plugin" do
     @c.plugin :serialization, :yaml, :name
-    @ds.instance_variable_set(:@mod_block, proc{|s| s.merge(:name=>"--- #{s[:name].to_i*3}\n")})
+    @ds._fetch = [[{:id=>1}, {:id=>2}], [{:id=>1, :name=>"--- 3\n"}, {:id=>2, :name=>"--- 6\n"}], [{:id=>1}], [{:name=>"--- 3\n"}]]
     @c.with_identity_map do
       ms = @ds.all
       ms.map{|m| m.values}.should == [{:id=>1}, {:id=>2}]
@@ -146,7 +143,6 @@ describe "Sequel::Plugins::LazyAttributes" do
       ms.map{|m| m.name}.should == [3,6]
       @db.sqls.should == ['SELECT id FROM la', 'SELECT id, name FROM la WHERE (id IN (1, 2))']
     end
-    @db.reset
     @c.with_identity_map do
       m = @ds.first
       m.values.should == {:id=>1}

data/spec/extensions/list_spec.rb

@@ -8,32 +8,10 @@ describe "List plugin" do
       columns :id, :position, :scope_id, :pos
       plugin :list, opts
       self.use_transactions = false
-
-      class << self
-        attr_accessor :rows
-      end
-
-      def checked_transaction(opts={})
-        return super if @in_transaction || !use_transaction?(opts)
-        @in_transaction = true
-        db.execute 'BEGIN'
-        super
-        db.execute 'COMMIT'
-        @in_transaction = false
-      end
     end
     c
   end
 
-  def y(c, *hs)
-    c.rows = hs
-    ds = c.dataset
-    def ds.fetch_rows(sql)
-      db.execute(sql)
-      yield model.rows.shift
-    end
-  end
-
   before do
     @c = klass
     @o = @c.load(:id=>7, :position=>3)
@@ -89,18 +67,18 @@ describe "List plugin" do
   end
 
   it "should have at_position return the model object at the given position" do
-    y(@c, :id=>1, :position=>1)
+    @c.dataset._fetch = {:id=>1, :position=>1}
     @o.at_position(10).should == @c.load(:id=>1, :position=>1)
-    y(@sc, :id=>2, :position=>2, :scope_id=>5)
+    @sc.dataset._fetch = {:id=>2, :position=>2, :scope_id=>5}
     @so.at_position(20).should == @sc.load(:id=>2, :position=>2, :scope_id=>5)
     @db.sqls.should == ["SELECT * FROM items WHERE (position = 10) ORDER BY position LIMIT 1",
       "SELECT * FROM items WHERE ((scope_id = 5) AND (position = 20)) ORDER BY scope_id, position LIMIT 1"]
   end
 
   it "should have last_position return the last position in the list" do
-    y(@c, :max=>10)
+    @c.dataset._fetch  = {:max=>10}
     @o.last_position.should == 10
-    y(@sc, :max=>20)
+    @sc.dataset._fetch = {:max=>20}
     @so.last_position.should == 20
     @db.sqls.should == ["SELECT max(position) FROM items LIMIT 1",
       "SELECT max(position) FROM items WHERE (scope_id = 5) LIMIT 1"]
@@ -115,7 +93,7 @@ describe "List plugin" do
   end
 
   it "should have move_down without an argument move down a single position" do
-    y(@c, :max=>10)
+    @c.dataset._fetch = {:max=>10}
     @o.move_down.should == @o
     @o.position.should == 4
     @db.sqls.should == ["SELECT max(position) FROM items LIMIT 1",
@@ -124,7 +102,7 @@ describe "List plugin" do
   end
 
   it "should have move_down with an argument move down the given number of positions" do
-    y(@c, :max=>10)
+    @c.dataset._fetch = {:max=>10}
     @o.move_down(3).should == @o
     @o.position.should == 6
     @db.sqls.should == ["SELECT max(position) FROM items LIMIT 1",
@@ -141,11 +119,11 @@ describe "List plugin" do
 
   it "should have move_to raise an error if an invalid target is used" do
     proc{@o.move_to(0)}.should raise_error(Sequel::Error)
-    y(@c, :max=>10)
+    @c.dataset._fetch = {:max=>10}
     proc{@o.move_to(11)}.should raise_error(Sequel::Error)
   end
 
-  it "should have move_to use a transaction is the instance is configured to use transactions" do
+  it "should have move_to use a transaction if the instance is configured to use transactions" do
     @o.use_transactions = true
     @o.move_to(2)
     @db.sqls.should == ["BEGIN",
@@ -167,13 +145,13 @@ describe "List plugin" do
   end
 
   it "should have move to shift entries correctly between current and target if moving down" do
-    y(@c, :max=>10)
+    @c.dataset._fetch = {:max=>10}
     @o.move_to(4)
     @db.sqls[1].should == "UPDATE items SET position = (position - 1) WHERE ((position >= 4) AND (position <= 4))"
   end
 
   it "should have move_to_bottom move the item to the last position" do
-    y(@c, :max=>10)
+    @c.dataset._fetch = {:max=>10}
     @o.move_to_bottom
     @db.sqls.should == ["SELECT max(position) FROM items LIMIT 1",
       "UPDATE items SET position = (position - 1) WHERE ((position >= 4) AND (position <= 10))",
@@ -201,7 +179,7 @@ describe "List plugin" do
   end
 
   it "should have move_up with a negative argument move down the given number of positions" do
-    y(@c, :max=>10)
+    @c.dataset._fetch = {:max=>10}
     @o.move_up(-1).should == @o
     @o.position.should == 4
     @db.sqls.should == ["SELECT max(position) FROM items LIMIT 1",
@@ -210,19 +188,19 @@ describe "List plugin" do
   end
 
   it "should have next return the next entry in the list if not given an argument" do
-    y(@c, :id=>9, :position=>4)
+    @c.dataset._fetch = {:id=>9, :position=>4}
     @o.next.should == @c.load(:id=>9, :position=>4)
     @db.sqls.should == ["SELECT * FROM items WHERE (position = 4) ORDER BY position LIMIT 1"]
   end
 
   it "should have next return the entry the given number of positions below the instance if given an argument" do
-    y(@c, :id=>9, :position=>5)
+    @c.dataset._fetch = {:id=>9, :position=>5}
     @o.next(2).should == @c.load(:id=>9, :position=>5)
     @db.sqls.should == ["SELECT * FROM items WHERE (position = 5) ORDER BY position LIMIT 1"]
   end
 
   it "should have next return a previous entry if given a negative argument" do
-    y(@c, :id=>9, :position=>2)
+    @c.dataset._fetch = {:id=>9, :position=>2}
     @o.next(-1).should == @c.load(:id=>9, :position=>2)
     @db.sqls.should == ["SELECT * FROM items WHERE (position = 2) ORDER BY position LIMIT 1"]
   end
@@ -232,19 +210,19 @@ describe "List plugin" do
   end
 
   it "should have prev return the previous entry in the list if not given an argument" do
-    y(@c, :id=>9, :position=>2)
+    @c.dataset._fetch = {:id=>9, :position=>2}
     @o.prev.should == @c.load(:id=>9, :position=>2)
     @db.sqls.should == ["SELECT * FROM items WHERE (position = 2) ORDER BY position LIMIT 1"]
   end
 
   it "should have prev return the entry the given number of positions above the instance if given an argument" do
-    y(@c, :id=>9, :position=>1)
+    @c.dataset._fetch = {:id=>9, :position=>1}
     @o.prev(2).should == @c.load(:id=>9, :position=>1)
     @db.sqls.should == ["SELECT * FROM items WHERE (position = 1) ORDER BY position LIMIT 1"]
   end
 
   it "should have prev return a following entry if given a negative argument" do
-    y(@c, :id=>9, :position=>4)
+    @c.dataset._fetch = {:id=>9, :position=>4}
     @o.prev(-1).should == @c.load(:id=>9, :position=>4)
     @db.sqls.should == ["SELECT * FROM items WHERE (position = 4) ORDER BY position LIMIT 1"]
   end