asana2flowdock 1.0.0 → 1.1.0

data/vendor/bundle/ruby/1.9.1/gems/sequel-4.15.0/spec/bin_spec.rb

@@ -1,256 +0,0 @@
-require 'rubygems'
-require 'rbconfig'
-require 'yaml'
-
-RUBY = File.join(RbConfig::CONFIG['bindir'], RbConfig::CONFIG['RUBY_INSTALL_NAME'])
-OUTPUT = "spec/bin-sequel-spec-output-#{$$}.log"
-TMP_FILE = "spec/bin-sequel-tmp-#{$$}.rb"
-BIN_SPEC_DB = "spec/bin-sequel-spec-db-#{$$}.sqlite3"
-BIN_SPEC_DB2 = "spec/bin-sequel-spec-db2-#{$$}.sqlite3"
-
-if defined?(RUBY_ENGINE) && RUBY_ENGINE == 'jruby'
-  CONN_PREFIX = 'jdbc:sqlite:'
-  CONN_HASH = {:adapter=>'jdbc', :uri=>"#{CONN_PREFIX}#{BIN_SPEC_DB}"}
-else
-  CONN_PREFIX = 'sqlite://'
-  CONN_HASH = {:adapter=>'sqlite', :database=>BIN_SPEC_DB}
-end
-
-unless Object.const_defined?('Sequel') && Sequel.const_defined?('Model')
-  $:.unshift(File.join(File.dirname(File.expand_path(__FILE__)), "../../lib/"))
-  require 'sequel'
-end
-
-DB = Sequel.connect("#{CONN_PREFIX}#{BIN_SPEC_DB}")
-DB2 = Sequel.connect("#{CONN_PREFIX}#{BIN_SPEC_DB2}")
-File.delete(BIN_SPEC_DB) if File.file?(BIN_SPEC_DB)
-File.delete(BIN_SPEC_DB2) if File.file?(BIN_SPEC_DB2)
-
-require File.join(File.dirname(File.expand_path(__FILE__)), "rspec_helper.rb")
-
-describe "bin/sequel" do
-  def bin(opts={})
-    cmd = "#{opts[:pre]}\"#{RUBY}\" -I lib bin/sequel #{opts[:args]} #{"#{CONN_PREFIX}#{BIN_SPEC_DB}" unless opts[:no_conn]} #{opts[:post]}> #{OUTPUT}#{" 2>&1" if opts[:stderr]}"
-    system(cmd)
-    File.read(OUTPUT)
-  end
-
-  after do
-    DB.disconnect
-    DB2.disconnect
-    File.delete(BIN_SPEC_DB) if File.file?(BIN_SPEC_DB)
-    File.delete(BIN_SPEC_DB2) if File.file?(BIN_SPEC_DB2)
-    File.delete(TMP_FILE) if File.file?(TMP_FILE)
-  end
-  after(:all) do
-    File.delete(OUTPUT) if File.file?(OUTPUT)
-  end
-  
-  it "-h should print the help" do
-    help = bin(:args=>"-h", :no_conn=>true)
-    help.should =~ /\ASequel: The Database Toolkit for Ruby/
-    help.should =~ /^Usage: sequel /
-  end
-
-  it "-c should run code" do
-    bin(:args=>'-c "print DB.tables.inspect"').should == '[]'
-    DB.create_table(:a){Integer :a}
-    bin(:args=>'-c "print DB.tables.inspect"').should == '[:a]'
-    bin(:args=>'-v -c "print DB.tables.inspect"').should == "sequel #{Sequel.version}\n[:a]"
-  end
-
-  it "-C should copy databases" do
-    DB.create_table(:a) do
-      primary_key :a
-      String :name
-    end
-    DB.create_table(:b) do
-      foreign_key :a, :a
-      index :a
-    end
-    DB[:a].insert(1, 'foo')
-    DB[:b].insert(1)
-    bin(:args=>'-C', :post=>"#{CONN_PREFIX}#{BIN_SPEC_DB2}").should =~ Regexp.new(<<END)
-Databases connections successful
-Migrations dumped successfully
-Tables created
-Begin copying data
-Begin copying records for table: a
-Finished copying 1 records for table: a
-Begin copying records for table: b
-Finished copying 1 records for table: b
-Finished copying data
-Begin creating indexes
-Finished creating indexes
-Begin adding foreign key constraints
-Finished adding foreign key constraints
-Database copy finished in \\d\\.\\d+ seconds
-END
-    DB2.tables.sort_by{|t| t.to_s}.should == [:a, :b]
-    DB[:a].all.should == [{:a=>1, :name=>'foo'}]
-    DB[:b].all.should == [{:a=>1}]
-    DB2.schema(:a).map{|col, sch| [col, *sch.values_at(:allow_null, :default, :primary_key, :db_type, :type, :ruby_default)]}.should == [[:a, false, nil, true, "integer", :integer, nil], [:name, true, nil, false, "varchar(255)", :string, nil]]
-    DB2.schema(:b).map{|col, sch| [col, *sch.values_at(:allow_null, :default, :primary_key, :db_type, :type, :ruby_default)]}.should == [[:a, true, nil, false, "integer", :integer, nil]]
-    DB2.indexes(:a).should == {}
-    DB2.indexes(:b).should == {:b_a_index=>{:unique=>false, :columns=>[:a]}}
-    DB2.foreign_key_list(:a).should == []
-    DB2.foreign_key_list(:b).should == [{:columns=>[:a], :table=>:a, :key=>nil, :on_update=>:no_action, :on_delete=>:no_action}]
-  end
-
-  it "-d and -D should dump generic and specific migrations" do
-    DB.create_table(:a) do
-      primary_key :a
-      String :name
-    end
-    DB.create_table(:b) do
-      foreign_key :a, :a
-      index :a
-    end
-    bin(:args=>'-d').should == <<END
-Sequel.migration do
-  change do
-    create_table(:a) do
-      primary_key :a
-      String :name, :size=>255
-    end
-    
-    create_table(:b, :ignore_index_errors=>true) do
-      foreign_key :a, :a
-      
-      index [:a]
-    end
-  end
-end
-END
-    bin(:args=>'-D').should == <<END
-Sequel.migration do
-  change do
-    create_table(:a) do
-      primary_key :a
-      column :name, "varchar(255)"
-    end
-    
-    create_table(:b) do
-      foreign_key :a, :a
-      
-      index [:a]
-    end
-  end
-end
-END
-  end
-
-  it "-E should echo SQL statements to stdout" do
-    bin(:args=>'-E -c DB.tables').should =~ %r{SELECT \* FROM `sqlite_master` WHERE \(type = 'table' AND NOT name = 'sqlite_sequence'\)\n}
-  end
-
-  it "-I should include directory in load path" do
-    bin(:args=>'-Ifoo -c "p 1 if $:.include?(\'foo\')"').should == "1\n"
-  end
-
-  it "-l should log SQL statements to file" do
-    bin(:args=>"-l #{TMP_FILE} -c DB.tables").should == ''
-    File.read(TMP_FILE).should =~ %r{SELECT \* FROM `sqlite_master` WHERE \(type = 'table' AND NOT name = 'sqlite_sequence'\)\n}
-  end
-
-  it "-L should load all *.rb files in given directory" do
-    bin(:args=>'-L ./lib/sequel/connection_pool -c "p [Sequel::SingleConnectionPool, Sequel::ThreadedConnectionPool, Sequel::ShardedSingleConnectionPool, Sequel::ShardedThreadedConnectionPool].length"').should == "4\n"
-  end
-
-  it "-m should migrate database up" do
-    bin(:args=>"-m spec/files/integer_migrations").should == ''
-    DB.tables.sort_by{|t| t.to_s}.should == [:schema_info, :sm1111, :sm2222, :sm3333]
-  end
-
-  it "-M should specify version to migrate to" do
-    bin(:args=>"-m spec/files/integer_migrations -M 2").should == ''
-    DB.tables.sort_by{|t| t.to_s}.should == [:schema_info, :sm1111, :sm2222]
-  end
-
-  it "-N should not test for a valid connection" do
-    bin(:no_conn=>true, :args=>"-c '' -N #{CONN_PREFIX}spec/nonexistent/foo").should == ''
-    bin(:no_conn=>true, :args=>"-c '' #{CONN_PREFIX}spec/nonexistent/foo", :stderr=>true).should =~ /\AError: Sequel::DatabaseConnectionError: /
-  end
-
-  it "-r should require a given library" do
-    bin(:args=>'-rsequel/extensions/sql_expr -c "print DB.literal(1.sql_expr)"').should == "1"
-  end
-
-  it "-S should dump the schema cache" do
-    bin(:args=>"-S #{TMP_FILE}").should == ''
-    Marshal.load(File.read(TMP_FILE)).should == {}
-    DB.create_table(:a){Integer :a}
-    bin(:args=>"-S #{TMP_FILE}").should == ''
-    Marshal.load(File.read(TMP_FILE)).should == {"`a`"=>[[:a, {:type=>:integer, :db_type=>"integer", :ruby_default=>nil, :allow_null=>true, :default=>nil, :primary_key=>false}]]}
-  end
-
-  it "-t should output full backtraces on error" do
-    bin(:args=>'-c "lambda{lambda{lambda{raise \'foo\'}.call}.call}.call"', :stderr=>true).count("\n").should < 3
-    bin(:args=>'-t -c "lambda{lambda{lambda{raise \'foo\'}.call}.call}.call"', :stderr=>true).count("\n").should > 3
-  end
-
-  it "-v should output the Sequel version and exit if database is not given" do
-    bin(:args=>"-v", :no_conn=>true).should == "sequel #{Sequel.version}\n"
-  end
-
-  it "should error if using -M without -m" do
-    bin(:args=>'-M 2', :stderr=>true).should == "Error: Must specify -m if using -M\n"
-  end
-
-  it "should error if using mutually exclusive options together" do
-    bin(:args=>'-c foo -d', :stderr=>true).should == "Error: Cannot specify -c and -d together\n"
-    bin(:args=>'-D -d', :stderr=>true).should == "Error: Cannot specify -D and -d together\n"
-    bin(:args=>'-m foo -d', :stderr=>true).should == "Error: Cannot specify -m and -d together\n"
-    bin(:args=>'-S foo -d', :stderr=>true).should == "Error: Cannot specify -S and -d together\n"
-    bin(:args=>'-S foo -C', :stderr=>true).should == "Error: Cannot specify -S and -C together\n"
-  end
-
-  it "should use a mock database if no database is given" do
-    bin(:args=>'-c "print DB.adapter_scheme"', :no_conn=>true).should == "mock"
-  end
-
-  it "should work with a yaml config file" do
-    File.open(TMP_FILE, 'wb'){|f| f.write(YAML.dump(CONN_HASH))}
-    bin(:args=>"-c \"print DB.tables.inspect\" #{TMP_FILE}", :no_conn=>true).should == "[]"
-    DB.create_table(:a){Integer :a}
-    bin(:args=>"-c \"print DB.tables.inspect\" #{TMP_FILE}", :no_conn=>true).should == "[:a]"
-  end
-
-  it "should work with a yaml config file with string keys" do
-    h = {}
-    CONN_HASH.each{|k,v| h[k.to_s] = v}
-    File.open(TMP_FILE, 'wb'){|f| f.write(YAML.dump(h))}
-    DB.create_table(:a){Integer :a}
-    bin(:args=>"-c \"print DB.tables.inspect\" #{TMP_FILE}", :no_conn=>true).should == "[:a]"
-  end
-
-  it "should work with a yaml config file with environments" do
-    File.open(TMP_FILE, 'wb'){|f| f.write(YAML.dump(:development=>CONN_HASH))}
-    bin(:args=>"-c \"print DB.tables.inspect\" #{TMP_FILE}", :no_conn=>true).should == "[]"
-    DB.create_table(:a){Integer :a}
-    bin(:args=>"-c \"print DB.tables.inspect\" #{TMP_FILE}", :no_conn=>true).should == "[:a]"
-  end
-
-  it "-e should set environment for yaml config file" do
-    File.open(TMP_FILE, 'wb'){|f| f.write(YAML.dump(:foo=>CONN_HASH))}
-    bin(:args=>"-c \"print DB.tables.inspect\" -e foo #{TMP_FILE}", :no_conn=>true).should == "[]"
-    DB.create_table(:a){Integer :a}
-    bin(:args=>"-c \"print DB.tables.inspect\" -e foo #{TMP_FILE}", :no_conn=>true).should == "[:a]"
-    File.open(TMP_FILE, 'wb'){|f| f.write(YAML.dump('foo'=>CONN_HASH))}
-    bin(:args=>"-c \"print DB.tables.inspect\" -e foo #{TMP_FILE}", :no_conn=>true).should == "[:a]"
-  end
-
-  it "should run code in given filenames" do
-    File.open(TMP_FILE, 'wb'){|f| f.write('print DB.tables.inspect')}
-    bin(:post=>TMP_FILE).should == '[]'
-    DB.create_table(:a){Integer :a}
-    bin(:post=>TMP_FILE).should == '[:a]'
-    bin(:post=>TMP_FILE, :args=>'-v').should == "sequel #{Sequel.version}\n[:a]"
-  end
-
-  it "should run code provided on stdin" do
-    bin(:pre=>'echo print DB.tables.inspect | ').should == '[]'
-    DB.create_table(:a){Integer :a}
-    bin(:pre=>'echo print DB.tables.inspect | ').should == '[:a]'
-  end
-end

data/vendor/bundle/ruby/1.9.1/gems/sequel-4.15.0/spec/core/connection_pool_spec.rb

@@ -1,982 +0,0 @@
-require File.join(File.dirname(File.expand_path(__FILE__)), 'spec_helper')
-CONNECTION_POOL_DEFAULTS = {:pool_timeout=>5, :pool_sleep_time=>0.001, :max_connections=>4}
-
-mock_db = lambda do |*a, &b|
-  db = Sequel.mock
-  (class << db; self end).send(:define_method, :connect){|c| b.arity == 1 ? b.call(c) : b.call} if b
-  if b2 = a.shift
-    (class << db; self end).send(:define_method, :disconnect_connection){|c| b2.arity == 1 ? b2.call(c) : b2.call}
-  end
-  db
-end
-
-describe "An empty ConnectionPool" do
-  before do
-    @cpool = Sequel::ConnectionPool.get_pool(mock_db.call, 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
-
-describe "ConnectionPool options" do
-  specify "should support string option values" do
-    cpool = Sequel::ConnectionPool.get_pool(mock_db.call, {:max_connections=>'5', :pool_timeout=>'3', :pool_sleep_time=>'0.01'})
-    cpool.max_size.should == 5
-    cpool.instance_variable_get(:@timeout).should == 3
-    cpool.instance_variable_get(:@sleep_time).should == 0.01
-  end
-
-  specify "should raise an error unless size is positive" do
-    lambda{Sequel::ConnectionPool.get_pool(mock_db.call{1}, :max_connections=>0)}.should raise_error(Sequel::Error)
-    lambda{Sequel::ConnectionPool.get_pool(mock_db.call{1}, :max_connections=>-10)}.should raise_error(Sequel::Error)
-    lambda{Sequel::ConnectionPool.get_pool(mock_db.call{1}, :max_connections=>'-10')}.should raise_error(Sequel::Error)
-    lambda{Sequel::ConnectionPool.get_pool(mock_db.call{1}, :max_connections=>'0')}.should raise_error(Sequel::Error)
-  end
-end
-
-describe "A connection pool handling connections" do
-  before do
-    @max_size = 2
-    msp = proc{@max_size=3}
-    @cpool = Sequel::ConnectionPool.get_pool(mock_db.call(proc{|c| msp.call}){:got_connection}, CONNECTION_POOL_DEFAULTS.merge(:max_connections=>@max_size))
-  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
-
-  if RUBY_VERSION < '1.9.0' and !defined?(RUBY_ENGINE)
-    specify "#hold should remove dead threads from the pool if it reaches its max_size" do
-      Thread.new{@cpool.hold{Thread.current.exit!}}.join
-      @cpool.allocated.keys.map{|t| t.alive?}.should == [false]
-
-      Thread.new{@cpool.hold{Thread.current.exit!}}.join
-      @cpool.allocated.keys.map{|t| t.alive?}.should == [false, false]
-
-      Thread.new{@cpool.hold{}}.join
-      @cpool.allocated.should == {}
-    end
-  end
-
-  specify "#make_new should not make more than max_size connections" do
-    q = Queue.new
-    50.times{Thread.new{@cpool.hold{q.pop}}}
-    50.times{q.push nil}
-    @cpool.created_count.should <= @max_size
-  end
-
-  specify "database's disconnect connection method should be called when a disconnect is detected" do
-    @max_size.should == 2
-    proc{@cpool.hold{raise Sequel::DatabaseDisconnectError}}.should raise_error(Sequel::DatabaseDisconnectError)
-    @max_size.should == 3
-  end
-
-  specify "#hold should remove the connection if a DatabaseDisconnectError is raised" do
-    @cpool.created_count.should == 0
-    q, q1 = Queue.new, Queue.new
-    @cpool.hold{Thread.new{@cpool.hold{q1.pop; q.push nil}; q1.pop; q.push nil}; q1.push nil; q.pop; q1.push nil; q.pop}
-    @cpool.created_count.should == 2
-    proc{@cpool.hold{raise Sequel::DatabaseDisconnectError}}.should raise_error(Sequel::DatabaseDisconnectError)
-    @cpool.created_count.should == 1
-    proc{@cpool.hold{raise Sequel::DatabaseDisconnectError}}.should raise_error(Sequel::DatabaseDisconnectError)
-    @cpool.created_count.should == 0
-    proc{@cpool.hold{raise Sequel::DatabaseDisconnectError}}.should raise_error(Sequel::DatabaseDisconnectError)
-    @cpool.created_count.should == 0
-  end
-end
-
-describe "A connection pool handling connection errors" do 
-  specify "#hold should raise a Sequel::DatabaseConnectionError if an exception is raised by the connection_proc" do
-    cpool = Sequel::ConnectionPool.get_pool(CONNECTION_POOL_DEFAULTS){raise Interrupt}
-    proc{cpool.hold{:block_return}}.should raise_error(Sequel::DatabaseConnectionError)
-    cpool.created_count.should == 0
-  end
-
-  specify "#hold should raise a Sequel::DatabaseConnectionError if nil is returned by the connection_proc" do
-    cpool = Sequel::ConnectionPool.get_pool(CONNECTION_POOL_DEFAULTS){nil}
-    proc{cpool.hold{:block_return}}.should raise_error(Sequel::DatabaseConnectionError)
-    cpool.created_count.should == 0
-  end
-end
-
-describe "ConnectionPool#hold" do
-  before do
-    value = 0
-    c = @c = Class.new do
-      define_method(:initialize){value += 1}
-      define_method(:value){value}
-    end
-    @pool = Sequel::ConnectionPool.get_pool(mock_db.call{c.new}, CONNECTION_POOL_DEFAULTS)
-  end
-  
-  specify "shoulda use the database's connect method to get new connections" do
-    res = nil
-    @pool.hold {|c| res = c}
-    res.should be_a_kind_of(@c)
-    res.value.should == 1
-    @pool.hold {|c| res = c}
-    res.should be_a_kind_of(@c)
-    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 {|c1| @pool.hold {|c2| cc = c2}}}
-    cc.should be_a_kind_of(@c)
-  end
-  
-  specify "should catch exceptions and reraise them" do
-    proc {@pool.hold {|c| c.foobar}}.should raise_error(NoMethodError)
-  end
-end
-
-describe "A connection pool with a max size of 1" do
-  before do
-    @invoked_count = 0
-    icp = proc{@invoked_count += 1}
-    @pool = Sequel::ConnectionPool.get_pool(mock_db.call{icp.call; 'herro'}, CONNECTION_POOL_DEFAULTS.merge(:max_connections=>1))
-  end
-  
-  specify "should let only one thread access the connection at any time" do
-    cc,c1, c2 = nil
-    q, q1 = Queue.new, Queue.new
-    
-    t1 = Thread.new {@pool.hold {|c| cc = c; c1 = c.dup; q1.push nil; q.pop}}
-    q1.pop
-    cc.should == 'herro'
-    c1.should == 'herro'
-    
-    t2 = Thread.new {@pool.hold {|c| c2 = c.dup; q1.push nil; q.pop;}}
-    
-    # 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')
-    q.push nil
-    q1.pop
-
-    t1.join
-    t2.should be_alive
-    
-    c2.should == 'hello'
-
-    @pool.available_connections.should be_empty
-    @pool.allocated.should == {t2=>cc}
-    
-    #connection released
-    q.push nil
-    t2.join
-    
-    @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 |cc2|
-        c2 = cc2
-        @pool.hold do |cc3|
-          c3 = cc3
-        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
-
-shared_examples_for "A threaded connection pool" do  
-  specify "should not have all_connections yield connections allocated to other threads" do
-    pool = Sequel::ConnectionPool.get_pool(mock_db.call(&@icpp), @cp_opts.merge(:max_connections=>2, :pool_timeout=>0))
-    q, q1 = Queue.new, Queue.new
-    t = Thread.new do
-      pool.hold do |c1|
-        q1.push nil
-        q.pop
-      end
-    end
-    pool.hold do |c1|
-      q1.pop
-      pool.all_connections{|c| c.should == c1}
-      q.push nil
-    end
-    t.join
-  end
-
-  specify "should wait until a connection is available if all are checked out" do
-    pool = Sequel::ConnectionPool.get_pool(mock_db.call(&@icpp), @cp_opts.merge(:max_connections=>1, :pool_timeout=>0.1, :pool_sleep_time=>0))
-    q, q1 = Queue.new, Queue.new
-    t = Thread.new do
-      pool.hold do |c|
-        q1.push nil
-        3.times{Thread.pass}
-        q.pop
-      end
-    end
-    q1.pop
-    proc{pool.hold{}}.should raise_error(Sequel::PoolTimeout)
-    q.push nil
-    t.join
-  end
-
-  specify "should not have all_connections yield all available connections" do
-    pool = Sequel::ConnectionPool.get_pool(mock_db.call(&@icpp), @cp_opts.merge(:max_connections=>2, :pool_timeout=>0))
-    q, q1 = Queue.new, Queue.new
-    b = []
-    t = Thread.new do
-      pool.hold do |c1|
-        b << c1
-        q1.push nil
-        q.pop
-      end
-    end
-    pool.hold do |c1|
-      q1.pop
-      b << c1
-      q.push nil
-    end
-    t.join
-    a = []
-    pool.all_connections{|c| a << c}
-    a.sort.should == b.sort
-  end
-
-  specify "should raise a PoolTimeout error if a connection couldn't be acquired before timeout" do
-    q, q1 = Queue.new, Queue.new
-    pool = Sequel::ConnectionPool.get_pool(mock_db.call(&@icpp), @cp_opts.merge(:max_connections=>1, :pool_timeout=>0))
-    t = Thread.new{pool.hold{|c| q1.push nil; q.pop}}
-    q1.pop
-    proc{pool.hold{|c|}}.should raise_error(Sequel::PoolTimeout)
-    q.push nil
-    t.join
-  end
-  
-  it "should not add a disconnected connection back to the pool if the disconnection_proc raises an error" do
-    pool = Sequel::ConnectionPool.get_pool(mock_db.call(proc{|c| raise Sequel::Error}, &@icpp), @cp_opts.merge(:max_connections=>1, :pool_timeout=>0))
-    proc{pool.hold{raise Sequel::DatabaseDisconnectError}}.should raise_error(Sequel::Error)
-    pool.available_connections.length.should == 0
-  end
-
-  specify "should let five threads simultaneously access separate connections" do
-    cc = {}
-    threads = []
-    q, q1, q2 = Queue.new, Queue.new, Queue.new
-    
-    5.times{|i| threads << Thread.new{@pool.hold{|c| q.pop; cc[i] = c; q1.push nil; q2.pop}}; q.push nil; q1.pop}
-    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
-
-    h = {}
-    i = 0
-    threads.each{|t| h[t] = (i+=1)}
-    @pool.allocated.should == h
-    @pool.available_connections.should == []
-    5.times{q2.push nil}
-    threads.each{|t| t.join}
-    
-    @pool.available_connections.size.should == 5
-    @pool.allocated.should be_empty
-  end
-  
-  specify "should block threads until a connection becomes available" do
-    cc = {}
-    threads = []
-    q, q1 = Queue.new, Queue.new
-    
-    5.times{|i| threads << Thread.new{@pool.hold{|c| cc[i] = c; q1.push nil; q.pop}}}
-    5.times{q1.pop}
-    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; q1.push nil}}}
-    
-    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
-    
-    5.times{q.push nil}
-    5.times{|i| threads[i].join}
-    3.times{q1.pop}
-    3.times{|i| threads[i+5].join}
-    
-    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
-
-  specify "should store connections in a stack if :connection_handling=>:stack" do
-    @pool = Sequel::ConnectionPool.get_pool(mock_db.call(&@icpp), @cp_opts.merge(:connection_handling=>:stack))
-    c2 = nil
-    c = @pool.hold{|cc| Thread.new{@pool.hold{|cc2| c2 = cc2}}.join; cc}
-    @pool.size.should == 2
-    @pool.hold{|cc| cc.should == c}
-    @pool.hold{|cc| cc.should == c}
-    @pool.hold do |cc|
-      cc.should == c
-      Thread.new{@pool.hold{|cc2| cc2.should == c2}}
-    end
-  end
-
-  specify "should store connections in a queue if :connection_handling=>:queue" do
-    @pool = Sequel::ConnectionPool.get_pool(mock_db.call(&@icpp), @cp_opts.merge(:connection_handling=>:queue))
-    c2 = nil
-    c = @pool.hold{|cc| Thread.new{@pool.hold{|cc2| c2 = cc2}}.join; cc}
-    @pool.size.should == 2
-    @pool.hold{|cc| cc.should == c2}
-    @pool.hold{|cc| cc.should == c}
-    @pool.hold do |cc|
-      cc.should == c2
-      Thread.new{@pool.hold{|cc2| cc2.should == c}}
-    end
-  end
-
-  specify "should not store connections if :connection_handling=>:disconnect" do
-    @pool = Sequel::ConnectionPool.get_pool(mock_db.call(&@icpp), @cp_opts.merge(:connection_handling=>:disconnect))
-    d = []
-    meta_def(@pool.db, :disconnect_connection){|c| d << c}
-    @pool.hold do |cc|
-      cc.should == 1
-      Thread.new{@pool.hold{|cc2| cc2.should == 2}}.join
-      d.should == [2]
-      @pool.hold{|cc3| cc3.should == 1}
-    end
-    @pool.size.should == 0
-    d.should == [2, 1]
-
-    @pool.hold{|cc| cc.should == 3}
-    @pool.size.should == 0
-    d.should == [2, 1, 3]
-
-    @pool.hold{|cc| cc.should == 4}
-    @pool.size.should == 0
-    d.should == [2, 1, 3, 4]
-  end
-end
-
-describe "Threaded Unsharded Connection Pool" do
-  before do
-    @invoked_count = 0
-    @icpp = proc{@invoked_count += 1}
-    @cp_opts = CONNECTION_POOL_DEFAULTS.merge(:max_connections=>5)
-    @pool = Sequel::ConnectionPool.get_pool(mock_db.call(&@icpp), @cp_opts)
-  end
-  
-  it_should_behave_like "A threaded connection pool"
-end
-
-describe "Threaded Sharded Connection Pool" do
-  before do
-    @invoked_count = 0
-    @icpp = proc{@invoked_count += 1}
-    @cp_opts = CONNECTION_POOL_DEFAULTS.merge(:max_connections=>5, :servers=>{})
-    @pool = Sequel::ConnectionPool.get_pool(mock_db.call(&@icpp), @cp_opts)
-  end
-
-  it_should_behave_like "A threaded connection pool"
-end
-
-describe "ConnectionPool#disconnect" do
-  before do
-    @count = 0
-    cp = proc{@count += 1}
-    @pool = Sequel::ConnectionPool.get_pool(mock_db.call{{:id => cp.call}}, CONNECTION_POOL_DEFAULTS.merge(:max_connections=>5, :servers=>{}))
-    threads = []
-    q, q1 = Queue.new, Queue.new
-    5.times {|i| threads << Thread.new {@pool.hold {|c| q1.push nil; q.pop}}}
-    5.times{q1.pop}
-    5.times{q.push nil}
-    threads.each {|t| t.join}
-  end
-  
-  specify "should invoke the given block for each available connection" do
-    @pool.size.should == 5
-    @pool.available_connections.size.should == 5
-    @pool.available_connections.each {|c| c[:id].should_not be_nil}
-    conns = []
-    meta_def(@pool.db, :disconnect_connection){|c| conns << c}
-    @pool.disconnect
-    conns.size.should == 5
-  end
-  
-  specify "should remove all available connections" do
-    @pool.size.should == 5
-    @pool.disconnect
-    @pool.size.should == 0
-  end
-
-  specify "should disconnect connections in use as soon as they are no longer in use" do
-    @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 = []
-      meta_def(@pool.db, :disconnect_connection){|c| conns << c}
-      @pool.disconnect
-      conns.size.should == 4
-      @pool.size.should == 1
-    end
-    @pool.size.should == 0
-  end
-end
-
-describe "A connection pool with multiple servers" do
-  before do
-    ic = @invoked_counts = Hash.new(0)
-    @pool = Sequel::ConnectionPool.get_pool(mock_db.call{|server| "#{server}#{ic[server] += 1}"}, CONNECTION_POOL_DEFAULTS.merge(:servers=>{:read_only=>{}}))
-  end
-  
-  specify "#all_connections should return connections for all servers" do
-    @pool.hold{}
-    @pool.all_connections{|c1| c1.should == "default1"}
-    a = []
-    @pool.hold(:read_only) do |c|
-      @pool.all_connections{|c1| a << c1}
-    end
-    a.sort_by{|c| c.to_s}.should == ["default1", "read_only1"]
-  end
-  
-  specify "#servers should return symbols for all servers" do
-    @pool.servers.sort_by{|s| s.to_s}.should == [:default, :read_only]
-  end
-
-  specify "should use the :default server by default" do
-    @pool.size.should == 0
-    @pool.hold do |c|
-      c.should == "default1"
-      @pool.allocated.should == {Thread.current=>"default1"}
-    end
-    @pool.available_connections.should == ["default1"]
-    @pool.size.should == 1
-    @invoked_counts.should == {:default=>1}
-  end
-  
-  specify "should use the :default server an invalid server is used" do
-    @pool.hold do |c1|
-      c1.should == "default1"
-      @pool.hold(:blah) do |c2|
-        c2.should == c1
-        @pool.hold(:blah2) do |c3|
-          c2.should == c3
-        end
-      end
-    end
-  end
-
-  specify "should support a :servers_hash option used for converting the server argument" do
-    ic = @invoked_counts
-    @pool = Sequel::ConnectionPool.get_pool(mock_db.call{|server| "#{server}#{ic[server] += 1}"}, CONNECTION_POOL_DEFAULTS.merge(:servers_hash=>Hash.new(:read_only), :servers=>{:read_only=>{}}))
-    @pool.hold(:blah) do |c1|
-      c1.should == "read_only1"
-      @pool.hold(:blah) do |c2|
-        c2.should == c1
-        @pool.hold(:blah2) do |c3|
-          c2.should == c3
-        end
-      end
-    end
-
-    @pool = Sequel::ConnectionPool.get_pool(mock_db.call{|server| "#{server}#{ic[server] += 1}"}, CONNECTION_POOL_DEFAULTS.merge(:servers_hash=>Hash.new{|h,k| raise Sequel::Error}, :servers=>{:read_only=>{}}))
-    proc{@pool.hold(:blah){|c1|}}.should raise_error(Sequel::Error)
-  end
-
-  specify "should use the requested server if server is given" do
-    @pool.size(:read_only).should == 0
-    @pool.hold(:read_only) do |c|
-      c.should == "read_only1"
-      @pool.allocated(:read_only).should == {Thread.current=>"read_only1"}
-    end
-    @pool.available_connections(:read_only).should == ["read_only1"]
-    @pool.size(:read_only).should == 1
-    @invoked_counts.should == {:read_only=>1}
-  end
-  
-  specify "#hold should only yield connections for the server requested" do
-    @pool.hold(:read_only) do |c|
-      c.should == "read_only1"
-      @pool.allocated(:read_only).should == {Thread.current=>"read_only1"}
-      @pool.hold do |d|
-        d.should == "default1"
-        @pool.hold do |e|
-          e.should == d
-          @pool.hold(:read_only){|b| b.should == c}
-        end
-        @pool.allocated.should == {Thread.current=>"default1"}
-      end
-    end
-    @invoked_counts.should == {:read_only=>1, :default=>1}
-  end
-  
-  specify "#disconnect should disconnect from all servers" do
-    @pool.hold(:read_only){}
-    @pool.hold{}
-    conns = []
-    @pool.size.should == 1
-    @pool.size(:read_only).should == 1
-    meta_def(@pool.db, :disconnect_connection){|c| conns << c}
-    @pool.disconnect
-    conns.sort.should == %w'default1 read_only1'
-    @pool.size.should == 0
-    @pool.size(:read_only).should == 0
-    @pool.hold(:read_only){|c| c.should == 'read_only2'}
-    @pool.hold{|c| c.should == 'default2'}
-  end
-  
-  specify "#add_servers should add new servers to the pool" do
-    pool = Sequel::ConnectionPool.get_pool(mock_db.call{|s| s}, :servers=>{:server1=>{}})
-    
-    pool.hold{}
-    pool.hold(:server2){}
-    pool.hold(:server3){}
-    pool.hold(:server1) do
-      pool.allocated.length.should == 0
-      pool.allocated(:server1).length.should == 1
-      pool.allocated(:server2).should == nil
-      pool.allocated(:server3).should == nil
-      pool.available_connections.length.should == 1
-      pool.available_connections(:server1).length.should == 0
-      pool.available_connections(:server2).should == nil
-      pool.available_connections(:server3).should == nil
-
-      pool.add_servers([:server2, :server3])
-      pool.hold(:server2){}
-      pool.hold(:server3) do 
-        pool.allocated.length.should == 0
-        pool.allocated(:server1).length.should == 1
-        pool.allocated(:server2).length.should == 0
-        pool.allocated(:server3).length.should == 1
-        pool.available_connections.length.should == 1
-        pool.available_connections(:server1).length.should == 0
-        pool.available_connections(:server2).length.should == 1
-        pool.available_connections(:server3).length.should == 0
-      end
-    end
-  end
-
-  specify "#add_servers should ignore existing keys" do
-    pool = Sequel::ConnectionPool.get_pool(mock_db.call{|s| s}, :servers=>{:server1=>{}})
-    
-    pool.allocated.length.should == 0
-    pool.allocated(:server1).length.should == 0
-    pool.available_connections.length.should == 0
-    pool.available_connections(:server1).length.should == 0
-    pool.hold do |c1| 
-      c1.should == :default
-      pool.allocated.length.should == 1
-      pool.allocated(:server1).length.should == 0
-      pool.available_connections.length.should == 0
-      pool.available_connections(:server1).length.should == 0
-      pool.hold(:server1) do |c2| 
-        c2.should == :server1
-        pool.allocated.length.should == 1
-        pool.allocated(:server1).length.should == 1
-        pool.available_connections.length.should == 0
-        pool.available_connections(:server1).length.should == 0
-        pool.add_servers([:default, :server1])
-        pool.allocated.length.should == 1
-        pool.allocated(:server1).length.should == 1
-        pool.available_connections.length.should == 0
-        pool.available_connections(:server1).length.should == 0
-      end
-      pool.allocated.length.should == 1
-      pool.allocated(:server1).length.should == 0
-      pool.available_connections.length.should == 0
-      pool.available_connections(:server1).length.should == 1
-      pool.add_servers([:default, :server1])
-      pool.allocated.length.should == 1
-      pool.allocated(:server1).length.should == 0
-      pool.available_connections.length.should == 0
-      pool.available_connections(:server1).length.should == 1
-    end
-    pool.allocated.length.should == 0
-    pool.allocated(:server1).length.should == 0
-    pool.available_connections.length.should == 1
-    pool.available_connections(:server1).length.should == 1
-    pool.add_servers([:default, :server1])
-    pool.allocated.length.should == 0
-    pool.allocated(:server1).length.should == 0
-    pool.available_connections.length.should == 1
-    pool.available_connections(:server1).length.should == 1
-  end
-  
-  specify "#remove_servers should disconnect available connections immediately" do
-    pool = Sequel::ConnectionPool.get_pool(mock_db.call{|s| s}, :max_connections=>5, :servers=>{:server1=>{}})
-    threads = []
-    q, q1 = Queue.new, Queue.new
-    5.times {|i| threads << Thread.new {pool.hold(:server1){|c| q1.push nil; q.pop}}}
-    5.times{q1.pop}
-    5.times{q.push nil}
-    threads.each {|t| t.join}
-    
-    pool.size(:server1).should == 5
-    pool.remove_servers([:server1])
-    pool.size(:server1).should == 0
-  end
-  
-  specify "#remove_servers should disconnect connections in use as soon as they are returned to the pool" do
-    dc = []
-    pool = Sequel::ConnectionPool.get_pool(mock_db.call(proc{|c| dc << c}){|c| c}, :servers=>{:server1=>{}})
-    c1 = nil
-    pool.hold(:server1) do |c|
-      pool.size(:server1).should == 1
-      dc.should == []
-      pool.remove_servers([:server1])
-      pool.size(:server1).should == 0
-      dc.should == []
-      c1 = c
-    end
-    pool.size(:server1).should == 0
-    dc.should == [c1]
-  end
-  
-  specify "#remove_servers should remove server related data structures immediately" do
-    pool = Sequel::ConnectionPool.get_pool(mock_db.call{|s| s}, :servers=>{:server1=>{}})
-    pool.available_connections(:server1).should == []
-    pool.allocated(:server1).should == {}
-    pool.remove_servers([:server1])
-    pool.available_connections(:server1).should == nil
-    pool.allocated(:server1).should == nil
-  end
-  
-  specify "#remove_servers should not allow the removal of the default server" do
-    pool = Sequel::ConnectionPool.get_pool(mock_db.call{|s| s}, :servers=>{:server1=>{}})
-    proc{pool.remove_servers([:server1])}.should_not raise_error
-    proc{pool.remove_servers([:default])}.should raise_error(Sequel::Error)
-  end
-  
-  specify "#remove_servers should ignore servers that have already been removed" do
-    dc = []
-    pool = Sequel::ConnectionPool.get_pool(mock_db.call(proc{|c| dc << c}){|c| c}, :servers=>{:server1=>{}})
-    c1 = nil
-    pool.hold(:server1) do |c|
-      pool.size(:server1).should == 1
-      dc.should == []
-      pool.remove_servers([:server1])
-      pool.remove_servers([:server1])
-      pool.size(:server1).should == 0
-      dc.should == []
-      c1 = c
-    end
-    pool.size(:server1).should == 0
-    dc.should == [c1]
-  end
-end
-
-ST_CONNECTION_POOL_DEFAULTS = CONNECTION_POOL_DEFAULTS.merge(:single_threaded=>true)
-
-describe "SingleConnectionPool" do
-  before do
-    @pool = Sequel::ConnectionPool.get_pool(mock_db.call{1234}, ST_CONNECTION_POOL_DEFAULTS)
-  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
-    conn = nil
-    x = nil
-    pool = Sequel::ConnectionPool.get_pool(mock_db.call(proc{|c| conn = c}){1234}, ST_CONNECTION_POOL_DEFAULTS)
-    pool.hold{|c| x = c}
-    x.should == 1234
-    pool.disconnect
-    conn.should == 1234
-  end
-end
-
-describe "A single threaded pool with multiple servers" do
-  before do
-    @max_size=2
-    msp = proc{@max_size += 1}
-    @pool = Sequel::ConnectionPool.get_pool(mock_db.call(proc{|c| msp.call}){|c| c}, ST_CONNECTION_POOL_DEFAULTS.merge(:servers=>{:read_only=>{}}))
-  end
-  
-  specify "#all_connections should return connections for all servers" do
-    @pool.hold{}
-    @pool.all_connections{|c1| c1.should == :default}
-    a = []
-    @pool.hold(:read_only) do
-      @pool.all_connections{|c1| a << c1}
-    end
-    a.sort_by{|c| c.to_s}.should == [:default, :read_only]
-  end
-  
-  specify "#servers should return symbols for all servers" do
-    @pool.servers.sort_by{|s| s.to_s}.should == [:default, :read_only]
-  end
-  
-  specify "#add_servers should add new servers to the pool" do
-    @pool.hold(:blah){|c| c.should == :default}
-    @pool.add_servers([:blah])
-    @pool.hold(:blah){|c| c.should == :blah}
-  end
-  
-  specify "#add_servers should ignore keys already existing" do
-    @pool.hold{|c| c.should == :default}
-    @pool.hold(:read_only){|c| c.should == :read_only}
-    @pool.add_servers([:default, :read_only])
-    @pool.conn.should == :default
-    @pool.conn(:read_only).should == :read_only
-  end
-  
-  specify "#remove_servers should remove servers from the pool" do
-    @pool.hold(:read_only){|c| c.should == :read_only}
-    @pool.remove_servers([:read_only])
-    @pool.hold(:read_only){|c| c.should == :default}
-  end
-  
-  specify "#remove_servers should not allow the removal of the default server" do
-    proc{@pool.remove_servers([:default])}.should raise_error(Sequel::Error)
-  end
-  
-  specify "#remove_servers should disconnect connection immediately" do
-    @pool.hold(:read_only){|c| c.should == :read_only}
-    @pool.conn(:read_only).should == :read_only
-    @pool.remove_servers([:read_only])
-    @pool.conn(:read_only).should == nil
-    @pool.hold{}
-    @pool.conn(:read_only).should == :default
-  end
-  
-  specify "#remove_servers should ignore keys that do not exist" do
-    proc{@pool.remove_servers([:blah])}.should_not raise_error
-  end
-  
-  specify "should use the :default server by default" do
-    @pool.hold{|c| c.should == :default}
-    @pool.conn.should == :default
-  end
-  
-  specify "should use the :default server an invalid server is used" do
-    @pool.hold do |c1|
-      c1.should == :default
-      @pool.hold(:blah) do |c2|
-        c2.should == c1
-        @pool.hold(:blah2) do |c3|
-          c2.should == c3
-        end
-      end
-    end
-  end
-
-  specify "should use the requested server if server is given" do
-    @pool.hold(:read_only){|c| c.should == :read_only}
-    @pool.conn(:read_only).should == :read_only
-  end
-  
-  specify "#hold should only yield connections for the server requested" do
-    @pool.hold(:read_only) do |c|
-      c.should == :read_only
-      @pool.hold do |d|
-        d.should == :default
-        @pool.hold do |e|
-          e.should == d
-          @pool.hold(:read_only){|b| b.should == c}
-        end
-      end
-    end
-    @pool.conn.should == :default
-    @pool.conn(:read_only).should == :read_only
-  end
-  
-  specify "#disconnect should disconnect from all servers" do
-    @pool.hold(:read_only){}
-    @pool.hold{}
-    @pool.conn.should == :default
-    @pool.conn(:read_only).should == :read_only
-    @pool.disconnect
-    @max_size.should == 4
-    @pool.conn.should == nil
-    @pool.conn(:read_only).should == nil
-  end
-
-  specify ":disconnection_proc option should set the disconnection proc to use" do
-    @max_size.should == 2
-    proc{@pool.hold{raise Sequel::DatabaseDisconnectError}}.should raise_error(Sequel::DatabaseDisconnectError)
-    @max_size.should == 3
-  end
-
-  specify "#hold should remove the connection if a DatabaseDisconnectError is raised" do
-    @pool.instance_variable_get(:@conns).length.should == 0
-    @pool.hold{}
-    @pool.instance_variable_get(:@conns).length.should == 1
-    proc{@pool.hold{raise Sequel::DatabaseDisconnectError}}.should raise_error(Sequel::DatabaseDisconnectError)
-    @pool.instance_variable_get(:@conns).length.should == 0
-  end
-end
-
-shared_examples_for "All connection pools classes" do
-  specify "should have pool_type return a symbol" do
-    @class.new(mock_db.call{123}, {}).pool_type.should be_a_kind_of(Symbol)
-  end
-
-  specify "should have all_connections yield current and available connections" do
-    p = @class.new(mock_db.call{123}, {})
-    p.hold{|c| p.all_connections{|c1| c.should == c1}}
-  end
-
-  specify "should be able to modify after_connect proc after the pool is created" do
-    a = []
-    p = @class.new(mock_db.call{123}, {})
-    p.after_connect = pr = proc{|c| a << c}
-    p.after_connect.should == pr
-    a.should == []
-    p.hold{}
-    a.should == [123]
-  end
-
-  specify "should not raise an error when disconnecting twice" do
-    c = @class.new(mock_db.call{123}, {})
-    proc{c.disconnect}.should_not raise_error
-    proc{c.disconnect}.should_not raise_error
-  end
-  
-  specify "should yield a connection created by the initialize block to hold" do
-    x = nil
-    @class.new(mock_db.call{123}, {}).hold{|c| x = c}
-    x.should == 123
-  end
-  
-  specify "should have the initialize block accept a shard/server argument" do
-    x = nil
-    @class.new(mock_db.call{|c| [c, c]}, {}).hold{|c| x = c}
-    x.should == [:default, :default]
-  end
-  
-  specify "should have respect an :after_connect proc that is called with each newly created connection" do
-    x = nil
-    @class.new(mock_db.call{123}, :after_connect=>proc{|c| x = [c, c]}).hold{}
-    x.should == [123, 123]
-    @class.new(mock_db.call{123}, :after_connect=>lambda{|c| x = [c, c]}).hold{}
-    x.should == [123, 123]
-    @class.new(mock_db.call{123}, :after_connect=>proc{|c, s| x = [c, s]}).hold{}
-    x.should == [123, :default]
-    @class.new(mock_db.call{123}, :after_connect=>lambda{|c, s| x = [c, s]}).hold{}
-    x.should == [123, :default]
-  end
-  
-  specify "should raise a DatabaseConnectionError if the connection raises an exception" do
-    proc{@class.new(mock_db.call{|c| raise Exception}, {}).hold{}}.should raise_error(Sequel::DatabaseConnectionError)
-  end
-  
-  specify "should raise a DatabaseConnectionError if the initialize block returns nil" do
-    proc{@class.new(mock_db.call{}, {}).hold{}}.should raise_error(Sequel::DatabaseConnectionError)
-  end
-  
-  specify "should call the disconnection_proc option if the hold block raises a DatabaseDisconnectError" do
-    x = nil
-    proc{@class.new(mock_db.call(proc{|c| x = c}){123}).hold{raise Sequel::DatabaseDisconnectError}}.should raise_error(Sequel::DatabaseDisconnectError)
-    x.should == 123
-  end
-  
-  specify "should have a disconnect method that disconnects the connection" do
-    x = nil
-    c = @class.new(mock_db.call(proc{|c1| x = c1}){123})
-    c.hold{}
-    x.should == nil
-    c.disconnect
-    x.should == 123
-  end
-  
-  specify "should have a reentrent hold method" do
-    o = Object.new
-    c = @class.new(mock_db.call{o}, {})
-    c.hold do |x|
-      x.should == o
-      c.hold do |x1|
-        x1.should == o
-        c.hold do |x2|
-          x2.should == o
-        end
-      end
-    end
-  end
-  
-  specify "should have a servers method that returns an array of shard/server symbols" do
-    @class.new(mock_db.call{123}, {}).servers.should == [:default]
-  end
-  
-  specify "should have a servers method that returns an array of shard/server symbols" do
-    c = @class.new(mock_db.call{123}, {})
-    c.size.should == 0
-    c.hold{}
-    c.size.should == 1
-  end
-end
-
-Sequel::ConnectionPool::CONNECTION_POOL_MAP.keys.each do |k, v|
-  opts = {:single_threaded=>k, :servers=>(v ? {} : nil)}
-  describe "Connection pool with #{opts.inspect}" do
-    before(:all) do
-      Sequel::ConnectionPool.send(:get_pool, mock_db.call, opts)
-    end
-    before do
-      @class = Sequel::ConnectionPool.send(:connection_pool_class, opts)
-    end
-    it_should_behave_like "All connection pools classes"
-  end
-end