sequel 4.36.0 → 5.61.0

data/spec/extensions/sharding_spec.rb

@@ -1,198 +0,0 @@
-require File.join(File.dirname(File.expand_path(__FILE__)), "spec_helper")
-
-describe "sharding plugin" do
-  before do
-    @db = Sequel.mock(:numrows=>1, :autoid=>proc{1}, :servers=>{:s1=>{}, :s2=>{}, :s3=>{}, :s4=>{}})
-    @Artist = Class.new(Sequel::Model(@db[:artists]))
-    @Artist.class_eval do
-      instance_dataset._fetch = dataset._fetch = {:id=>2, :name=>'YJM'}
-      columns :id, :name
-      plugin :sharding
-    end
-    @Album = Class.new(Sequel::Model(@db[:albums]))
-    @Album.class_eval do
-      instance_dataset._fetch = dataset._fetch = {:id=>1, :name=>'RF', :artist_id=>2}
-      columns :id, :artist_id, :name
-      plugin :sharding
-    end
-    @Tag = Class.new(Sequel::Model(@db[:tags]))
-    @Tag.class_eval do
-      instance_dataset._fetch = dataset._fetch = {:id=>3, :name=>'M'}
-      columns :id, :name
-      plugin :sharding
-    end
-    @Artist.one_to_many :albums, :class=>@Album, :key=>:artist_id
-    @Album.many_to_one :artist, :class=>@Artist
-    @Album.many_to_many :tags, :class=>@Tag, :left_key=>:album_id, :right_key=>:tag_id, :join_table=>:albums_tags
-    @db.sqls
-  end 
-
-  it "should allow you to instantiate a new object for a specified shard" do
-    @Album.new_using_server(:s1, :name=>'RF').save
-    @db.sqls.must_equal ["INSERT INTO albums (name) VALUES ('RF') -- s1", "SELECT * FROM albums WHERE (id = 1) LIMIT 1 -- s1"]
-    
-    @Album.new_using_server(:s2){|o| o.name = 'MO'}.save
-    @db.sqls.must_equal ["INSERT INTO albums (name) VALUES ('MO') -- s2", "SELECT * FROM albums WHERE (id = 1) LIMIT 1 -- s2"]
-  end 
-
-  it "should allow you to create and save a new object for a specified shard" do
-    @Album.create_using_server(:s1, :name=>'RF')
-    @db.sqls.must_equal ["INSERT INTO albums (name) VALUES ('RF') -- s1", "SELECT * FROM albums WHERE (id = 1) LIMIT 1 -- s1"]
-
-    @Album.create_using_server(:s2){|o| o.name = 'MO'}
-    @db.sqls.must_equal ["INSERT INTO albums (name) VALUES ('MO') -- s2", "SELECT * FROM albums WHERE (id = 1) LIMIT 1 -- s2"]
-  end 
-
-  it "should have objects retrieved from a specific shard update that shard" do
-    @Album.server(:s1).first.update(:name=>'MO')
-    @db.sqls.must_equal ["SELECT * FROM albums LIMIT 1 -- s1", "UPDATE albums SET name = 'MO' WHERE (id = 1) -- s1"]
-  end 
-
-  it "should have objects retrieved from a specific shard delete from that shard" do
-    @Album.server(:s1).first.delete
-    @db.sqls.must_equal ["SELECT * FROM albums LIMIT 1 -- s1", "DELETE FROM albums WHERE (id = 1) -- s1"]
-  end 
-
-  it "should have objects retrieved from a specific shard reload from that shard" do
-    @Album.server(:s1).first.reload
-    @db.sqls.must_equal ["SELECT * FROM albums LIMIT 1 -- s1", "SELECT * FROM albums WHERE (id = 1) LIMIT 1 -- s1"]
-  end 
-
-  it "should use current dataset's shard when eager loading if eagerly loaded dataset doesn't have its own shard" do
-    albums = @Album.server(:s1).eager(:artist).all
-    @db.sqls.must_equal ["SELECT * FROM albums -- s1", "SELECT * FROM artists WHERE (artists.id IN (2)) -- s1"]
-    albums.length.must_equal 1
-    albums.first.artist.save
-    @db.sqls.must_equal ["UPDATE artists SET name = 'YJM' WHERE (id = 2) -- s1"]
-  end 
-
-  it "should not use current dataset's shard when eager loading if eagerly loaded dataset has its own shard" do
-    @Artist.instance_dataset.opts[:server] = @Artist.dataset.opts[:server] = :s2
-    albums = @Album.server(:s1).eager(:artist).all
-    @db.sqls.must_equal ["SELECT * FROM albums -- s1", "SELECT * FROM artists WHERE (artists.id IN (2)) -- s2"]
-    albums.length.must_equal 1
-    albums.first.artist.save
-    @db.sqls.must_equal ["UPDATE artists SET name = 'YJM' WHERE (id = 2) -- s2"]
-  end 
-
-  it "should use current dataset's shard when eager graphing if eagerly graphed dataset doesn't have its own shard" do
-    ds = @Album.server(:s1).eager_graph(:artist)
-    ds._fetch = {:id=>1, :artist_id=>2, :name=>'RF', :artist_id_0=>2, :artist_name=>'YJM'}
-    albums = ds.all
-    @db.sqls.must_equal ["SELECT albums.id, albums.artist_id, albums.name, artist.id AS artist_id_0, artist.name AS artist_name FROM albums LEFT OUTER JOIN artists AS artist ON (artist.id = albums.artist_id) -- s1"]
-    albums.length.must_equal 1
-    albums.first.artist.save
-    @db.sqls.must_equal ["UPDATE artists SET name = 'YJM' WHERE (id = 2) -- s1"]
-  end 
-
-  it "should not use current dataset's shard when eager graphing if eagerly graphed dataset has its own shard" do
-    @Artist.instance_dataset.opts[:server] = @Artist.dataset.opts[:server] = :s2
-    ds = @Album.server(:s1).eager_graph(:artist)
-    ds._fetch = {:id=>1, :artist_id=>2, :name=>'RF', :artist_id_0=>2, :artist_name=>'YJM'}
-    albums = ds.all
-    @db.sqls.must_equal ["SELECT albums.id, albums.artist_id, albums.name, artist.id AS artist_id_0, artist.name AS artist_name FROM albums LEFT OUTER JOIN artists AS artist ON (artist.id = albums.artist_id) -- s1"]
-    albums.length.must_equal 1
-    albums.first.artist.save
-    @db.sqls.must_equal ["UPDATE artists SET name = 'YJM' WHERE (id = 2) -- s2"]
-  end 
-
-  it "should use eagerly graphed dataset shard for eagerly graphed objects even if current dataset does not have a shard" do
-    @Artist.instance_dataset.opts[:server] = @Artist.dataset.opts[:server] = :s2
-    ds = @Album.eager_graph(:artist)
-    ds._fetch = {:id=>1, :artist_id=>2, :name=>'RF', :artist_id_0=>2, :artist_name=>'YJM'}
-    albums = ds.all
-    @db.sqls.must_equal ["SELECT albums.id, albums.artist_id, albums.name, artist.id AS artist_id_0, artist.name AS artist_name FROM albums LEFT OUTER JOIN artists AS artist ON (artist.id = albums.artist_id)"]
-    albums.length.must_equal 1
-    albums.first.artist.save
-    @db.sqls.must_equal ["UPDATE artists SET name = 'YJM' WHERE (id = 2) -- s2"]
-  end 
-
-  it "should have objects retrieved from a specific shard use associated objects from that shard, with modifications to the associated objects using that shard" do
-    album = @Album.server(:s1).first
-    @db.sqls.must_equal ["SELECT * FROM albums LIMIT 1 -- s1"]
-    album.artist.update(:name=>'AS')
-    @db.sqls.must_equal ["SELECT * FROM artists WHERE (artists.id = 2) LIMIT 1 -- s1", "UPDATE artists SET name = 'AS' WHERE (id = 2) -- s1"]
-    album.tags.map{|a| a.update(:name=>'SR')}
-    @db.sqls.must_equal ["SELECT tags.* FROM tags INNER JOIN albums_tags ON (albums_tags.tag_id = tags.id) WHERE (albums_tags.album_id = 1) -- s1", "UPDATE tags SET name = 'SR' WHERE (id = 3) -- s1"]
-    @Artist.server(:s2).first.albums.map{|a| a.update(:name=>'MO')}
-    @db.sqls.must_equal ["SELECT * FROM artists LIMIT 1 -- s2", "SELECT * FROM albums WHERE (albums.artist_id = 2) -- s2", "UPDATE albums SET name = 'MO' WHERE (id = 1) -- s2"]
-  end 
-
-  it "should have objects retrieved from a specific shard add associated objects to that shard" do
-    album = @Album.server(:s1).first
-    artist = @Artist.server(:s2).first
-    @db.sqls.must_equal ["SELECT * FROM albums LIMIT 1 -- s1", "SELECT * FROM artists LIMIT 1 -- s2"]
-
-    artist.add_album(:name=>'MO')
-    sqls = @db.sqls
-    ["INSERT INTO albums (artist_id, name) VALUES (2, 'MO') -- s2", "INSERT INTO albums (name, artist_id) VALUES ('MO', 2) -- s2"].must_include(sqls.shift)
-    sqls.must_equal ["SELECT * FROM albums WHERE (id = 1) LIMIT 1 -- s2"]
-    
-    album.add_tag(:name=>'SR')
-    sqls = @db.sqls
-    ["INSERT INTO albums_tags (album_id, tag_id) VALUES (1, 3) -- s1", "INSERT INTO albums_tags (tag_id, album_id) VALUES (3, 1) -- s1"].must_include(sqls.pop)
-    sqls.must_equal ["INSERT INTO tags (name) VALUES ('SR') -- s1", "SELECT * FROM tags WHERE (id = 1) LIMIT 1 -- s1", ]
-  end 
-
-  it "should have objects retrieved from a specific shard remove associated objects from that shard" do
-    album = @Album.server(:s1).first
-    artist = @Artist.server(:s2).first
-    @db.sqls.must_equal ["SELECT * FROM albums LIMIT 1 -- s1", "SELECT * FROM artists LIMIT 1 -- s2"]
-
-    artist.remove_album(1)
-    sqls = @db.sqls
-    ["UPDATE albums SET artist_id = NULL, name = 'RF' WHERE (id = 1) -- s2", "UPDATE albums SET name = 'RF', artist_id = NULL WHERE (id = 1) -- s2"].must_include(sqls.pop)
-    sqls.must_equal ["SELECT * FROM albums WHERE ((albums.artist_id = 2) AND (albums.id = 1)) LIMIT 1 -- s2"]
-    
-    album.remove_tag(3)
-    @db.sqls.must_equal ["SELECT tags.* FROM tags INNER JOIN albums_tags ON (albums_tags.tag_id = tags.id) WHERE ((albums_tags.album_id = 1) AND (tags.id = 3)) LIMIT 1 -- s1", "DELETE FROM albums_tags WHERE ((album_id = 1) AND (tag_id = 3)) -- s1"]
-  end 
-
-  it "should have objects retrieved from a specific shard remove all associated objects from that shard" do
-    album = @Album.server(:s1).first
-    artist = @Artist.server(:s2).first
-    @db.sqls.must_equal ["SELECT * FROM albums LIMIT 1 -- s1", "SELECT * FROM artists LIMIT 1 -- s2"]
-
-    artist.remove_all_albums
-    @db.sqls.must_equal ["UPDATE albums SET artist_id = NULL WHERE (artist_id = 2) -- s2"]
-    
-    album.remove_all_tags
-    @db.sqls.must_equal ["DELETE FROM albums_tags WHERE (album_id = 1) -- s1"]
-  end 
-
-  it "should not override a server already set on an associated object" do
-    @Album.server(:s1).first
-    artist = @Artist.server(:s2).first
-    @db.sqls.must_equal ["SELECT * FROM albums LIMIT 1 -- s1", "SELECT * FROM artists LIMIT 1 -- s2"]
-
-    artist.add_album(@Album.load(:id=>4, :name=>'MO').set_server(:s3))
-    ["UPDATE albums SET artist_id = 2, name = 'MO' WHERE (id = 4) -- s3", "UPDATE albums SET name = 'MO', artist_id = 2 WHERE (id = 4) -- s3"].must_include(@db.sqls.pop)
-
-    artist.remove_album(@Album.load(:id=>5, :name=>'T', :artist_id=>2).set_server(:s4))
-    # Should select from current object's shard to check existing association, but update associated object's shard
-    sqls = @db.sqls
-    ["UPDATE albums SET artist_id = NULL, name = 'T' WHERE (id = 5) -- s4", "UPDATE albums SET name = 'T', artist_id = NULL WHERE (id = 5) -- s4"].must_include(sqls.pop)
-    sqls.must_equal ["SELECT 1 AS one FROM albums WHERE ((albums.artist_id = 2) AND (id = 5)) LIMIT 1 -- s2"]
-  end 
-
-  it "should be able to set a shard to use for any object using set_server" do
-    @Album.server(:s1).first.set_server(:s2).reload
-    @db.sqls.must_equal ["SELECT * FROM albums LIMIT 1 -- s1", "SELECT * FROM albums WHERE (id = 1) LIMIT 1 -- s2"]
-  end 
-
-  it "should use transactions on the correct shard" do
-    @Album.use_transactions = true
-    @Album.server(:s2).first.save
-    sqls = @db.sqls
-    ["UPDATE albums SET artist_id = 2, name = 'RF' WHERE (id = 1) -- s2", "UPDATE albums SET name = 'RF', artist_id = 2 WHERE (id = 1) -- s2"].must_include(sqls.slice!(2))
-    sqls.must_equal ["SELECT * FROM albums LIMIT 1 -- s2", "BEGIN -- s2", "COMMIT -- s2"]
-  end 
-
-  it "should use override current shard when saving with given :server option" do
-    @Album.use_transactions = true
-    @Album.server(:s2).first.save(:server=>:s1)
-    sqls = @db.sqls
-    ["UPDATE albums SET artist_id = 2, name = 'RF' WHERE (id = 1) -- s1", "UPDATE albums SET name = 'RF', artist_id = 2 WHERE (id = 1) -- s1"].must_include(sqls.slice!(2))
-    sqls.must_equal ["SELECT * FROM albums LIMIT 1 -- s2", "BEGIN -- s1", "COMMIT -- s1"]
-  end 
-end

data/spec/extensions/shared_caching_spec.rb

@@ -1,175 +0,0 @@
-require File.join(File.dirname(File.expand_path(__FILE__)), "spec_helper")
-
-describe "Shared caching behavior" do
-  before do
-    @db = Sequel.mock
-
-    class ::LookupModel < ::Sequel::Model(@db)
-      columns :id, :caching_model_id, :caching_model_id2
-      many_to_one :caching_model
-      many_to_one :caching_model2, :key=>[:caching_model_id, :caching_model_id2], :class=>:CachingModel
-    end
-    @c = LookupModel
-
-    class ::CachingModel < Sequel::Model(@db)
-      columns :id, :id2
-    end
-    @cc = CachingModel
-  end
-  after do
-    Object.send(:remove_const, :CachingModel)
-    Object.send(:remove_const, :LookupModel)
-  end
-
-  many_to_one_cpk_specs = shared_description do
-    it "should use a simple primary key lookup when retrieving many_to_one associated records with a composite key" do
-      @db.sqls.must_equal []
-      @c.load(:id=>3, :caching_model_id=>1, :caching_model_id2=>2).caching_model2.must_be_same_as(@cm12)
-      @c.load(:id=>3, :caching_model_id=>2, :caching_model_id2=>1).caching_model2.must_be_same_as(@cm21)
-      @db.sqls.must_equal []
-      @db.fetch = []
-      @c.load(:id=>4, :caching_model_id=>2, :caching_model_id2=>2).caching_model2.must_equal nil
-    end
-  end
-
-  many_to_one_pk_specs = shared_description do
-    it "should use a simple primary key lookup when retrieving many_to_one associated records" do
-      @cc.set_primary_key([:id, :id2])
-      @db.sqls.must_equal []
-      @c.load(:id=>3, :caching_model_id=>1).caching_model.must_be_same_as(@cm1)
-      @c.load(:id=>4, :caching_model_id=>2).caching_model.must_be_same_as(@cm2)
-      @db.sqls.must_equal []
-      @db.fetch = []
-      @c.load(:id=>4, :caching_model_id=>3).caching_model.must_equal nil
-    end
-
-    it "should not use a simple primary key lookup if the assocation has a nil :key option" do
-      @c.many_to_one :caching_model, :key=>nil, :dataset=>proc{CachingModel.filter(:caching_model_id=>caching_model_id)}
-      @c.load(:id=>3, :caching_model_id=>1).caching_model
-      @db.sqls.wont_equal []
-    end
-
-    it "should not use a simple primary key lookup if the assocation has a nil :key option" do
-      @c.many_to_one :caching_model, :many_to_one_pk_lookup=>false
-      @c.load(:id=>3, :caching_model_id=>1).caching_model
-      @db.sqls.wont_equal []
-    end
-
-    it "should not use a simple primary key lookup if the assocation's :primary_key option doesn't match the primary key of the associated class" do
-      @c.many_to_one :caching_model, :primary_key=>:id2
-      @c.load(:id=>3, :caching_model_id=>1).caching_model
-      @db.sqls.wont_equal []
-    end
-
-    it "should not use a simple primary key lookup if the assocation has :conditions" do
-      @c.many_to_one :caching_model, :conditions=>{:a=>1}
-      @c.load(:id=>3, :caching_model_id=>1).caching_model
-      @db.sqls.wont_equal []
-    end
-
-    it "should not use a simple primary key lookup if the assocation has :select" do
-      @c.many_to_one :caching_model, :select=>[:a, :b]
-      @c.load(:id=>3, :caching_model_id=>1).caching_model
-      @db.sqls.wont_equal []
-    end
-
-    it "should not use a simple primary key lookup if the assocation has a block" do
-      @c.many_to_one(:caching_model){|ds| ds.where{a > 1}}
-      @c.load(:id=>3, :caching_model_id=>1).caching_model
-      @db.sqls.wont_equal []
-    end
-
-    it "should not use a simple primary key lookup if the assocation has a non-default :dataset option" do
-      cc = @cc
-      @c.many_to_one :caching_model, :dataset=>proc{cc.where(:id=>caching_model_id)}
-      @c.load(:id=>3, :caching_model_id=>1).caching_model
-      @db.sqls.wont_equal []
-    end
-
-    it "should use a simple primary key lookup if explicitly set" do
-      @c.many_to_one :caching_model, :select=>[:a, :b], :many_to_one_pk_lookup=>true
-      @c.load(:id=>3, :caching_model_id=>1).caching_model
-      @db.sqls.must_equal []
-    end
-
-    it "should not use a simple primary key lookup if the prepared_statements_associations method is being used" do
-      c2 = Class.new(Sequel::Model(@db[:not_caching_model]))
-      c2.dataset._fetch = {:id=>1}
-      c = Class.new(Sequel::Model(@db[:lookup_model]))
-      c.class_eval do
-        plugin :prepared_statements_associations
-        columns :id, :caching_model_id
-        many_to_one :caching_model, :class=>c2
-      end
-      c.load(:id=>3, :caching_model_id=>1).caching_model.must_equal c2.load(:id=>1)
-      @db.sqls.wont_equal []
-    end
-
-    it "should use a simple primary key lookup if the prepared_statements_associations method is being used but associated model also uses caching" do
-      c = Class.new(Sequel::Model(:lookup_model))
-      c.class_eval do
-        plugin :prepared_statements_associations
-        columns :id, :caching_model_id
-        many_to_one :caching_model
-      end
-      c.load(:id=>3, :caching_model_id=>1).caching_model.must_be_same_as(@cm1)
-      @db.sqls.must_equal []
-    end
-  end
-
-  describe "With caching plugin" do
-    before do
-      @cache_class = Class.new(Hash) do
-        attr_accessor :ttl
-        def set(k, v, ttl); self[k] = v; @ttl = ttl; end
-        def get(k); self[k]; end
-      end
-      cache = @cache_class.new
-      @cache = cache
-      
-      @cc.plugin :caching, @cache
-      @db.fetch = {:id=>1}
-      @cm1 = @cc[1]
-      @cm2 = @cc[2]
-      @cm12 = @cc[1, 2]
-      @cm21 = @cc[2, 1]
-
-      @db.sqls
-    end
-
-    include many_to_one_cpk_specs
-    include many_to_one_pk_specs
-  end
-
-  describe "With static_cache plugin with single key" do
-    before do
-      @db.fetch = [{:id=>1}, {:id=>2}]
-      @cc.plugin :static_cache
-      @cm1 = @cc[1]
-      @cm2 = @cc[2]
-      @db.sqls
-    end
-
-    include many_to_one_pk_specs
-
-    it "should not issue regular query if primary key lookup returns no rows" do
-      def @cc.primary_key_lookup(pk); end
-      @c.many_to_one :caching_model
-      @c.load(:id=>3, :caching_model_id=>1).caching_model
-      @db.sqls.must_equal []
-    end
-  end
-
-  describe "With static_cache plugin with composite key" do
-    before do
-      @cc.set_primary_key([:id, :id2])
-      @db.fetch = [{:id=>1, :id2=>2}, {:id=>2, :id2=>1}]
-      @cc.plugin :static_cache
-      @cm12 = @cc[[1, 2]]
-      @cm21 = @cc[[2, 1]]
-      @db.sqls
-    end
-
-    include many_to_one_cpk_specs
-  end
-end

data/spec/extensions/single_table_inheritance_spec.rb

@@ -1,297 +0,0 @@
-require File.join(File.dirname(File.expand_path(__FILE__)), "spec_helper")
-
-describe Sequel::Model, "single table inheritance plugin" do
-  before do
-    class ::StiTest < Sequel::Model
-      columns :id, :kind, :blah
-      plugin :single_table_inheritance, :kind
-    end 
-    class ::StiTestSub1 < StiTest
-    end 
-    class ::StiTestSub2 < StiTest
-    end 
-    @ds = StiTest.dataset
-    DB.reset
-  end
-  after do
-    Object.send(:remove_const, :StiTestSub1)
-    Object.send(:remove_const, :StiTestSub2)
-    Object.send(:remove_const, :StiTest)
-  end
-
-  it "should have simple_table = nil" do
-    StiTest.simple_table.must_equal "sti_tests"
-    StiTestSub1.simple_table.must_equal nil
-  end
-  
-  it "should allow changing the inheritance column via a plugin :single_table_inheritance call" 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 
-    @ds._fetch = [{:blah=>'StiTest'}, {:blah=>'StiTestSub1'}, {:blah=>'StiTestSub2'}]
-    StiTest.all.collect{|x| x.class}.must_equal [StiTest, StiTestSub1, StiTestSub2]
-    StiTest.dataset.sql.must_equal "SELECT * FROM sti_tests"
-    StiTestSub1.dataset.sql.must_equal "SELECT * FROM sti_tests WHERE (sti_tests.blah IN ('StiTestSub1'))"
-    StiTestSub2.dataset.sql.must_equal "SELECT * FROM sti_tests WHERE (sti_tests.blah IN ('StiTestSub2'))"
-  end 
-  
-  it "should return rows with the correct class based on the polymorphic_key value" do
-    @ds._fetch = [{:kind=>'StiTest'}, {:kind=>'StiTestSub1'}, {:kind=>'StiTestSub2'}]
-    StiTest.all.collect{|x| x.class}.must_equal [StiTest, StiTestSub1, StiTestSub2]
-  end 
-
-  it "should return rows with the correct class based on the polymorphic_key value when retreiving by primary key" do
-    @ds._fetch = [{:kind=>'StiTestSub1'}]
-    StiTest[1].class.must_equal StiTestSub1
-  end 
-
-  it "should return rows with the correct class for subclasses based on the polymorphic_key value" do
-    class ::StiTestSub1Sub < StiTestSub1; end 
-    StiTestSub1.dataset._fetch = [{:kind=>'StiTestSub1'}, {:kind=>'StiTestSub1Sub'}]
-    StiTestSub1.all.collect{|x| x.class}.must_equal [StiTestSub1, StiTestSub1Sub]
-  end 
-
-  it "should fallback to the main class if the given class does not exist" do
-    @ds._fetch = {:kind=>'StiTestSub3'}
-    StiTest.all.collect{|x| x.class}.must_equal [StiTest]
-  end
-
-  it "should fallback to the main class if the sti_key field is empty or nil without calling constantize" do
-    called = false
-    StiTest.meta_def(:constantize) do |s|
-      called = true
-      Object
-    end
-    StiTest.plugin :single_table_inheritance, :kind
-    @ds._fetch = [{:kind=>''}, {:kind=>nil}]
-    StiTest.all.collect{|x| x.class}.must_equal [StiTest, StiTest]
-    called.must_equal false
-  end
-
-  it "should set the model class name when saving" do
-    StiTest.new.save
-    StiTestSub1.new.save
-    StiTestSub2.new.save
-    DB.sqls.must_equal ["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 destroy the model correctly" do
-    StiTest.load(:id=>1).destroy
-    StiTestSub1.load(:id=>1).destroy
-    StiTestSub2.load(:id=>1).destroy
-    DB.sqls.must_equal ["DELETE FROM sti_tests WHERE id = 1", "DELETE FROM sti_tests WHERE ((sti_tests.kind IN ('StiTestSub1')) AND (id = 1))", "DELETE FROM sti_tests WHERE ((sti_tests.kind IN ('StiTestSub2')) AND (id = 1))"]
-  end
-
-  it "should handle validations on the type column field" do
-    o = StiTestSub1.new
-    def o.validate
-      errors.add(:kind, 'not present') unless kind
-    end
-    o.valid?.must_equal true
-  end
-
-  it "should set type column field even if validations are skipped" do
-    StiTestSub1.new.save(:validate=>false)
-    DB.sqls.must_equal ["INSERT INTO sti_tests (kind) VALUES ('StiTestSub1')", "SELECT * FROM sti_tests WHERE ((sti_tests.kind IN ('StiTestSub1')) AND (id = 10)) LIMIT 1"]
-  end
-
-  it "should override an existing value in the class name field" do
-    StiTest.create(:kind=>'StiTestSub1')
-    DB.sqls.must_equal ["INSERT INTO sti_tests (kind) VALUES ('StiTestSub1')", "SELECT * FROM sti_tests WHERE (id = 10) LIMIT 1"]
-  end
-
-  it "should handle type column with the same name as existing method names" do
-    StiTest.plugin :single_table_inheritance, :type
-    StiTest.columns :id, :type
-    StiTest.create
-    DB.sqls.must_equal ["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
-    StiTest.dataset.sql.must_equal "SELECT * FROM sti_tests"
-    StiTestSub1.dataset.sql.must_equal "SELECT * FROM sti_tests WHERE (sti_tests.kind IN ('StiTestSub1'))"
-    StiTestSub2.dataset.sql.must_equal "SELECT * FROM sti_tests WHERE (sti_tests.kind IN ('StiTestSub2'))"
-  end
-
-  it "should add a correct filter for multiple levels of subclasses" do
-    class ::StiTestSub1A < StiTestSub1; end
-    StiTestSub1.dataset.sql.must_equal "SELECT * FROM sti_tests WHERE (sti_tests.kind IN ('StiTestSub1', 'StiTestSub1A'))"
-    StiTestSub1A.dataset.sql.must_equal "SELECT * FROM sti_tests WHERE (sti_tests.kind IN ('StiTestSub1A'))"
-    class ::StiTestSub2A < StiTestSub2; end
-    StiTestSub2.dataset.sql.must_equal "SELECT * FROM sti_tests WHERE (sti_tests.kind IN ('StiTestSub2', 'StiTestSub2A'))"
-    StiTestSub2A.dataset.sql.must_equal "SELECT * FROM sti_tests WHERE (sti_tests.kind IN ('StiTestSub2A'))"
-    class ::StiTestSub1B < StiTestSub1A; end
-    StiTestSub1.dataset.sql.must_equal "SELECT * FROM sti_tests WHERE (sti_tests.kind IN ('StiTestSub1', 'StiTestSub1A', 'StiTestSub1B'))"
-    StiTestSub1A.dataset.sql.must_equal "SELECT * FROM sti_tests WHERE (sti_tests.kind IN ('StiTestSub1A', 'StiTestSub1B'))"
-    StiTestSub1B.dataset.sql.must_equal "SELECT * FROM sti_tests WHERE (sti_tests.kind IN ('StiTestSub1B'))"
-  end
-  
-  it "should work correctly with the :caching plugin" do
-    cache_class = Class.new(Hash) do
-      attr_accessor :ttl
-      def set(k, v, ttl); self[k] = v; @ttl = ttl; end
-      def get(k); self[k]; end
-    end
-    cache = cache_class.new
-
-    StiTest.plugin :caching, cache
-    def StiTest.cache_key_prefix; "stitest" end
-    c2 = Class.new StiTest
-    c2.cache_key(:id).must_equal StiTest.cache_key(:id)
-
-    obj2 = c2.new
-    obj2.values[:x] = 2
-    obj2.save
-    c2[obj2.id]
-    c2.cache_get_pk(obj2.id).values.must_equal StiTest.cache_get_pk(obj2.id).values
-    obj2.save
-    c2.cache_get_pk(obj2.id).must_equal nil
-    StiTest.cache_get_pk(obj2.id).must_equal nil
-  end
-
-  describe "with custom options" do
-    before do
-      class ::StiTest2 < Sequel::Model
-        columns :id, :kind
-        def _save_refresh; end
-      end
-    end
-    after do
-      Object.send(:remove_const, :StiTest2)
-      Object.send(:remove_const, :StiTest3)
-      Object.send(:remove_const, :StiTest4)
-    end
-
-    it "should have working row_proc if using set_dataset in subclass to remove columns" do
-      StiTest2.plugin :single_table_inheritance, :kind
-      class ::StiTest3 < ::StiTest2
-        set_dataset(dataset.select(*(columns - [:blah])))
-      end
-      class ::StiTest4 < ::StiTest3; end
-      StiTest3.dataset._fetch = {:id=>1, :kind=>'StiTest4'}
-      StiTest3[1].must_equal StiTest4.load(:id=>1, :kind=>'StiTest4')
-    end
-
-    it "should work with custom procs with strings" do
-      StiTest2.plugin :single_table_inheritance, :kind, :model_map=>proc{|v| v == 1 ? 'StiTest3' : 'StiTest4'}, :key_map=>proc{|klass| klass.name == 'StiTest3' ? 1 : 2}
-      class ::StiTest3 < ::StiTest2; end
-      class ::StiTest4 < ::StiTest2; end
-      StiTest2.dataset.row_proc.call(:kind=>0).must_be_instance_of(StiTest4)
-      StiTest2.dataset.row_proc.call(:kind=>1).must_be_instance_of(StiTest3)
-      StiTest2.dataset.row_proc.call(:kind=>2).must_be_instance_of(StiTest4)
-
-      StiTest2.create.kind.must_equal 2
-      StiTest3.create.kind.must_equal 1
-      StiTest4.create.kind.must_equal 2
-    end
-
-    it "should work with custom procs with symbols" do
-      StiTest2.plugin :single_table_inheritance, :kind, :model_map=>proc{|v| v == 1 ? :StiTest3 : :StiTest4}, :key_map=>proc{|klass| klass.name == 'StiTest3' ? 1 : 2}
-      class ::StiTest3 < ::StiTest2; end
-      class ::StiTest4 < ::StiTest2; end
-      StiTest2.dataset.row_proc.call(:kind=>0).must_be_instance_of(StiTest4)
-      StiTest2.dataset.row_proc.call(:kind=>1).must_be_instance_of(StiTest3)
-      StiTest2.dataset.row_proc.call(:kind=>2).must_be_instance_of(StiTest4)
-
-      StiTest2.create.kind.must_equal 2
-      StiTest3.create.kind.must_equal 1
-      StiTest4.create.kind.must_equal 2
-    end
-
-    it "should work with custom hashes" do
-      StiTest2.plugin :single_table_inheritance, :kind, :model_map=>{0=>StiTest2, 1=>:StiTest3, 2=>'StiTest4'}, :key_map=>{StiTest2=>4, 'StiTest3'=>5, 'StiTest4'=>6}
-      class ::StiTest3 < ::StiTest2; end
-      class ::StiTest4 < ::StiTest2; end
-      StiTest2.dataset.row_proc.call(:kind=>0).must_be_instance_of(StiTest2)
-      StiTest2.dataset.row_proc.call(:kind=>1).must_be_instance_of(StiTest3)
-      StiTest2.dataset.row_proc.call(:kind=>2).must_be_instance_of(StiTest4)
-      StiTest3.sti_model_map.must_equal StiTest2.sti_model_map
-
-      StiTest2.create.kind.must_equal 4
-      StiTest3.create.kind.must_equal 5
-      StiTest4.create.kind.must_equal 6
-
-      class ::StiTest5 < ::StiTest4; end
-      StiTest5.create.kind.must_equal nil
-    end
-
-    it "should infer key_map from model_map if provided as a hash" do
-      StiTest2.plugin :single_table_inheritance, :kind, :model_map=>{0=>StiTest2, 1=>'StiTest3', 2=>:StiTest4}
-      class ::StiTest3 < ::StiTest2; end
-      class ::StiTest4 < ::StiTest2; end
-      StiTest2.dataset.row_proc.call(:kind=>0).must_be_instance_of(StiTest2)
-      StiTest2.dataset.row_proc.call(:kind=>1).must_be_instance_of(StiTest3)
-      StiTest2.dataset.row_proc.call(:kind=>2).must_be_instance_of(StiTest4)
-
-      StiTest2.create.kind.must_equal 0
-      StiTest3.create.kind.must_equal 1
-      StiTest4.create.kind.must_equal 2
-    end
-
-    it "should raise exceptions if a bad model value is used" do
-      StiTest2.plugin :single_table_inheritance, :kind, :model_map=>{0=>1,1=>1.5, 2=>Date.today}
-      class ::StiTest3 < ::StiTest2; end
-      class ::StiTest4 < ::StiTest2; end
-      proc{StiTest2.dataset.row_proc.call(:kind=>0)}.must_raise(Sequel::Error)
-      proc{StiTest2.dataset.row_proc.call(:kind=>1)}.must_raise(Sequel::Error)
-      proc{StiTest2.dataset.row_proc.call(:kind=>2)}.must_raise(Sequel::Error)
-    end
-
-    it "should work with non-bijective mappings" do
-      StiTest2.plugin :single_table_inheritance, :kind, :model_map=>{0=>'StiTest3', 1=>'StiTest3', 2=>'StiTest4'}
-      class ::StiTest3 < ::StiTest2; end
-      class ::StiTest4 < ::StiTest2; end
-      StiTest2.dataset.row_proc.call(:kind=>0).must_be_instance_of(StiTest3)
-      StiTest2.dataset.row_proc.call(:kind=>1).must_be_instance_of(StiTest3)
-      StiTest2.dataset.row_proc.call(:kind=>2).must_be_instance_of(StiTest4)
-
-      [0,1].must_include(StiTest3.create.kind)
-      StiTest4.create.kind.must_equal 2
-    end
-
-    it "should work with non-bijective mappings and key map procs" do
-      StiTest2.plugin :single_table_inheritance, :kind,
-        :key_map=>proc{|model| model.to_s == 'StiTest4' ? 2 : [0,1] }
-      class ::StiTest3 < ::StiTest2; end
-      class ::StiTest4 < ::StiTest2; end
-
-      StiTest2.dataset.sql.must_equal "SELECT * FROM sti_test2s"
-      StiTest3.dataset.sql.must_equal "SELECT * FROM sti_test2s WHERE (sti_test2s.kind IN (0, 1))"
-      StiTest4.dataset.sql.must_equal "SELECT * FROM sti_test2s WHERE (sti_test2s.kind IN (2))"
-    end
-
-    it "should create correct sql with non-bijective mappings" do
-      StiTest2.plugin :single_table_inheritance, :kind, :model_map=>{0=>'StiTest3', 1=>'StiTest3', 2=>'StiTest4'}
-      class ::StiTest3 < ::StiTest2; end
-      class ::StiTest4 < ::StiTest2; end
-    
-      StiTest2.dataset.sql.must_equal "SELECT * FROM sti_test2s"
-      ["SELECT * FROM sti_test2s WHERE (sti_test2s.kind IN (0, 1))",
-       "SELECT * FROM sti_test2s WHERE (sti_test2s.kind IN (1, 0))"].must_include(StiTest3.dataset.sql)
-    end
-
-    it "should destroy the model correctly" do
-      StiTest2.plugin :single_table_inheritance, :kind, :model_map=>{'sti3'=>'StiTest3', 'sti3b'=>'StiTest3', 'sti4'=>'StiTest4'}
-      class ::StiTest3 < ::StiTest2; end
-      class ::StiTest4 < ::StiTest2; end
-      StiTest2.load(:id=>1).destroy
-      StiTest3.load(:id=>1).destroy
-      sqls = DB.sqls
-      sqls.shift.must_equal "DELETE FROM sti_test2s WHERE id = 1"
-      ["DELETE FROM sti_test2s WHERE ((sti_test2s.kind IN ('sti3', 'sti3b')) AND (id = 1))",
-       "DELETE FROM sti_test2s WHERE ((sti_test2s.kind IN ('sti3b', 'sti3')) AND (id = 1))"].must_include(sqls.pop)
-      sqls.must_equal []
-    end
-
-    it "should honor a :key_chooser" do
-      StiTest2.plugin :single_table_inheritance, :kind, :key_chooser => proc{|inst| inst.model.to_s.downcase }
-      class ::StiTest3 < ::StiTest2; end
-      class ::StiTest4 < ::StiTest2; end
-
-      StiTest3.create.kind.must_equal 'stitest3'
-      StiTest4.create.kind.must_equal 'stitest4'
-    end
-  end
-end