sequel_core 2.2.0 → 3.8.0

data/spec/adapters/sqlite_spec.rb

@@ -1,413 +0,0 @@
-require File.join(File.dirname(__FILE__), '../spec_helper.rb')
-
-unless defined?(SQLITE_DB)
-  SQLITE_DB = Sequel.connect('sqlite:/')
-end
-
-SQLITE_DB.create_table :items do
-  integer :id, :primary_key => true, :auto_increment => true
-  text :name
-  float :value
-end
-SQLITE_DB.create_table :test2 do
-  text :name
-  integer :value
-end
-SQLITE_DB.create_table(:time) {timestamp :t}
-
-context "An SQLite database" do
-  before do
-    @db = Sequel.connect('sqlite:/')
-  end
-  after do
-    @db.disconnect
-  end
-  
-  specify "should provide a list of existing tables" do
-    @db.tables.should == []
-    
-    @db.create_table :testing do
-      text :name
-    end
-    @db.tables.should include(:testing)
-  end
-  
-  specify "should support getting pragma values" do
-    @db.pragma_get(:auto_vacuum).should == '0'
-  end
-  
-  specify "should support setting pragma values" do
-    @db.pragma_set(:auto_vacuum, '1')
-    @db.pragma_get(:auto_vacuum).should == '1'
-    @db.pragma_set(:auto_vacuum, '2')
-    @db.pragma_get(:auto_vacuum).should == '2'
-  end
-  
-  specify "should support getting and setting the auto_vacuum pragma" do
-    @db.auto_vacuum = :full
-    @db.auto_vacuum.should == :full
-    @db.auto_vacuum = :incremental
-    @db.auto_vacuum.should == :incremental
-    
-    proc {@db.auto_vacuum = :invalid}.should raise_error(Sequel::Error)
-  end
-
-  specify "should support getting and setting the synchronous pragma" do
-    @db.synchronous = :off
-    @db.synchronous.should == :off
-    @db.synchronous = :normal
-    @db.synchronous.should == :normal
-    @db.synchronous = :full
-    @db.synchronous.should == :full
-    
-    proc {@db.synchronous = :invalid}.should raise_error(Sequel::Error)
-  end
-  
-  specify "should support getting and setting the temp_store pragma" do
-    @db.temp_store = :default
-    @db.temp_store.should == :default
-    @db.temp_store = :file
-    @db.temp_store.should == :file
-    @db.temp_store = :memory
-    @db.temp_store.should == :memory
-    
-    proc {@db.temp_store = :invalid}.should raise_error(Sequel::Error)
-  end
-  
-  specify "should be able to execute multiple statements at once" do
-    @db.create_table :t do
-      text :name
-    end
-    
-    @db << "insert into t (name) values ('abc');insert into t (name) values ('def')"
-
-    @db[:t].count.should == 2
-    
-    @db[:t].order(:name).map(:name).should == ['abc', 'def']
-  end
-  
-  specify "should be able to execute transactions" do
-    @db.transaction do
-      @db.create_table(:t) {text :name}
-    end
-    
-    @db.tables.should == [:t]
-
-    proc {@db.transaction do
-      @db.create_table(:u) {text :name}
-      raise ArgumentError
-    end}.should raise_error(ArgumentError)
-    # no commit
-    @db.tables.should == [:t]
-
-    proc {@db.transaction do
-      @db.create_table(:v) {text :name}
-      raise Sequel::Error::Rollback
-    end}.should_not raise_error
-    # no commit
-    @db.tables.should == [:t]
-  end
-
-  specify "should support nested transactions" do
-    @db.transaction do
-      @db.transaction do
-        @db.create_table(:t) {text :name}
-      end
-    end
-    
-    @db.tables.should == [:t]
-
-    proc {@db.transaction do
-      @db.create_table(:v) {text :name}
-      @db.transaction do
-        raise Sequel::Error::Rollback # should roll back the top-level transaction
-      end
-    end}.should_not raise_error
-    # no commit
-    @db.tables.should == [:t]
-  end
-  
-  specify "should handle returning inside of transaction by committing" do
-    @db.create_table(:items){text :name}
-    def @db.ret_commit
-      transaction do
-        self[:items] << {:name => 'abc'}
-        return
-        self[:items] << {:name => 'd'}
-      end
-    end
-    @db[:items].count.should == 0
-    @db.ret_commit
-    @db[:items].count.should == 1
-    @db.ret_commit
-    @db[:items].count.should == 2
-    proc do
-      @db.transaction do
-        raise Interrupt, 'asdf'
-      end
-    end.should raise_error(Interrupt)
-
-    @db[:items].count.should == 2
-  end
-
-  specify "should provide disconnect functionality" do
-    @db.tables
-    @db.pool.size.should == 1
-    @db.disconnect
-    @db.pool.size.should == 0
-  end
-
-  specify "should support timestamps" do
-    t1 = Time.at(Time.now.to_i) #normalize time
-    
-    SQLITE_DB[:time] << {:t => t1}
-    SQLITE_DB[:time].first[:t].should == t1
-  end
-  
-  specify "should support sequential primary keys" do
-    @db.create_table!(:with_pk) {primary_key :id; text :name}
-    @db[:with_pk] << {:name => 'abc'}
-    @db[:with_pk] << {:name => 'def'}
-    @db[:with_pk] << {:name => 'ghi'}
-    @db[:with_pk].order(:name).all.should == [
-      {:id => 1, :name => 'abc'},
-      {:id => 2, :name => 'def'},
-      {:id => 3, :name => 'ghi'}
-    ]
-  end
-  
-  specify "should catch invalid SQL errors and raise them as Error::InvalidStatement" do
-    proc {@db.execute 'blah blah'}.should raise_error(
-      Sequel::Error::InvalidStatement, "blah blah\r\nnear \"blah\": syntax error")
-
-    proc {@db.execute_insert 'blah blah'}.should raise_error(
-      Sequel::Error::InvalidStatement, "blah blah\r\nnear \"blah\": syntax error")
-
-    proc {@db.execute_select 'blah blah'}.should raise_error(
-      Sequel::Error::InvalidStatement, "blah blah\r\nnear \"blah\": syntax error")
-
-    proc {@db.single_value 'blah blah'}.should raise_error(
-      Sequel::Error::InvalidStatement, "blah blah\r\nnear \"blah\": syntax error")
-  end
-  
-  specify "should not swallow non-SQLite based exceptions" do
-    proc {@db.pool.hold{raise Interrupt, "test"}}.should raise_error(Interrupt)
-  end
-
-  specify "should correctly parse the schema" do
-    @db.create_table(:time) {timestamp :t}
-    @db.schema(:time, :reload=>true).should == [[:t, {:type=>:datetime, :allow_null=>true, :max_chars=>nil, :default=>nil, :db_type=>"timestamp", :numeric_precision=>nil, :primary_key=>false}]]
-  end
-
-  specify "should get the schema all database tables if no table name is used" do
-    @db.create_table(:time) {timestamp :t}
-    @db.schema(:time, :reload=>true).should == @db.schema(nil, :reload=>true)[:time]
-  end
-end
-
-context "An SQLite dataset" do
-  setup do
-    @d = SQLITE_DB[:items]
-    @d.delete # remove all records
-  end
-  
-  specify "should return the correct records" do
-    @d.to_a.should == []
-    @d << {:name => 'abc', :value => 1.23}
-    @d << {:name => 'abc', :value => 4.56}
-    @d << {:name => 'def', :value => 7.89}
-    @d.select(:name, :value).to_a.sort_by {|h| h[:value]}.should == [
-      {:name => 'abc', :value => 1.23},
-      {:name => 'abc', :value => 4.56},
-      {:name => 'def', :value => 7.89}
-    ]
-  end
-  
-  specify "should return the correct record count" do
-    @d.count.should == 0
-    @d << {:name => 'abc', :value => 1.23}
-    @d << {:name => 'abc', :value => 4.56}
-    @d << {:name => 'def', :value => 7.89}
-    @d.count.should == 3
-  end
-
-  specify "should return the last inserted id when inserting records" do
-    id = @d << {:name => 'abc', :value => 1.23}
-    id.should == @d.first[:id]
-  end
-  
-  specify "should update records correctly" do
-    @d << {:name => 'abc', :value => 1.23}
-    @d << {:name => 'abc', :value => 4.56}
-    @d << {:name => 'def', :value => 7.89}
-    @d.filter(:name => 'abc').update(:value => 5.3)
-    
-    # the third record should stay the same
-    @d[:name => 'def'][:value].should == 7.89
-    @d.filter(:value => 5.3).count.should == 2
-  end
-  
-  specify "should delete records correctly" do
-    @d << {:name => 'abc', :value => 1.23}
-    @d << {:name => 'abc', :value => 4.56}
-    @d << {:name => 'def', :value => 7.89}
-    @d.filter(:name => 'abc').delete
-    
-    @d.count.should == 1
-    @d.first[:name].should == 'def'
-  end
-
-  specify "should handle string pattern matches correctly" do
-    @d.literal(:x.like('a')).should == "(x LIKE 'a')"
-    @d.literal(~:x.like('a')).should == "NOT (x LIKE 'a')"
-    @d.literal(:x.ilike('a')).should == "(x LIKE 'a')"
-    @d.literal(~:x.ilike('a')).should == "NOT (x LIKE 'a')"
-  end
-
-  specify "should raise errors if given a regexp pattern match" do
-    proc{@d.literal(:x.like(/a/))}.should raise_error(Sequel::Error)
-    proc{@d.literal(~:x.like(/a/))}.should raise_error(Sequel::Error)
-    proc{@d.literal(:x.like(/a/i))}.should raise_error(Sequel::Error)
-    proc{@d.literal(~:x.like(/a/i))}.should raise_error(Sequel::Error)
-  end
-end
-
-context "An SQLite dataset" do
-  setup do
-    @d = SQLITE_DB[:items]
-    @d.delete # remove all records
-    @d << {:name => 'abc', :value => 1.23}
-    @d << {:name => 'def', :value => 4.56}
-    @d << {:name => 'ghi', :value => 7.89}
-  end
-  
-  specify "should correctly return avg" do
-    @d.avg(:value).should == ((1.23 + 4.56 + 7.89) / 3).to_s
-  end
-  
-  specify "should correctly return sum" do
-    @d.sum(:value).should == (1.23 + 4.56 + 7.89).to_s
-  end
-  
-  specify "should correctly return max" do
-    @d.max(:value).should == 7.89.to_s
-  end
-  
-  specify "should correctly return min" do
-    @d.min(:value).should == 1.23.to_s
-  end
-end
-
-context "SQLite::Dataset#delete" do
-  setup do
-    @d = SQLITE_DB[:items]
-    @d.delete # remove all records
-    @d << {:name => 'abc', :value => 1.23}
-    @d << {:name => 'def', :value => 4.56}
-    @d << {:name => 'ghi', :value => 7.89}
-  end
-  
-  specify "should return the number of records affected when filtered" do
-    @d.count.should == 3
-    @d.filter {:value < 3}.delete.should == 1
-    @d.count.should == 2
-
-    @d.filter {:value < 3}.delete.should == 0
-    @d.count.should == 2
-  end
-  
-  specify "should return the number of records affected when unfiltered" do
-    @d.count.should == 3
-    @d.delete.should == 3
-    @d.count.should == 0
-
-    @d.delete.should == 0
-  end
-end
-
-context "SQLite::Dataset#update" do
-  setup do
-    @d = SQLITE_DB[:items]
-    @d.delete # remove all records
-    @d << {:name => 'abc', :value => 1.23}
-    @d << {:name => 'def', :value => 4.56}
-    @d << {:name => 'ghi', :value => 7.89}
-  end
-  
-  specify "should return the number of records affected" do
-    @d.filter(:name => 'abc').update(:value => 2).should == 1
-    
-    @d.update(:value => 10).should == 3
-    
-    @d.filter(:name => 'xxx').update(:value => 23).should == 0
-  end
-end
-
-context "SQLite dataset" do
-  setup do
-    SQLITE_DB.create_table :test do
-      integer :id, :primary_key => true, :auto_increment => true
-      text :name
-      float :value
-    end
-
-    @d = SQLITE_DB[:items]
-    @d.delete # remove all records
-    @d << {:name => 'abc', :value => 1.23}
-    @d << {:name => 'def', :value => 4.56}
-    @d << {:name => 'ghi', :value => 7.89}
-  end
-  
-  teardown do
-    SQLITE_DB.drop_table :test
-  end
-  
-  specify "should be able to insert from a subquery" do
-    SQLITE_DB[:test] << @d
-    SQLITE_DB[:test].count.should == 3
-    SQLITE_DB[:test].select(:name, :value).order(:value).to_a.should == \
-      @d.select(:name, :value).order(:value).to_a
-  end
-end
-
-context "A SQLite database" do
-  setup do
-    @db = SQLITE_DB
-    @db.create_table! :test2 do
-      text :name
-      integer :value
-    end
-  end
-
-  specify "should support add_column operations" do
-    @db.add_column :test2, :xyz, :text
-    
-    @db[:test2].columns.should == [:name, :value, :xyz]
-    @db[:test2] << {:name => 'mmm', :value => 111, :xyz=>'000'}
-    @db[:test2].first.should == {:name => 'mmm', :value => 111, :xyz=>'000'}
-  end
-  
-  specify "should support drop_column operations" do
-    @db.drop_column :test2, :value
-    @db[:test2].columns.should == [:name]
-    @db[:test2] << {:name => 'mmm'}
-    @db[:test2].first.should == {:name => 'mmm'}
-  end
-  
-  specify "should not support rename_column operations" do
-    proc {@db.rename_column :test2, :value, :zyx}.should raise_error(Sequel::Error)
-  end
-  
-  specify "should not support set_column_type operations" do
-    proc {@db.set_column_type :test2, :value, :integer}.should raise_error(Sequel::Error)
-  end
-  
-  specify "should support add_index" do
-    @db.add_index :test2, :value, :unique => true
-    @db.add_index :test2, [:name, :value]
-  end
-  
-  specify "should not support drop_index" do
-    proc {@db.drop_index :test2, :value}.should raise_error(Sequel::Error)
-  end
-end  

data/spec/connection_pool_spec.rb

@@ -1,363 +0,0 @@
-require File.join(File.dirname(__FILE__), 'spec_helper')
-CONNECTION_POOL_DEFAULTS = {:pool_timeout=>5, :pool_sleep_time=>0.001,
-  :pool_reuse_connections=>:allow, :pool_convert_exceptions=>true, :max_connections=>4}
-
-context "An empty ConnectionPool" do
-  setup do
-    @cpool = Sequel::ConnectionPool.new(CONNECTION_POOL_DEFAULTS)
-  end
-
-  specify "should have no available connections" do
-    @cpool.available_connections.should == []
-  end
-
-  specify "should have no allocated connections" do
-    @cpool.allocated.should == {}
-  end
-
-  specify "should have a created_count of zero" do
-    @cpool.created_count.should == 0
-  end
-end
-
-context "A connection pool handling connections" do
-  setup do
-    @max_size = 2
-    @cpool = Sequel::ConnectionPool.new(CONNECTION_POOL_DEFAULTS.merge(:max_connections=>@max_size)) {:got_connection}
-  end
-
-  specify "#hold should increment #created_count" do
-    @cpool.hold do
-      @cpool.created_count.should == 1
-      @cpool.hold {@cpool.hold {@cpool.created_count.should == 1}}
-      Thread.new{@cpool.hold {@cpool.created_count.should == 2}}.join
-    end
-  end
-
-  specify "#hold should add the connection to the #allocated array" do
-    @cpool.hold do
-      @cpool.allocated.size.should == 1
-  
-      @cpool.allocated.should == {Thread.current=>:got_connection}
-    end
-  end
-
-  specify "#hold should yield a new connection" do
-    @cpool.hold {|conn| conn.should == :got_connection}
-  end
-
-  specify "a connection should be de-allocated after it has been used in #hold" do
-    @cpool.hold {}
-    @cpool.allocated.size.should == 0
-  end
-
-  specify "#hold should return the value of its block" do
-    @cpool.hold {:block_return}.should == :block_return
-  end
-
-  specify "#make_new should not make more than max_size connections" do
-    @cpool.send(:make_new).should == :got_connection
-    @cpool.send(:make_new).should == :got_connection
-    @cpool.send(:make_new).should == nil
-    @cpool.created_count.should == 2
-  end
-end
-
-class DummyConnection
-  @@value = 0
-  def initialize
-    @@value += 1
-  end
-  
-  def value
-    @@value
-  end
-end
-
-context "ConnectionPool#hold" do
-  setup do
-    @pool = Sequel::ConnectionPool.new(CONNECTION_POOL_DEFAULTS) {DummyConnection.new}
-  end
-  
-  specify "should pass the result of the connection maker proc to the supplied block" do
-    res = nil
-    @pool.hold {|c| res = c}
-    res.should be_a_kind_of(DummyConnection)
-    res.value.should == 1
-    @pool.hold {|c| res = c}
-    res.should be_a_kind_of(DummyConnection)
-    res.value.should == 1 # the connection maker is invoked only once
-  end
-  
-  specify "should be re-entrant by the same thread" do
-    cc = nil
-    @pool.hold {|c| @pool.hold {|c| @pool.hold {|c| cc = c}}}
-    cc.should be_a_kind_of(DummyConnection)
-  end
-  
-  specify "should catch exceptions and reraise them" do
-    proc {@pool.hold {|c| c.foobar}}.should raise_error(NoMethodError)
-  end
-  
-  specify "should handle Exception errors (normally not caught by rescue)" do
-    err = nil
-    begin
-      @pool.hold {raise Exception}
-    rescue => e
-      err = e
-    end
-    err.should be_a_kind_of(RuntimeError)
-  end
-end
-
-context "ConnectionPool#connection_proc" do
-  setup do
-    @pool = Sequel::ConnectionPool.new(CONNECTION_POOL_DEFAULTS)
-  end
-  
-  specify "should be nil if no block is supplied to the pool" do
-    @pool.connection_proc.should be_nil
-    proc {@pool.hold {}}.should raise_error
-  end
-  
-  specify "should be mutable" do
-    @pool.connection_proc = proc {'herro'}
-    res = nil
-    proc {@pool.hold {|c| res = c}}.should_not raise_error
-    res.should == 'herro'
-  end
-end
-
-context "A connection pool with a max size of 1" do
-  setup do
-    @invoked_count = 0
-    @pool = Sequel::ConnectionPool.new(CONNECTION_POOL_DEFAULTS.merge(:max_connections=>1)) {@invoked_count += 1; 'herro'}
-  end
-  
-  specify "should let only one thread access the connection at any time" do
-    cc,c1, c2 = nil
-    
-    t1 = Thread.new {@pool.hold {|c| cc = c; c1 = c.dup; while c == 'herro';sleep 0.1;end}}
-    sleep 0.2
-    cc.should == 'herro'
-    c1.should == 'herro'
-    
-    t2 = Thread.new {@pool.hold {|c| c2 = c.dup; while c == 'hello';sleep 0.1;end}}
-    sleep 0.2
-    
-    # connection held by t1
-    t1.should be_alive
-    t2.should be_alive
-    
-    cc.should == 'herro'
-    c1.should == 'herro'
-    c2.should be_nil
-    
-    @pool.available_connections.should be_empty
-    @pool.allocated.should == {t1=>cc}
-    
-    cc.gsub!('rr', 'll')
-    sleep 0.5
-    
-    # connection held by t2
-    t1.should_not be_alive
-    t2.should be_alive
-
-    c2.should == 'hello'
-
-    @pool.available_connections.should be_empty
-    @pool.allocated.should == {t2=>cc}
-    
-    cc.gsub!('ll', 'rr')
-    sleep 0.5
-    
-    #connection released
-    t2.should_not be_alive
-    
-    cc.should == 'herro'
-    
-    @invoked_count.should == 1
-    @pool.size.should == 1
-    @pool.available_connections.should == [cc]
-    @pool.allocated.should be_empty
-  end
-  
-  specify "should let the same thread reenter #hold" do
-    c1, c2, c3 = nil
-    @pool.hold do |c|
-      c1 = c
-      @pool.hold do |c|
-        c2 = c
-        @pool.hold do |c|
-          c3 = c
-        end
-      end
-    end
-    c1.should == 'herro'
-    c2.should == 'herro'
-    c3.should == 'herro'
-    
-    @invoked_count.should == 1
-    @pool.size.should == 1
-    @pool.available_connections.size.should == 1
-    @pool.allocated.should be_empty
-  end
-end
-
-context "A connection pool with a max size of 5" do
-  setup do
-    @invoked_count = 0
-    @pool = Sequel::ConnectionPool.new(CONNECTION_POOL_DEFAULTS.merge(:max_connections=>5)) {@invoked_count += 1}
-  end
-  
-  specify "should let five threads simultaneously access separate connections" do
-    cc = {}
-    threads = []
-    stop = nil
-    
-    5.times {|i| threads << Thread.new {@pool.hold {|c| cc[i] = c; while !stop;sleep 0.1;end}}; sleep 0.1}
-    sleep 0.2
-    threads.each {|t| t.should be_alive}
-    cc.size.should == 5
-    @invoked_count.should == 5
-    @pool.size.should == 5
-    @pool.available_connections.should be_empty
-    i = 0
-    h = {}
-    threads.each{|t| h[t] = (i+=1)}
-    @pool.allocated.should == h
-    
-    threads[0].raise "your'e dead"
-    sleep 0.1
-    threads[3].raise "your'e dead too"
-    
-    sleep 0.1
-    
-    @pool.available_connections.should == [1, 4]
-    @pool.allocated.should == {threads[1]=>2, threads[2]=>3, threads[4]=>5}
-    
-    stop = true
-    sleep 0.2
-    
-    @pool.available_connections.size.should == 5
-    @pool.allocated.should be_empty
-  end
-  
-  specify "should block threads until a connection becomes available" do
-    cc = {}
-    threads = []
-    stop = nil
-    
-    5.times {|i| threads << Thread.new {@pool.hold {|c| cc[i] = c; while !stop;sleep 0.1;end}}; sleep 0.1}
-    sleep 0.2
-    threads.each {|t| t.should be_alive}
-    @pool.available_connections.should be_empty
-
-    3.times {|i| threads << Thread.new {@pool.hold {|c| cc[i + 5] = c}}}
-    
-    sleep 0.2
-    threads[5].should be_alive
-    threads[6].should be_alive
-    threads[7].should be_alive
-    cc.size.should == 5
-    cc[5].should be_nil
-    cc[6].should be_nil
-    cc[7].should be_nil
-    
-    stop = true
-    sleep 0.3
-    
-    threads.each {|t| t.should_not be_alive}
-    
-    @pool.size.should == 5
-    @invoked_count.should == 5
-    @pool.available_connections.size.should == 5
-    @pool.allocated.should be_empty
-  end
-end
-
-context "ConnectionPool#disconnect" do
-  setup do
-    @count = 0
-    @pool = Sequel::ConnectionPool.new(CONNECTION_POOL_DEFAULTS.merge(:max_connections=>5)) {{:id => @count += 1}}
-  end
-  
-  specify "should invoke the given block for each available connection" do
-    threads = []
-    stop = nil
-    5.times {|i| threads << Thread.new {@pool.hold {|c| while !stop;sleep 0.1;end}}; sleep 0.1}
-    while @pool.size < 5
-      sleep 0.2
-    end
-    stop = true
-    sleep 1
-    threads.each {|t| t.join}
-    
-    @pool.size.should == 5
-    @pool.available_connections.size.should == 5
-    @pool.available_connections.each {|c| c[:id].should_not be_nil}
-    conns = []
-    @pool.disconnect {|c| conns << c}
-    conns.size.should == 5
-  end
-  
-  specify "should remove all available connections" do
-    threads = []
-    stop = nil
-    5.times {|i| threads << Thread.new {@pool.hold {|c| while !stop;sleep 0.1;end}}; sleep 0.1}
-    while @pool.size < 5
-      sleep 0.2
-    end
-    stop = true
-    sleep 1
-    threads.each {|t| t.join}
-    
-    @pool.size.should == 5
-    @pool.disconnect
-    @pool.size.should == 0
-  end
-
-  specify "should not touch connections in use" do
-    threads = []
-    stop = nil
-    5.times {|i| threads << Thread.new {@pool.hold {|c| while !stop;sleep 0.1;end}}; sleep 0.1}
-    while @pool.size < 5
-      sleep 0.2
-    end
-    stop = true
-    sleep 1
-    threads.each {|t| t.join}
-    
-    @pool.size.should == 5
-    
-    @pool.hold do |conn|
-      @pool.available_connections.size.should == 4
-      @pool.available_connections.each {|c| c.should_not be(conn)}
-      conns = []
-      @pool.disconnect {|c| conns << c}
-      conns.size.should == 4
-    end
-    @pool.size.should == 1
-  end
-end
-
-context "SingleThreadedPool" do
-  setup do
-    @pool = Sequel::SingleThreadedPool.new(CONNECTION_POOL_DEFAULTS){1234}
-  end
-  
-  specify "should provide a #hold method" do
-    conn = nil
-    @pool.hold {|c| conn = c}
-    conn.should == 1234
-  end
-  
-  specify "should provide a #disconnect method" do
-    @pool.hold {|c|}
-    @pool.conn.should == 1234
-    conn = nil
-    @pool.disconnect {|c| conn = c}
-    conn.should == 1234
-    @pool.conn.should be_nil
-  end
-end