sequel 4.41.0 → 4.42.0

data/spec/extensions/active_model_spec.rb

@@ -33,25 +33,25 @@ describe "ActiveModel plugin" do
   end
   
   it "#to_key should return a key array, or nil" do
-    @o.to_key.must_equal nil
+    @o.to_key.must_be_nil
     @o.id = 1
     @o.to_key.must_equal [1]
     @o.id = nil
-    @o.to_key.must_equal nil
+    @o.to_key.must_be_nil
 
     @c.set_primary_key [:id2, :id]
-    @o.to_key.must_equal nil
+    @o.to_key.must_be_nil
     @o.id = 1
     @o.id2 = 2
     @o.to_key.must_equal [2, 1]
     @o.destroy
     @o.to_key.must_equal [2, 1]
     @o.id = nil
-    @o.to_key.must_equal nil
+    @o.to_key.must_be_nil
   end
   
   it "#to_param should return a param string or nil" do
-    @o.to_param.must_equal nil
+    @o.to_param.must_be_nil
     @o.id = 1
     @o.to_param.must_equal '1'
     @c.set_primary_key [:id2, :id]
@@ -60,7 +60,7 @@ describe "ActiveModel plugin" do
     @o.meta_def(:to_param_joiner){'|'}
     @o.to_param.must_equal '2|1'
     @o.destroy
-    @o.to_param.must_equal nil
+    @o.to_param.must_be_nil
   end
 
   it "#persisted? should return true if the object exists and has not been destroyed" do

data/spec/extensions/association_dependencies_spec.rb

@@ -6,9 +6,9 @@ describe "AssociationDependencies plugin" do
     @c = Class.new(Sequel::Model)
     @c.plugin :association_dependencies
     @Artist = Class.new(@c).set_dataset(:artists)
-    @Artist.dataset._fetch = {:id=>2, :name=>'Ar'}
+    @Artist.dataset = @Artist.dataset.with_fetch(:id=>2, :name=>'Ar')
     @Album = Class.new(@c).set_dataset(:albums)
-    @Album.dataset._fetch = {:id=>1, :name=>'Al', :artist_id=>2}
+    @Album.dataset = @Album.dataset.with_fetch(:id=>1, :name=>'Al', :artist_id=>2)
     @Artist.columns :id, :name
     @Album.columns :id, :name, :artist_id
     @Artist.one_to_many :albums, :class=>@Album, :key=>:artist_id

data/spec/extensions/blacklist_security_spec.rb

@@ -50,7 +50,7 @@ describe Sequel::Model, ".restricted_columns " do
   end
   
   it "should set the restricted columns correctly" do
-    @c.restricted_columns.must_equal nil
+    @c.restricted_columns.must_be_nil
     @c.set_restricted_columns :x
     @c.restricted_columns.must_equal [:x]
     @c.set_restricted_columns :x, :y
@@ -64,7 +64,7 @@ describe Sequel::Model, ".restricted_columns " do
     i.set(:x => 4, :y => 5, :z => 6)
     i.values.must_equal(:x => 4, :y => 5)
 
-    @c.instance_dataset._fetch = @c.dataset._fetch = {:x => 7}
+    @c.dataset = @c.dataset.with_fetch(:x => 7)
     i = @c.new
     i.update(:x => 7, :z => 9)
     i.values.must_equal(:x => 7)
@@ -79,7 +79,7 @@ describe Sequel::Model, ".restricted_columns " do
     i.set(:x => 4, :y => 5, :z => 6)
     i.values.must_equal(:x => 4, :y => 5)
 
-    @c.instance_dataset._fetch = @c.dataset._fetch = {:y => 7}
+    @c.dataset = @c.dataset.with_fetch(:y => 7)
     i = @c.new
     i.update(:y => 7, :z => 9)
     i.values.must_equal(:y => 7)

data/spec/extensions/boolean_readers_spec.rb

@@ -19,13 +19,13 @@ describe Sequel::Model, "BooleanReaders plugin" do
   it "should create attribute? readers for all boolean attributes" do
     @c.plugin(:boolean_readers)
     o = @c.new
-    o.b?.must_equal nil
+    o.b?.must_be_nil
     o.b = '1'
     o.b?.must_equal true
     o.b = '0'
     o.b?.must_equal false
     o.b = ''
-    o.b?.must_equal nil
+    o.b?.must_be_nil
   end
 
   it "should not create attribute? readers for non-boolean attributes" do
@@ -38,8 +38,8 @@ describe Sequel::Model, "BooleanReaders plugin" do
     @c.plugin(:boolean_readers){|c| db_schema[c][:db_type] == 'tinyint(1)'}
     proc{@c.new.b?}.must_raise(NoMethodError)
     o = @c.new
-    o.z.must_equal nil
-    o.z?.must_equal nil
+    o.z.must_be_nil
+    o.z?.must_be_nil
     o.z = '1'
     o.z.must_equal 1
     o.z?.must_equal true
@@ -47,8 +47,8 @@ describe Sequel::Model, "BooleanReaders plugin" do
     o.z.must_equal 0
     o.z?.must_equal false
     o.z = ''
-    o.z.must_equal nil
-    o.z?.must_equal nil
+    o.z.must_be_nil
+    o.z?.must_be_nil
   end
 
   it "should create boolean readers when set_dataset is defined" do
@@ -57,13 +57,13 @@ describe Sequel::Model, "BooleanReaders plugin" do
     c.plugin(:boolean_readers)
     c.set_dataset(@db[:a])
     o = c.new
-    o.b?.must_equal nil
+    o.b?.must_be_nil
     o.b = '1'
     o.b?.must_equal true
     o.b = '0'
     o.b?.must_equal false
     o.b = ''
-    o.b?.must_equal nil
+    o.b?.must_be_nil
     proc{o.i?}.must_raise(NoMethodError)
 
     c = Class.new(Sequel::Model(@db))
@@ -71,8 +71,8 @@ describe Sequel::Model, "BooleanReaders plugin" do
     c.plugin(:boolean_readers){|x| db_schema[x][:db_type] == 'tinyint(1)'}
     c.set_dataset(@db[:a])
     o = c.new
-    o.z.must_equal nil
-    o.z?.must_equal nil
+    o.z.must_be_nil
+    o.z?.must_be_nil
     o.z = '1'
     o.z.must_equal 1
     o.z?.must_equal true
@@ -80,8 +80,8 @@ describe Sequel::Model, "BooleanReaders plugin" do
     o.z.must_equal 0
     o.z?.must_equal false
     o.z = ''
-    o.z.must_equal nil
-    o.z?.must_equal nil
+    o.z.must_be_nil
+    o.z?.must_be_nil
     proc{o.b?}.must_raise(NoMethodError)
   end
 

data/spec/extensions/caching_spec.rb

@@ -43,13 +43,15 @@ describe Sequel::Model, "caching" do
       columns :name, :id
     end
    
-    @dataset = @c.dataset = @c3.dataset = @c4.dataset
-    @dataset._fetch = {:name => 'sharon'.dup, :id => 1}
-    @dataset.numrows = 1
     
     @c2 = Class.new(@c) do
       def self.name; 'SubItem' end
     end    
+
+    [@c, @c2, @c3, @c4].each do |c|
+      c.dataset = c.dataset.with_fetch(:name => 'sharon'.dup, :id => 1).with_numrows(1)
+    end
+
     @c.db.reset
   end
   
@@ -164,7 +166,7 @@ describe Sequel::Model, "caching" do
   end
 
   it "should handle lookups by nil primary keys" do
-    @c[nil].must_equal nil
+    @c[nil].must_be_nil
     @c.db.sqls.must_equal []
   end
   
@@ -200,7 +202,7 @@ describe Sequel::Model, "caching" do
   
   it "should support #[] as a shortcut to #find with hash" do
     m = @c[:id => 3]
-    @cache[m.cache_key].must_equal nil
+    @cache[m.cache_key].must_be_nil
     @c.db.sqls.must_equal ["SELECT * FROM items WHERE (id = 3) LIMIT 1"]
     m = @c[1]
     @cache[m.cache_key].must_equal m
@@ -209,7 +211,7 @@ describe Sequel::Model, "caching" do
     @c.db.sqls.must_equal ["SELECT * FROM items WHERE (id = 4) LIMIT 1"]
 
     m = @c2[:id => 3]
-    @cache[m.cache_key].must_equal nil
+    @cache[m.cache_key].must_be_nil
     @c.db.sqls.must_equal ["SELECT * FROM items WHERE (id = 3) LIMIT 1"]
     m = @c2[1]
     @cache[m.cache_key].must_equal m
@@ -232,13 +234,14 @@ describe Sequel::Model, "caching" do
   
   it "should rescue an exception if cache_store is memcached and ignore_exception is enabled" do
     @c4[1].values.must_equal(:name => 'sharon', :id => 1)
+    @c4.dataset = @c4.dataset.with_fetch(:name => 'sharon', :id => 1, :x=>1)
     m = @c4.new.save
     m.update({:name=>'blah'})
     m.values.must_equal(:name => 'blah', :id => 1, :x => 1)
   end
   
   it "should support Model.cache_get_pk for getting a value from the cache by primary key" do
-    @c.cache_get_pk(1).must_equal nil
+    @c.cache_get_pk(1).must_be_nil
     m = @c[1]
     @c.cache_get_pk(1).must_equal m
   end
@@ -246,8 +249,8 @@ describe Sequel::Model, "caching" do
   it "should support Model.cache_delete_pk for removing a value from the cache by primary key" do
     @c[1]
     @c.cache_get_pk(1).wont_equal nil
-    @c.cache_delete_pk(1).must_equal nil
-    @c.cache_get_pk(1).must_equal nil
+    @c.cache_delete_pk(1).must_be_nil
+    @c.cache_get_pk(1).must_be_nil
   end
 
   it "should support overriding the cache key prefix" do
@@ -258,7 +261,7 @@ describe Sequel::Model, "caching" do
     c2.cache_key(:id).must_equal c3.cache_key(:id)
     
     @c[1]
-    c2.cache_get_pk(1).must_equal nil
+    c2.cache_get_pk(1).must_be_nil
     m = c2[1]
     c2.cache_get_pk(1).values.must_equal @c[1].values
     c3.cache_get_pk(1).values.must_equal m.values

data/spec/extensions/class_table_inheritance_spec.rb

@@ -71,15 +71,15 @@ describe "class_table_inheritance plugin" do
   end
 
   it "should have simple_table = nil for all subclasses" do
-    Manager.simple_table.must_equal nil
-    Executive.simple_table.must_equal nil
-    Ceo.simple_table.must_equal nil
-    Staff.simple_table.must_equal nil
+    Manager.simple_table.must_be_nil
+    Executive.simple_table.must_be_nil
+    Ceo.simple_table.must_be_nil
+    Staff.simple_table.must_be_nil
   end
   
   it "should have working row_proc if using set_dataset in subclass to remove columns" do
     Manager.set_dataset(Manager.dataset.select(*(Manager.columns - [:blah])))
-    Manager.dataset._fetch = {:id=>1, :kind=>'Ceo'}
+    Manager.dataset = Manager.dataset.with_fetch(:id=>1, :kind=>'Ceo')
     Manager[1].must_equal Ceo.load(:id=>1, :kind=>'Ceo')
   end
 
@@ -92,18 +92,16 @@ describe "class_table_inheritance plugin" do
   end
   
   it "should return rows with the correct class based on the polymorphic_key value" do
-    @ds._fetch = [{:kind=>'Employee'}, {:kind=>'Manager'}, {:kind=>'Executive'}, {:kind=>'Ceo'}, {:kind=>'Staff'}]
-    Employee.all.collect{|x| x.class}.must_equal [Employee, Manager, Executive, Ceo, Staff]
+    @ds.with_fetch([{:kind=>'Employee'}, {:kind=>'Manager'}, {:kind=>'Executive'}, {:kind=>'Ceo'}, {:kind=>'Staff'}]).all.collect{|x| x.class}.must_equal [Employee, Manager, Executive, Ceo, Staff]
   end 
   
   it "should return rows with the correct class based on the polymorphic_key value for subclasses" do
-    Manager.dataset._fetch = [{:kind=>'Manager'}, {:kind=>'Executive'}, {:kind=>'Ceo'}]
-    Manager.all.collect{|x| x.class}.must_equal [Manager, Executive, Ceo]
+    Manager.dataset.with_fetch([{:kind=>'Manager'}, {:kind=>'Executive'}, {:kind=>'Ceo'}]).all.collect{|x| x.class}.must_equal [Manager, Executive, Ceo]
   end
   
   it "should have refresh return all columns in subclass after loading from superclass" do
-    Employee.dataset._fetch = [{:id=>1, :name=>'A', :kind=>'Ceo'}]
-    Ceo.instance_dataset._fetch = [{:id=>1, :name=>'A', :kind=>'Ceo', :num_staff=>3, :num_managers=>2}]
+    Employee.dataset = Employee.dataset.with_fetch([{:id=>1, :name=>'A', :kind=>'Ceo'}])
+    Ceo.dataset = Ceo.dataset.with_fetch([{:id=>1, :name=>'A', :kind=>'Ceo', :num_staff=>3, :num_managers=>2}])
     a = Employee.first
     a.class.must_equal Ceo
     a.values.must_equal(:id=>1, :name=>'A', :kind=>'Ceo')
@@ -114,8 +112,7 @@ describe "class_table_inheritance plugin" do
   
   it "should return rows with the current class if cti_key is nil" do
     Employee.plugin(:class_table_inheritance)
-    Employee.dataset._fetch = [{:kind=>'Employee'}, {:kind=>'Manager'}, {:kind=>'Executive'}, {:kind=>'Ceo'}, {:kind=>'Staff'}]
-    Employee.all.collect{|x| x.class}.must_equal [Employee, Employee, Employee, Employee, Employee]
+    Employee.dataset.with_fetch([{:kind=>'Employee'}, {:kind=>'Manager'}, {:kind=>'Executive'}, {:kind=>'Ceo'}, {:kind=>'Staff'}]).all.map{|x| x.class}.must_equal [Employee, Employee, Employee, Employee, Employee]
   end
   
   it "should return rows with the current class if cti_key is nil in subclasses" do
@@ -124,8 +121,7 @@ describe "class_table_inheritance plugin" do
     Object.send(:remove_const, :Manager)
     class ::Manager < Employee; end 
     class ::Executive < Manager; end 
-    Manager.dataset._fetch = [{:kind=>'Manager'}, {:kind=>'Executive'}]
-    Manager.all.collect{|x| x.class}.must_equal [Manager, Manager]
+    Manager.dataset.with_fetch([{:kind=>'Manager'}, {:kind=>'Executive'}]).all.map{|x| x.class}.must_equal [Manager, Manager]
   end
   
   it "should handle a model map with integer values" do
@@ -136,20 +132,18 @@ describe "class_table_inheritance plugin" do
     class ::Manager < Employee; end 
     class ::Executive < Manager; end 
     class ::Ceo < Executive; end 
-    Employee.dataset._fetch = [{:kind=>nil},{:kind=>0},{:kind=>1}, {:kind=>2}, {:kind=>3}]
+    Employee.dataset = Employee.dataset.with_fetch([{:kind=>nil},{:kind=>0},{:kind=>1}, {:kind=>2}, {:kind=>3}])
     Employee.all.collect{|x| x.class}.must_equal [Employee, Employee, Manager, Executive, Ceo]
-    Manager.dataset._fetch = [{:kind=>nil},{:kind=>0},{:kind=>1}, {:kind=>2}, {:kind=>3}]
+    Manager.dataset = Manager.dataset.with_fetch([{:kind=>nil},{:kind=>0},{:kind=>1}, {:kind=>2}, {:kind=>3}])
     Manager.all.collect{|x| x.class}.must_equal [Manager, Employee, Manager, Executive, Ceo]
   end
   
   it "should fallback to the main class if the given class does not exist" do
-    @ds._fetch = [{:kind=>'Employee'}, {:kind=>'Manager'}, {:kind=>'Blah'}, {:kind=>'Staff'}]
-    Employee.all.collect{|x| x.class}.must_equal [Employee, Manager, Employee, Staff]
+    @ds.with_fetch([{:kind=>'Employee'}, {:kind=>'Manager'}, {:kind=>'Blah'}, {:kind=>'Staff'}]).all.map{|x| x.class}.must_equal [Employee, Manager, Employee, Staff]
   end
   
   it "should fallback to the main class if the given class does not exist in subclasses" do
-    Manager.dataset._fetch = [{:kind=>'Manager'}, {:kind=>'Executive'}, {:kind=>'Ceo'}, {:kind=>'Blah'}]
-    Manager.all.collect{|x| x.class}.must_equal [Manager, Executive, Ceo, Manager]
+    Manager.dataset.with_fetch([{:kind=>'Manager'}, {:kind=>'Executive'}, {:kind=>'Ceo'}, {:kind=>'Blah'}]).all.map{|x| x.class}.must_equal [Manager, Executive, Ceo, Manager]
   end
 
   it "should sets the model class name for the key when creating new parent class records" do
@@ -194,7 +188,7 @@ describe "class_table_inheritance plugin" do
   end
 
   it "should lazily load attributes for columns in subclass tables" do
-    Manager.instance_dataset._fetch = Manager.dataset._fetch = {:id=>1, :name=>'J', :kind=>'Ceo', :num_staff=>2}
+    Manager.dataset = Manager.dataset.with_fetch(:id=>1, :name=>'J', :kind=>'Ceo', :num_staff=>2)
     m = Manager[1]
     @db.sqls.must_equal ['SELECT employees.id, employees.name, employees.kind, managers.num_staff FROM employees INNER JOIN managers ON (managers.id = employees.id) WHERE (managers.id = 1) LIMIT 1']
     @db.fetch = {:num_managers=>3}
@@ -205,8 +199,8 @@ describe "class_table_inheritance plugin" do
   end
 
   it "should lazily load columns in middle classes correctly when loaded from parent class" do
-    Employee.dataset._fetch = {:id=>1, :kind=>'Ceo'}
-    Manager.dataset._fetch = {:num_staff=>2}
+    Employee.dataset = Employee.dataset.with_fetch(:id=>1, :kind=>'Ceo')
+    @db.fetch = [[:num_staff=>2]]
     e = Employee[1]
     e.must_be_kind_of(Ceo)
     @db.sqls.must_equal ["SELECT * FROM employees WHERE (id = 1) LIMIT 1"]
@@ -215,9 +209,8 @@ describe "class_table_inheritance plugin" do
   end
 
   it "should eagerly load lazily columns in subclasses when loaded from parent class" do
-    Employee.dataset._fetch = {:id=>1, :kind=>'Ceo'}
-    Manager.dataset._fetch = {:id=>1, :num_staff=>2}
-    @db.fetch = {:id=>1, :num_managers=>3}
+    Employee.dataset = Employee.dataset.with_fetch(:id=>1, :kind=>'Ceo')
+    @db.fetch = [[{:id=>1, :num_staff=>2}], [{:id=>1, :num_managers=>3}]]
     e = Employee.all.first
     e.must_be_kind_of(Ceo)
     @db.sqls.must_equal ["SELECT * FROM employees"]
@@ -267,13 +260,15 @@ describe "class_table_inheritance plugin" do
     sqls[2].must_match(/INSERT INTO executives \((num_managers|id), (num_managers|id)\) VALUES \([13], [13]\)/)
   end
     
-  it "should insert the correct rows into all tables when inserting when insert select is important" do
-    [Ceo, Manager, Employee].each do |klass|
-      def (klass.cti_instance_dataset).supports_insert_select?; true; end
-      def (klass.cti_instance_dataset).insert_select(v)
-        db.run(insert_sql(v) + " RETURNING *")
-        v.merge(:id=>1)
-      end
+  it "should insert the correct rows into all tables when inserting when insert_select is supported" do
+    [Executive, Manager, Employee].each do |klass|
+      klass.instance_variable_set(:@cti_instance_dataset, klass.cti_instance_dataset.with_extend do
+        def supports_insert_select?; true; end
+        def insert_select(v)
+          db.run(insert_sql(v) + " RETURNING *")
+          v.merge(:id=>1)
+        end
+      end)
     end
     Ceo.create(:num_managers=>3, :num_staff=>2, :name=>'E')
     sqls = @db.sqls
@@ -300,13 +295,13 @@ describe "class_table_inheritance plugin" do
   end
 
   it "should handle many_to_one relationships correctly" do
-    Manager.dataset._fetch = {:id=>3, :name=>'E', :kind=>'Ceo', :num_managers=>3}
+    Manager.dataset = Manager.dataset.with_fetch(:id=>3, :name=>'E', :kind=>'Ceo', :num_managers=>3)
     Staff.load(:manager_id=>3).manager.must_equal Ceo.load(:id=>3, :name=>'E', :kind=>'Ceo', :num_managers=>3)
     @db.sqls.must_equal ['SELECT employees.id, employees.name, employees.kind, managers.num_staff FROM employees INNER JOIN managers ON (managers.id = employees.id) WHERE (managers.id = 3) LIMIT 1']
   end
   
   it "should handle one_to_many relationships correctly" do
-    Staff.dataset._fetch = {:id=>1, :name=>'S', :kind=>'Staff', :manager_id=>3}
+    Staff.dataset = Staff.dataset.with_fetch(:id=>1, :name=>'S', :kind=>'Staff', :manager_id=>3)
     Ceo.load(:id=>3).staff_members.must_equal [Staff.load(:id=>1, :name=>'S', :kind=>'Staff', :manager_id=>3)]
     @db.sqls.must_equal ['SELECT employees.id, employees.name, employees.kind, staff.manager_id FROM employees INNER JOIN staff ON (staff.id = employees.id) WHERE (staff.manager_id = 3)']
   end
@@ -361,14 +356,14 @@ describe "class_table_inheritance plugin without sti_key" do
   end
 
   it "should have simple_table = nil for all subclasses" do
-    Manager.simple_table.must_equal nil
-    Executive.simple_table.must_equal nil
-    Staff.simple_table.must_equal nil
+    Manager.simple_table.must_be_nil
+    Executive.simple_table.must_be_nil
+    Staff.simple_table.must_be_nil
   end
   
   it "should have working row_proc if using set_dataset in subclass to remove columns" do
     Manager.set_dataset(Manager.dataset.select(*(Manager.columns - [:blah])))
-    Manager.dataset._fetch = {:id=>1}
+    Manager.dataset = Manager.dataset.with_fetch(:id=>1)
     Manager[1].must_equal Manager.load(:id=>1)
   end
 
@@ -381,7 +376,7 @@ describe "class_table_inheritance plugin without sti_key" do
   
   it "should return rows with the current class if cti_key is nil" do
     Employee.plugin(:class_table_inheritance)
-    Employee.dataset._fetch = [{}]
+    Employee.dataset = Employee.dataset.with_fetch([{}])
     Employee.first.class.must_equal Employee
   end
   
@@ -442,13 +437,13 @@ describe "class_table_inheritance plugin without sti_key" do
   end
 
   it "should handle many_to_one relationships correctly" do
-    Manager.dataset._fetch = {:id=>3, :name=>'E',  :num_staff=>3}
+    Manager.dataset = Manager.dataset.with_fetch(:id=>3, :name=>'E',  :num_staff=>3)
     Staff.load(:manager_id=>3).manager.must_equal Manager.load(:id=>3, :name=>'E', :num_staff=>3)
     @db.sqls.must_equal ['SELECT employees.id, employees.name, managers.num_staff FROM employees INNER JOIN managers ON (managers.id = employees.id) WHERE (managers.id = 3) LIMIT 1']
   end
   
   it "should handle one_to_many relationships correctly" do
-    Staff.dataset._fetch = {:id=>1, :name=>'S', :manager_id=>3}
+    Staff.dataset = Staff.dataset.with_fetch(:id=>1, :name=>'S', :manager_id=>3)
     Executive.load(:id=>3).staff_members.must_equal [Staff.load(:id=>1, :name=>'S', :manager_id=>3)]
     @db.sqls.must_equal ['SELECT employees.id, employees.name, staff.manager_id FROM employees INNER JOIN staff ON (staff.id = employees.id) WHERE (staff.manager_id = 3)']
   end

data/spec/extensions/column_conflicts_spec.rb

@@ -50,9 +50,7 @@ describe "column_conflicts plugin" do
   end
 
   it "should work correctly for dataset changes" do
-    ds = @db[:test]
-    def ds.columns; [:object_id] end
-    @c.dataset = ds
+    @c.dataset = @db[:test].with_extend{def columns; [:object_id] end}
     o = @c.load(:object_id=>3)
     o.get_column_value(:object_id).must_equal 3
     o.object_id.wont_equal 3

data/spec/extensions/columns_introspection_spec.rb

@@ -10,7 +10,7 @@ describe "columns_introspection extension" do
   end
 
   it "should not issue a database query if the columns are already loaded" do
-    @ds.instance_variable_set(:@columns, [:x])
+    @ds.send(:columns=, [:x])
     @ds.columns.must_equal [:x]
     @db.sqls.length.must_equal 0
   end
@@ -74,8 +74,7 @@ describe "columns_introspection extension" do
 
   it "should issue a database query when common table expressions are used" do
     @db.instance_variable_set(:@schemas, "a"=>[[:x, {}]])
-    def @ds.supports_cte?(*) true end
-    @ds.with(:a, @ds).columns
+    @ds.with_extend{def supports_cte?(*) true end}.with(:a, @ds).columns
     @db.sqls.length.must_equal 1
   end