sequel 5.29.0 → 5.30.0

data/spec/extensions/server_block_spec.rb

@@ -1,135 +0,0 @@
-require_relative "spec_helper"
-
-with_server_specs = shared_description do
-  it "should set the default server to use in the block" do
-    @db.with_server(:a){@db[:t].all}
-    @db.sqls.must_equal ["SELECT * FROM t -- a"]
-    @db.with_server(:b){@db[:t].all}
-    @db.sqls.must_equal ["SELECT * FROM t -- b"]
-  end
-
-  it "should set the default server to use in the block" do
-    @db.with_server(:a, :b){@db[:t].all}
-    @db.sqls.must_equal ["SELECT * FROM t -- b"]
-    @db.with_server(:a, :b){@db[:t].insert}
-    @db.sqls.must_equal ["INSERT INTO t DEFAULT VALUES -- a"]
-  end
-
-  it "should have no affect after the block" do
-    @db.with_server(:a){@db[:t].all}
-    @db.sqls.must_equal ["SELECT * FROM t -- a"]
-    @db[:t].all
-    @db.sqls.must_equal ["SELECT * FROM t"]
-  end
-
-  it "should not override specific server inside the block" do
-    @db.with_server(:a){@db[:t].server(:b).all}
-    @db.sqls.must_equal ["SELECT * FROM t -- b"]
-  end
-
-  it "should work correctly when blocks are nested" do
-    @db[:t].all
-    @db.with_server(:a) do
-      @db[:t].all
-      @db.with_server(:b){@db[:t].all}
-      @db[:t].all
-    end
-    @db[:t].all
-    @db.sqls.must_equal ["SELECT * FROM t", "SELECT * FROM t -- a", "SELECT * FROM t -- b", "SELECT * FROM t -- a", "SELECT * FROM t"]
-  end
-
-  it "should work correctly for inserts/updates/deletes" do
-    @db.with_server(:a) do
-      @db[:t].insert
-      @db[:t].update(:a=>1)
-      @db[:t].delete
-    end
-    @db.sqls.must_equal ["INSERT INTO t DEFAULT VALUES -- a", "UPDATE t SET a = 1 -- a", "DELETE FROM t -- a"]
-  end
-end
-
-describe "Database#with_server single threaded" do
-  before do
-    @db = Sequel.mock(:single_threaded=>true, :servers=>{:a=>{}, :b=>{}})
-    @db.extension :server_block
-  end
-
-  include with_server_specs
-end
-
-describe "Database#with_server multi threaded" do
-  before do
-    @db = Sequel.mock(:servers=>{:a=>{}, :b=>{}, :c=>{}, :d=>{}})
-    @db.extension :server_block
-  end
-
-  include with_server_specs
-
-  it "should respect multithreaded access" do
-    q, q1 = Queue.new, Queue.new
-    
-    t = nil
-    @db[:t].all
-    @db.with_server(:a) do
-      @db[:t].all
-      t = Thread.new do
-        @db[:t].all
-        @db.with_server(:c) do
-          @db[:t].all
-          @db.with_server(:d){@db[:t].all}
-          q.push nil
-          q1.pop
-          @db[:t].all
-        end
-        @db[:t].all
-      end
-      q.pop
-      @db.with_server(:b){@db[:t].all}
-      @db[:t].all
-    end
-    @db[:t].all
-    q1.push nil
-    t.join
-    @db.sqls.must_equal ["SELECT * FROM t", "SELECT * FROM t -- a", "SELECT * FROM t", "SELECT * FROM t -- c", "SELECT * FROM t -- d",
-      "SELECT * FROM t -- b", "SELECT * FROM t -- a", "SELECT * FROM t", "SELECT * FROM t -- c", "SELECT * FROM t"]
-  end
-end
-
-describe "Database#with_server with invalid servers" do
-  def sqls(server)
-    @db.with_server(server) do
-      @db[:t].all
-      @db[:t].insert
-      @db[:t].update(:a=>1)
-      @db[:t].delete
-    end
-    @db.sqls
-  end
-
-  it "when single threaded and no servers_hash" do
-    @db = Sequel.mock(:single_threaded=>true, :servers=>{:a=>{}}).extension(:server_block)
-    sqls(:a).must_equal ["SELECT * FROM t -- a", "INSERT INTO t DEFAULT VALUES -- a", "UPDATE t SET a = 1 -- a", "DELETE FROM t -- a"]
-    sqls(:c).must_equal ["SELECT * FROM t", "INSERT INTO t DEFAULT VALUES", "UPDATE t SET a = 1", "DELETE FROM t"]
-  end
-
-  it "when multi-threaded and no servers_hash" do
-    @db = Sequel.mock(:servers=>{:a=>{}}).extension(:server_block)
-    sqls(:a).must_equal ["SELECT * FROM t -- a", "INSERT INTO t DEFAULT VALUES -- a", "UPDATE t SET a = 1 -- a", "DELETE FROM t -- a"]
-    sqls(:c).must_equal ["SELECT * FROM t", "INSERT INTO t DEFAULT VALUES", "UPDATE t SET a = 1", "DELETE FROM t"]
-  end
-
-  it "when single threaded and servers_hash" do
-    @db = Sequel.mock(:single_threaded=>true, :servers=>{:a=>{}, :b=>{}}, :servers_hash=>Hash.new{|_,k| raise}.merge!(:c=>:b)).extension(:server_block)
-    sqls(:a).must_equal ["SELECT * FROM t -- a", "INSERT INTO t DEFAULT VALUES -- a", "UPDATE t SET a = 1 -- a", "DELETE FROM t -- a"]
-    sqls(:c).must_equal ["SELECT * FROM t -- b", "INSERT INTO t DEFAULT VALUES -- b", "UPDATE t SET a = 1 -- b", "DELETE FROM t -- b"]
-    proc{sqls(:d)}.must_raise(RuntimeError)
-  end
-
-  it "when multi-threaded and servers_hash" do
-    @db = Sequel.mock(:servers=>{:a=>{}, :b=>{}}, :servers_hash=>Hash.new{|_,k| raise}.merge!(:c=>:b)).extension(:server_block)
-    sqls(:a).must_equal ["SELECT * FROM t -- a", "INSERT INTO t DEFAULT VALUES -- a", "UPDATE t SET a = 1 -- a", "DELETE FROM t -- a"]
-    sqls(:c).must_equal ["SELECT * FROM t -- b", "INSERT INTO t DEFAULT VALUES -- b", "UPDATE t SET a = 1 -- b", "DELETE FROM t -- b"]
-    proc{sqls(:d)}.must_raise(RuntimeError)
-  end
-end
-

data/spec/extensions/server_logging_spec.rb

@@ -1,45 +0,0 @@
-require_relative "spec_helper"
-
-describe "server_logging extension" do
-  before do
-    @o = Object.new
-    def @o.logs; @logs || []; end
-    def @o.log; logs.length.must_equal 1; logs.first.length.must_equal 1; logs.shift.first; end
-    def @o.to_ary; [self]; end
-    def @o.method_missing(m, *args); (@logs ||= []) << args; end
-    @db = Sequel::mock(:test=>false, :servers=>{:read_only=>{}, :b=>{}}, :logger=>@o).extension(:server_logging)
-  end
-
-  it "should include shard when logging" do
-    @db[:a].all
-    @o.log.must_include "server: read_only) SELECT * FROM a"
-    @db[:a].insert
-    @o.log.must_include "server: default) INSERT INTO a DEFAULT VALUES"
-    @db[:a].server(:b).all
-    @o.log.must_include "server: b) SELECT * FROM a"
-  end
-
-  it "should not include shard when not logging connection info" do
-    @db.log_connection_info = false
-    @db[:a].all
-    log = @o.log
-    log.wont_include "server: read_only) SELECT * FROM a"
-    log.must_include "SELECT * FROM a"
-  end
-
-  it "should not turn on logging connction info if it was turned off" do
-    @db.log_connection_info = false
-    @db.extension :server_logging
-    @db[:a].all
-    log = @o.log
-    log.wont_include "server: read_only) SELECT * FROM a"
-    log.must_include "SELECT * FROM a"
-  end
-
-  it "should remove mapping when disconnecting" do
-    c = @db.synchronize{|c1| c1}
-    @db.disconnect
-    @db.send(:log_connection_execute, c, "SELECT * FROM a")
-    @o.log.must_include "server: ) SELECT * FROM a"
-  end
-end

data/spec/extensions/sharding_spec.rb

@@ -1,197 +0,0 @@
-require_relative "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].with_fetch(:id=>2, :name=>'YJM')))
-    @Artist.class_eval do
-      columns :id, :name
-      plugin :sharding
-    end
-    @Album = Class.new(Sequel::Model(@db[:albums].with_fetch(:id=>1, :name=>'RF', :artist_id=>2)))
-    @Album.class_eval do
-      columns :id, :artist_id, :name
-      plugin :sharding
-    end
-    @Tag = Class.new(Sequel::Model(@db[:tags].with_fetch(:id=>3, :name=>'M')))
-    @Tag.class_eval do
-      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.dataset = @Artist.dataset.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
-    albums = @Album.server(:s1).eager_graph(:artist).with_fetch(:id=>1, :artist_id=>2, :name=>'RF', :artist_id_0=>2, :artist_name=>'YJM').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.dataset = @Artist.dataset.server(:s2)
-    albums = @Album.server(:s1).eager_graph(:artist).with_fetch(:id=>1, :artist_id=>2, :name=>'RF', :artist_id_0=>2, :artist_name=>'YJM').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.dataset = @Artist.dataset.server(:s2)
-    albums = @Album.eager_graph(:artist).with_fetch(:id=>1, :artist_id=>2, :name=>'RF', :artist_id_0=>2, :artist_name=>'YJM').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 
-
-  it "should have objects retrieved from a specific shard using with_server from server_block extension" do
-    album = @db.extension(:server_block).with_server(:s1) do
-      @Album.first
-    end
-    album.update(:name=>'MO')
-    @db.sqls.must_equal ["SELECT * FROM albums LIMIT 1 -- s1", "UPDATE albums SET name = 'MO' WHERE (id = 1) -- s1"]
-  end 
-end

data/spec/extensions/shared_caching_spec.rb

@@ -1,151 +0,0 @@
-require_relative "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_be_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_be_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
-  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