sequel 3.21.0 → 3.41.0

data/spec/extensions/instance_filters_spec.rb

@@ -2,54 +2,44 @@ require File.join(File.dirname(File.expand_path(__FILE__)), "spec_helper")
 
 describe "instance_filters plugin" do
   before do
-    @c = Class.new(Sequel::Model(:people)) do
-    end
-    @sql = sql = ''
-    @v = v = [1]
+    @c = Class.new(Sequel::Model(:people))
     @c.dataset.quote_identifiers = false
-    @c.dataset.meta_def(:update) do |opts|
-      sql.replace(update_sql(opts))
-      return v.first
-    end
-    @c.dataset.meta_def(:delete) do
-      sql.replace(delete_sql)
-      return v.first
-    end
     @c.columns :id, :name, :num
     @c.plugin :instance_filters
     @p = @c.load(:id=>1, :name=>'John', :num=>1)
+    MODEL_DB.sqls
   end
 
   specify "should raise an error when updating a stale record" do
     @p.update(:name=>'Bob')
-    @sql.should == "UPDATE people SET name = 'Bob' WHERE (id = 1)"
+    MODEL_DB.sqls.should == ["UPDATE people SET name = 'Bob' WHERE (id = 1)"]
     @p.instance_filter(:name=>'Jim')
-    @v.replace([0])
+    @p.this.numrows = 0
     proc{@p.update(:name=>'Joe')}.should raise_error(Sequel::Plugins::InstanceFilters::Error)
-    @sql.should == "UPDATE people SET name = 'Joe' WHERE ((id = 1) AND (name = 'Jim'))"
+    MODEL_DB.sqls.should == ["UPDATE people SET name = 'Joe' WHERE ((id = 1) AND (name = 'Jim'))"]
   end 
 
   specify "should raise an error when destroying a stale record" do
     @p.destroy
-    @sql.should == "DELETE FROM people WHERE (id = 1)"
+    MODEL_DB.sqls.should == ["DELETE FROM people WHERE id = 1"]
     @p.instance_filter(:name=>'Jim')
-    @v.replace([0])
+    @p.this.numrows = 0
     proc{@p.destroy}.should raise_error(Sequel::Plugins::InstanceFilters::Error)
-    @sql.should == "DELETE FROM people WHERE ((id = 1) AND (name = 'Jim'))"
+    MODEL_DB.sqls.should == ["DELETE FROM people WHERE ((id = 1) AND (name = 'Jim'))"]
   end 
   
   specify "should apply all instance filters" do
     @p.instance_filter(:name=>'Jim')
     @p.instance_filter{num > 2}
     @p.update(:name=>'Bob')
-    @sql.should == "UPDATE people SET name = 'Bob' WHERE ((id = 1) AND (name = 'Jim') AND (num > 2))"
+    MODEL_DB.sqls.should == ["UPDATE people SET name = 'Bob' WHERE ((id = 1) AND (name = 'Jim') AND (num > 2))"]
   end 
 
   specify "should drop instance filters after updating" do
     @p.instance_filter(:name=>'Joe')
     @p.update(:name=>'Joe')
-    @sql.should == "UPDATE people SET name = 'Joe' WHERE ((id = 1) AND (name = 'Joe'))"
+    MODEL_DB.sqls.should == ["UPDATE people SET name = 'Joe' WHERE ((id = 1) AND (name = 'Joe'))"]
     @p.update(:name=>'Bob')
-    @sql.should == "UPDATE people SET name = 'Bob' WHERE (id = 1)"
+    MODEL_DB.sqls.should == ["UPDATE people SET name = 'Bob' WHERE (id = 1)"]
   end
 end

data/spec/extensions/instance_hooks_spec.rb

@@ -177,3 +177,75 @@ describe "InstanceHooks plugin" do
     @r.should == [2, 1, 4, 3]
   end
 end
+
+describe "InstanceHooks plugin with transactions" do
+  before do
+    @db = Sequel.mock(:numrows=>1)
+    pr = proc{|x| r(x)}
+    @c = Class.new(Sequel::Model(@db[:items])) do
+      attr_accessor :rb
+      def after_save
+        db.execute('as')
+        raise Sequel::Rollback if rb
+      end
+      def after_destroy
+        db.execute('ad')
+        raise Sequel::Rollback if rb
+      end
+    end
+    @c.use_transactions = true
+    @c.plugin :instance_hooks
+    @o = @c.load({:id=>1})
+    @or = @c.load({:id=>1})
+    @or.rb = true
+    @r = []
+    @db.sqls
+  end
+  
+  it "should support after_commit_hook" do
+    @o.after_commit_hook{@db.execute('ac1')}
+    @o.after_commit_hook{@db.execute('ac2')}
+    @o.save.should_not be_nil
+    @db.sqls.should == ['BEGIN', 'as', 'COMMIT', 'ac1', 'ac2']
+  end
+  
+  it "should support after_rollback_hook" do
+    @or.after_rollback_hook{@db.execute('ar1')}
+    @or.after_rollback_hook{@db.execute('ar2')}
+    @or.save.should be_nil
+    @db.sqls.should == ['BEGIN', 'as', 'ROLLBACK', 'ar1', 'ar2']
+  end
+  
+  it "should support after_commit_hook" do
+    @o.after_destroy_commit_hook{@db.execute('adc1')}
+    @o.after_destroy_commit_hook{@db.execute('adc2')}
+    @o.destroy.should_not be_nil
+    @db.sqls.should == ['BEGIN', "DELETE FROM items WHERE (id = 1)", 'ad', 'COMMIT', 'adc1', 'adc2']
+  end
+  
+  it "should support after_rollback_hook" do
+    @or.after_destroy_rollback_hook{@db.execute('adr1')}
+    @or.after_destroy_rollback_hook{@db.execute('adr2')}
+    @or.destroy.should be_nil
+    @db.sqls.should == ['BEGIN', "DELETE FROM items WHERE (id = 1)", 'ad', 'ROLLBACK', 'adr1', 'adr2']
+  end
+
+  it "should have *_hook methods return self "do
+    @o.before_destroy_hook{r 1}.should equal(@o)
+    @o.before_validation_hook{r 1}.should equal(@o)
+    @o.before_save_hook{r 1}.should equal(@o)
+    @o.before_update_hook{r 1}.should equal(@o)
+    @o.before_create_hook{r 1}.should equal(@o)
+
+    @o.after_destroy_hook{r 1}.should equal(@o)
+    @o.after_validation_hook{r 1}.should equal(@o)
+    @o.after_save_hook{r 1}.should equal(@o)
+    @o.after_update_hook{r 1}.should equal(@o)
+    @o.after_create_hook{r 1}.should equal(@o)
+    @o.after_commit_hook{r 1}.should equal(@o)
+    @o.after_rollback_hook{r 1}.should equal(@o)
+    @o.after_destroy_commit_hook{r 1}.should equal(@o)
+    @o.after_destroy_rollback_hook{r 1}.should equal(@o)
+  end
+
+end

data/spec/extensions/json_serializer_spec.rb

@@ -1,10 +1,5 @@
 require File.join(File.dirname(File.expand_path(__FILE__)), "spec_helper")
 
-begin
-  require 'json'
-rescue LoadError => e
-  skip_warn "json_serializer plugin: can't load json (#{e.class}: #{e})"
-else
 describe "Sequel::Plugins::JsonSerializer" do
   before do
     class ::Artist < Sequel::Model
@@ -96,14 +91,30 @@ describe "Sequel::Plugins::JsonSerializer" do
     @artist.id.should == 2
   end
 
+  it "should support #from_json to support specific :fields" do
+    @album.from_json('{"name": "AS", "artist_id": 3}', :fields=>['name'])
+    @album.name.should == 'AS'
+    @album.artist_id.should == 2
+  end
+
+  it "should support #from_json to support :missing=>:skip option" do
+    @album.from_json('{"artist_id": 3}', :fields=>['name'], :missing=>:skip)
+    @album.name.should == 'RF'
+    @album.artist_id.should == 2
+  end
+
+  it "should support #from_json to support :missing=>:raise option" do
+    proc{@album.from_json('{"artist_id": 3}', :fields=>['name'], :missing=>:raise)}.should raise_error(Sequel::Error)
+  end
+
   it "should raise an exception for json keys that aren't associations, columns, or setter methods" do
     Album.send(:undef_method, :blah=)
     proc{JSON.parse(@album.to_json(:include=>:blah))}.should raise_error(Sequel::Error)
   end
 
   it "should support a to_json class and dataset method" do
-    album = @album
-    Album.dataset.meta_def(:all){[album]}
+    Album.dataset._fetch = {:id=>1, :name=>'RF', :artist_id=>2}
+    Artist.dataset._fetch = {:id=>2, :name=>'YJM'}
     JSON.parse(Album.to_json).should == [@album]
     JSON.parse(Album.to_json(:include=>:artist)).map{|x| x.artist}.should == [@artist]
     JSON.parse(Album.dataset.to_json(:only=>:name)).should == [Album.load(:name=>@album.name)]
@@ -112,10 +123,23 @@ describe "Sequel::Plugins::JsonSerializer" do
   it "should have dataset to_json method work with naked datasets" do
     album = @album
     ds = Album.dataset.naked
-    ds.meta_def(:all){[album.values]}
+    ds._fetch = {:id=>1, :name=>'RF', :artist_id=>2}
     JSON.parse(ds.to_json).should == [@album.values.inject({}){|h, (k, v)| h[k.to_s] = v; h}]
   end
 
+  it "should have dataset to_json method respect :array option for the array to use" do
+    a = Album.load(:id=>1, :name=>'RF', :artist_id=>3)
+    JSON.parse(Album.to_json(:array=>[a])).should == [a]
+
+    a.associations[:artist] = artist = Artist.load(:id=>3, :name=>'YJM')
+    JSON.parse(Album.to_json(:array=>[a], :include=>:artist)).first.artist.should == artist
+
+    artist.associations[:albums] = [a]
+    x = JSON.parse(Artist.to_json(:array=>[artist], :include=>:albums))
+    x.should == [artist]
+    x.first.albums.should == [a]
+  end
+
   it "should propagate class default options to instance to_json output" do
     class ::Album2 < Sequel::Model
       attr_accessor :blah
@@ -136,9 +160,23 @@ describe "Sequel::Plugins::JsonSerializer" do
     @album.to_json(:root=>true, :only => :name).to_s.should == '{"album":{"name":"RF"}}'
   end
   
-  it "should handle the :root option to qualify a dataset of records" do
-    album = @album
-    Album.dataset.meta_def(:all){[album, album]}
+  it "should handle the :root=>:both option to qualify a dataset of records" do
+    Album.dataset._fetch = [{:id=>1, :name=>'RF'}, {:id=>1, :name=>'RF'}]
+    Album.dataset.to_json(:root=>true, :only => :id).to_s.should == '{"albums":[{"album":{"id":1}},{"album":{"id":1}}]}'
+  end
+
+  it "should handle the :root=>:collection option to qualify just the collection" do
+    Album.dataset._fetch = [{:id=>1, :name=>'RF'}, {:id=>1, :name=>'RF'}]
+    Album.dataset.to_json(:root=>:collection, :only => :id).to_s.should == '{"albums":[{"id":1},{"id":1}]}'
+  end
+
+  it "should handle the :root=>:instance option to qualify just the instances" do
+    Album.dataset._fetch = [{:id=>1, :name=>'RF'}, {:id=>1, :name=>'RF'}]
+    Album.dataset.to_json(:root=>:instance, :only => :id).to_s.should == '[{"album":{"id":1}},{"album":{"id":1}}]'
+  end
+
+  it "should handle the :root=>true option be the same as :root=>:both for backwards compatibility" do
+    Album.dataset._fetch = [{:id=>1, :name=>'RF'}, {:id=>1, :name=>'RF'}]
     Album.dataset.to_json(:root=>true, :only => :id).to_s.should == '{"albums":[{"album":{"id":1}},{"album":{"id":1}}]}'
   end
 
@@ -162,4 +200,3 @@ describe "Sequel::Plugins::JsonSerializer" do
     Object.send(:remove_const, :Artist3)
   end
 end
-end

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'])
+      instance_dataset._fetch = 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")})
+    @c.instance_dataset._fetch = @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

@@ -1,4 +1,4 @@
-require File.join(File.dirname(File.expand_path(__FILE__)), '/spec_helper')
+require File.join(File.dirname(File.expand_path(__FILE__)), 'spec_helper')
 
 describe "List plugin" do
   def klass(opts={})
@@ -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,49 @@ 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 position field set to max+1 when creating if not already set" do
+    @c.instance_dataset._fetch = @c.dataset._fetch = [[{:pos=>nil}], [{:id=>1, :position=>1}], [{:pos=>1}], [{:id=>2, :position=>2}]]
+    @c.instance_dataset.autoid = @c.dataset.autoid = 1
+    @c.create.values.should == {:id=>1, :position=>1}
+    @c.create.values.should == {:id=>2, :position=>2}
+    @db.sqls.should == ["SELECT max(position) FROM items LIMIT 1",
+      "INSERT INTO items (position) VALUES (1)", 
+      "SELECT * FROM items WHERE (id = 1) ORDER BY position LIMIT 1",
+      "SELECT max(position) FROM items LIMIT 1",
+      "INSERT INTO items (position) VALUES (2)", 
+      "SELECT * FROM items WHERE (id = 2) ORDER BY position LIMIT 1"]
+  end
+
+  it "should have position field set to max+1 in scope when creating if not already set" do
+    @sc.instance_dataset._fetch = @sc.dataset._fetch = [[{:pos=>nil}], [{:id=>1, :scope_id=>1, :position=>1}], [{:pos=>1}], [{:id=>2, :scope_id=>1, :position=>2}], [{:pos=>nil}], [{:id=>3, :scope_id=>2, :position=>1}]]
+    @sc.instance_dataset.autoid = @sc.dataset.autoid = 1
+    @sc.create(:scope_id=>1).values.should == {:id=>1, :scope_id=>1, :position=>1}
+    @sc.create(:scope_id=>1).values.should == {:id=>2, :scope_id=>1, :position=>2}
+    @sc.create(:scope_id=>2).values.should == {:id=>3, :scope_id=>2, :position=>1}
+    sqls = @db.sqls
+    sqls.slice!(7).should =~ /INSERT INTO items \((scope_id|position), (scope_id|position)\) VALUES \([12], [12]\)/
+    sqls.slice!(4).should =~ /INSERT INTO items \((scope_id|position), (scope_id|position)\) VALUES \([12], [12]\)/
+    sqls.slice!(1).should =~ /INSERT INTO items \((scope_id|position), (scope_id|position)\) VALUES \(1, 1\)/
+    sqls.should == ["SELECT max(position) FROM items WHERE (scope_id = 1) LIMIT 1",
+      "SELECT * FROM items WHERE (id = 1) ORDER BY scope_id, position LIMIT 1",
+      "SELECT max(position) FROM items WHERE (scope_id = 1) LIMIT 1",
+      "SELECT * FROM items WHERE (id = 2) ORDER BY scope_id, position LIMIT 1",
+      "SELECT max(position) FROM items WHERE (scope_id = 2) LIMIT 1",
+      "SELECT * FROM items WHERE (id = 3) 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 +124,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 +133,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 +150,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 +176,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 +210,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 +219,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 +241,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

data/spec/extensions/looser_typecasting_spec.rb

@@ -4,18 +4,18 @@ describe "LooserTypecasting Extension" do
   before do
     @db = Sequel::Database.new({})
     def @db.schema(*args)
-      [[:id, {}], [:y, {:type=>:float}], [:b, {:type=>:integer}]]
+      [[:id, {}], [:z, {:type=>:float}], [:b, {:type=>:integer}]]
     end 
     @c = Class.new(Sequel::Model(@db[:items]))
     @c.instance_eval do
-      @columns = [:id, :b, :y] 
+      @columns = [:id, :b, :z] 
       def columns; @columns; end 
     end
   end
 
   specify "Should use to_i instead of Integer() for typecasting integers" do
     proc{@c.new(:b=>'a')}.should raise_error(Sequel::InvalidValue)
-    @db.extend(Sequel::LooserTypecasting)
+    @db.extension(:looser_typecasting)
     @c.new(:b=>'a').b.should == 0
 
     o = Object.new
@@ -26,14 +26,14 @@ describe "LooserTypecasting Extension" do
   end
 
   specify "Should use to_f instead of Float() for typecasting floats" do
-    proc{@c.new(:y=>'a')}.should raise_error(Sequel::InvalidValue)
-    @db.extend(Sequel::LooserTypecasting)
-    @c.new(:y=>'a').y.should == 0.0
+    proc{@c.new(:z=>'a')}.should raise_error(Sequel::InvalidValue)
+    @db.extension(:looser_typecasting)
+    @c.new(:z=>'a').z.should == 0.0
 
     o = Object.new
     def o.to_f
       1.0
     end
-    @c.new(:y=>o).y.should == 1.0
+    @c.new(:z=>o).z.should == 1.0
   end
 end