sequel 3.8.0 → 3.9.0

data/spec/adapters/spec_helper.rb

@@ -1,4 +1,5 @@
 require 'rubygems'
+require 'logger'
 unless Object.const_defined?('Sequel')
   $:.unshift(File.join(File.dirname(__FILE__), "../../lib/"))
   require 'sequel'
@@ -10,6 +11,19 @@ rescue LoadError
 end
 
 class Spec::Example::ExampleGroup
+  def log 
+    begin
+      INTEGRATION_DB.loggers << Logger.new(STDOUT)
+      yield
+    ensure
+     INTEGRATION_DB.loggers.pop
+    end 
+  end 
+
+  def self.log_specify(message, &block)
+    specify(message){log{instance_eval(&block)}}
+  end
+
   def self.cspecify(message, *checked, &block)
     pending = false
     checked.each do |c|
@@ -28,4 +42,4 @@ class Spec::Example::ExampleGroup
       specify(message, &block)
     end
   end
-end
+end

data/spec/core/connection_pool_spec.rb

@@ -1,10 +1,9 @@
 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}
+CONNECTION_POOL_DEFAULTS = {:pool_timeout=>5, :pool_sleep_time=>0.001, :max_connections=>4}
 
 context "An empty ConnectionPool" do
   before do
-    @cpool = Sequel::ConnectionPool.new(CONNECTION_POOL_DEFAULTS)
+    @cpool = Sequel::ConnectionPool.get_pool(CONNECTION_POOL_DEFAULTS){}
   end
 
   specify "should have no available connections" do
@@ -22,24 +21,24 @@ end
 
 context "ConnectionPool options" do
   specify "should support string option values" do
-    cpool = Sequel::ConnectionPool.new({:max_connections=>'5', :pool_timeout=>'3', :pool_sleep_time=>'0.01'})
+    cpool = Sequel::ConnectionPool.get_pool({: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.new(:max_connections=>0)}.should raise_error(Sequel::Error)
-    lambda{Sequel::ConnectionPool.new(:max_connections=>-10)}.should raise_error(Sequel::Error)
-    lambda{Sequel::ConnectionPool.new(:max_connections=>'-10')}.should raise_error(Sequel::Error)
-    lambda{Sequel::ConnectionPool.new(:max_connections=>'0')}.should raise_error(Sequel::Error)
+    lambda{Sequel::ConnectionPool.get_pool(:max_connections=>0)}.should raise_error(Sequel::Error)
+    lambda{Sequel::ConnectionPool.get_pool(:max_connections=>-10)}.should raise_error(Sequel::Error)
+    lambda{Sequel::ConnectionPool.get_pool(:max_connections=>'-10')}.should raise_error(Sequel::Error)
+    lambda{Sequel::ConnectionPool.get_pool(:max_connections=>'0')}.should raise_error(Sequel::Error)
   end
 end
 
 context "A connection pool handling connections" do
   before do
     @max_size = 2
-    @cpool = Sequel::ConnectionPool.new(CONNECTION_POOL_DEFAULTS.merge(:disconnection_proc=>proc{|c| @max_size=3},  :max_connections=>@max_size)) {:got_connection}
+    @cpool = Sequel::ConnectionPool.get_pool(CONNECTION_POOL_DEFAULTS.merge(:disconnection_proc=>proc{|c| @max_size=3},  :max_connections=>@max_size)) {:got_connection}
   end
 
   specify "#hold should increment #created_count" do
@@ -95,13 +94,6 @@ context "A connection pool handling connections" do
     @max_size.should == 3
   end
 
-  specify "#disconnection_proc= should set the disconnection proc to use" do
-    a = 1
-    @cpool.disconnection_proc = proc{|c| a += 1}
-    proc{@cpool.hold{raise Sequel::DatabaseDisconnectError}}.should raise_error(Sequel::DatabaseDisconnectError)
-    a.should == 2
-  end
-
   specify "#hold should remove the connection if a DatabaseDisconnectError is raised" do
     @cpool.created_count.should == 0
     @cpool.hold{Thread.new{@cpool.hold{}}; sleep 0.01}
@@ -117,13 +109,13 @@ end
 
 context "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.new(CONNECTION_POOL_DEFAULTS){raise Interrupt}
+    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.new(CONNECTION_POOL_DEFAULTS){nil}
+    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
@@ -142,7 +134,7 @@ end
 
 context "ConnectionPool#hold" do
   before do
-    @pool = Sequel::ConnectionPool.new(CONNECTION_POOL_DEFAULTS) {DummyConnection.new}
+    @pool = Sequel::ConnectionPool.get_pool(CONNECTION_POOL_DEFAULTS) {DummyConnection.new}
   end
   
   specify "should pass the result of the connection maker proc to the supplied block" do
@@ -164,40 +156,12 @@ context "ConnectionPool#hold" do
   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
-  before 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
   before do
     @invoked_count = 0
-    @pool = Sequel::ConnectionPool.new(CONNECTION_POOL_DEFAULTS.merge(:max_connections=>1)) {@invoked_count += 1; 'herro'}
+    @pool = Sequel::ConnectionPool.get_pool(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
@@ -270,12 +234,7 @@ context "A connection pool with a max size of 1" do
   end
 end
 
-context "A connection pool with a max size of 5" do
-  before do
-    @invoked_count = 0
-    @pool = Sequel::ConnectionPool.new(CONNECTION_POOL_DEFAULTS.merge(:max_connections=>5)) {@invoked_count += 1}
-  end
-  
+shared_examples_for "A threaded connection pool" do  
   specify "should let five threads simultaneously access separate connections" do
     cc = {}
     threads = []
@@ -342,10 +301,28 @@ context "A connection pool with a max size of 5" do
   end
 end
 
+context "Threaded Unsharded Connection Pool" do
+  before do
+    @invoked_count = 0
+    @pool = Sequel::ConnectionPool.get_pool(CONNECTION_POOL_DEFAULTS.merge(:max_connections=>5)) {@invoked_count += 1}
+  end
+  
+  it_should_behave_like "A threaded connection pool"
+end
+
+context "Threaded Sharded Connection Pool" do
+  before do
+    @invoked_count = 0
+    @pool = Sequel::ConnectionPool.get_pool(CONNECTION_POOL_DEFAULTS.merge(:max_connections=>5, :servers=>{})) {@invoked_count += 1}
+  end
+  
+  it_should_behave_like "A threaded connection pool"
+end
+
 context "ConnectionPool#disconnect" do
   before do
     @count = 0
-    @pool = Sequel::ConnectionPool.new(CONNECTION_POOL_DEFAULTS.merge(:max_connections=>5)) {{:id => @count += 1}}
+    @pool = Sequel::ConnectionPool.get_pool(CONNECTION_POOL_DEFAULTS.merge(:max_connections=>5, :servers=>{})) {{:id => @count += 1}}
   end
   
   specify "should invoke the given block for each available connection" do
@@ -411,7 +388,7 @@ end
 context "A connection pool with multiple servers" do
   before do
     @invoked_counts = Hash.new(0)
-    @pool = Sequel::ConnectionPool.new(CONNECTION_POOL_DEFAULTS.merge(:servers=>{:read_only=>{}})){|server| "#{server}#{@invoked_counts[server] += 1}"}
+    @pool = Sequel::ConnectionPool.get_pool(CONNECTION_POOL_DEFAULTS.merge(:servers=>{:read_only=>{}})){|server| "#{server}#{@invoked_counts[server] += 1}"}
   end
   
   specify "#servers should return symbols for all servers" do
@@ -483,7 +460,7 @@ context "A connection pool with multiple servers" do
   end
   
   specify "#add_servers should add new servers to the pool" do
-    pool = Sequel::ConnectionPool.new(:servers=>{:server1=>{}}){|s| s}
+    pool = Sequel::ConnectionPool.get_pool(:servers=>{:server1=>{}}){|s| s}
     
     pool.hold{}
     pool.hold(:server2){}
@@ -514,7 +491,7 @@ context "A connection pool with multiple servers" do
   end
 
   specify "#add_servers should ignore existing keys" do
-    pool = Sequel::ConnectionPool.new(:servers=>{:server1=>{}}){|s| s}
+    pool = Sequel::ConnectionPool.get_pool(:servers=>{:server1=>{}}){|s| s}
     
     pool.allocated.length.should == 0
     pool.allocated(:server1).length.should == 0
@@ -560,7 +537,7 @@ context "A connection pool with multiple servers" do
   end
   
   specify "#remove_servers should disconnect available connections immediately" do
-    pool = Sequel::ConnectionPool.new(:max_connections=>5, :servers=>{:server1=>{}}){|s| s}
+    pool = Sequel::ConnectionPool.get_pool(:max_connections=>5, :servers=>{:server1=>{}}){|s| s}
     threads = []
     stop = nil
     5.times {|i| threads << Thread.new{pool.hold(:server1){|c| sleep 0.05}}}
@@ -574,7 +551,7 @@ context "A connection pool with multiple servers" do
   
   specify "#remove_servers should disconnect connections in use as soon as they are returned to the pool" do
     dc = []
-    pool = Sequel::ConnectionPool.new(:servers=>{:server1=>{}}, :disconnection_proc=>proc{|c| dc << c}){|s| s}
+    pool = Sequel::ConnectionPool.get_pool(:servers=>{:server1=>{}}, :disconnection_proc=>proc{|c| dc << c}){|s| s}
     c1 = nil
     pool.hold(:server1) do |c|
       pool.size(:server1).should == 1
@@ -589,7 +566,7 @@ context "A connection pool with multiple servers" do
   end
   
   specify "#remove_servers should remove server related data structures immediately" do
-    pool = Sequel::ConnectionPool.new(:servers=>{:server1=>{}}){|s| s}
+    pool = Sequel::ConnectionPool.get_pool(:servers=>{:server1=>{}}){|s| s}
     pool.available_connections(:server1).should == []
     pool.allocated(:server1).should == {}
     pool.remove_servers([:server1])
@@ -598,14 +575,14 @@ context "A connection pool with multiple servers" do
   end
   
   specify "#remove_servers should not allow the removal of the default server" do
-    pool = Sequel::ConnectionPool.new(:servers=>{:server1=>{}}){|s| s}
+    pool = Sequel::ConnectionPool.get_pool(:servers=>{:server1=>{}}){|s| s}
     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.new(:servers=>{:server1=>{}}, :disconnection_proc=>proc{|c| dc << c}){|s| s}
+    pool = Sequel::ConnectionPool.get_pool(:servers=>{:server1=>{}}, :disconnection_proc=>proc{|c| dc << c}){|s| s}
     c1 = nil
     pool.hold(:server1) do |c|
       pool.size(:server1).should == 1
@@ -621,31 +598,34 @@ context "A connection pool with multiple servers" do
   end
 end
 
-context "SingleThreadedPool" do
+ST_CONNECTION_POOL_DEFAULTS = CONNECTION_POOL_DEFAULTS.merge(:single_threaded=>true)
+
+context "SingleConnectionPool" do
   before do
-    @pool = Sequel::SingleThreadedPool.new(CONNECTION_POOL_DEFAULTS){1234}
+    @pool = Sequel::ConnectionPool.get_pool(ST_CONNECTION_POOL_DEFAULTS){1234}
   end
   
   specify "should provide a #hold method" do
     conn = nil
-    @pool.hold {|c| conn = c}
+    @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}
+    x = nil
+    pool = Sequel::ConnectionPool.get_pool(ST_CONNECTION_POOL_DEFAULTS.merge(:disconnection_proc=>proc{|c| conn = c})){1234}
+    pool.hold{|c| x = c}
+    x.should == 1234
+    pool.disconnect
     conn.should == 1234
-    @pool.conn.should be_nil
   end
 end
 
 context "A single threaded pool with multiple servers" do
   before do
     @max_size=2
-    @pool = Sequel::SingleThreadedPool.new(CONNECTION_POOL_DEFAULTS.merge(:disconnection_proc=>proc{|c| @max_size=3}, :servers=>{:read_only=>{}})){|server| server}
+    @pool = Sequel::ConnectionPool.get_pool(ST_CONNECTION_POOL_DEFAULTS.merge(:disconnection_proc=>proc{|c| @max_size=3}, :servers=>{:read_only=>{}})){|server| server}
   end
   
   specify "#servers should return symbols for all servers" do
@@ -744,13 +724,6 @@ context "A single threaded pool with multiple servers" do
     @max_size.should == 3
   end
 
-  specify "#disconnection_proc= should set the disconnection proc to use" do
-    a = 1
-    @pool.disconnection_proc = proc{|c| a += 1}
-    proc{@pool.hold{raise Sequel::DatabaseDisconnectError}}.should raise_error(Sequel::DatabaseDisconnectError)
-    a.should == 2
-  end
-
   specify "#hold should remove the connection if a DatabaseDisconnectError is raised" do
     @pool.instance_variable_get(:@conns).length.should == 0
     @pool.hold{}
@@ -759,3 +732,71 @@ context "A single threaded pool with multiple servers" do
     @pool.instance_variable_get(:@conns).length.should == 0
   end
 end
+
+shared_examples_for "All connection pools classes" do
+  specify "should yield a connection created by the initialize block to hold" do
+    x = nil
+    @class.new({}){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({}){|c| [c, c]}.hold{|c| x = c}
+    x.should == [:default, :default]
+  end
+  
+  specify "should raise a DatabaseConnectionError if the connection raises an exception" do
+    proc{@class.new({}){|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({}){}.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(:disconnection_proc=>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 calls the :disconnection_proc option with the connection" do
+    x = nil
+    c = @class.new(:disconnection_proc=>proc{|c| x = c}){123}
+    c.hold{}
+    x.should == nil
+    c.disconnect
+    x.should == 123
+  end
+  
+  specify "should have a disconnect method that calls the given block with the connection" do
+    x = nil
+    y = nil
+    c = @class.new(:disconnection_proc=>proc{|c| x = c}){123}
+    c.hold{}
+    c.disconnect{|c| y = c}
+    x.should == nil
+    y.should == 123
+  end
+  
+  specify "should have a servers method that returns an array of shard/server symbols" do
+    @class.new({}){123}.servers.should == [:default]
+  end
+  
+  specify "should have a servers method that returns an array of shard/server symbols" do
+    c = @class.new({}){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 do
+      @class = Sequel::ConnectionPool.send(:connection_pool_class, opts)
+    end
+    it_should_behave_like "All connection pools classes"
+  end
+end

data/spec/core/database_spec.rb

@@ -11,7 +11,8 @@ context "A new Database" do
   end
   
   specify "should receive options" do
-    @db.opts.should == {1 => 2, :logger => 3}  
+    @db.opts[1].should == 2
+    @db.opts[:logger].should == 3  
   end
   
   specify "should set the logger from opts[:logger] and opts[:loggers]" do
@@ -37,17 +38,17 @@ context "A new Database" do
   end
 
   specify "should respect the :single_threaded option" do
-    db = Sequel::Database.new(:single_threaded=>true)
-    db.pool.should be_a_kind_of(Sequel::SingleThreadedPool)
-    db = Sequel::Database.new(:single_threaded=>'t')
-    db.pool.should be_a_kind_of(Sequel::SingleThreadedPool)
-    db = Sequel::Database.new(:single_threaded=>'1')
-    db.pool.should be_a_kind_of(Sequel::SingleThreadedPool)
-    db = Sequel::Database.new(:single_threaded=>false)
+    db = Sequel::Database.new(:single_threaded=>true){123}
+    db.pool.should be_a_kind_of(Sequel::SingleConnectionPool)
+    db = Sequel::Database.new(:single_threaded=>'t'){123}
+    db.pool.should be_a_kind_of(Sequel::SingleConnectionPool)
+    db = Sequel::Database.new(:single_threaded=>'1'){123}
+    db.pool.should be_a_kind_of(Sequel::SingleConnectionPool)
+    db = Sequel::Database.new(:single_threaded=>false){123}
     db.pool.should be_a_kind_of(Sequel::ConnectionPool)
-    db = Sequel::Database.new(:single_threaded=>'f')
+    db = Sequel::Database.new(:single_threaded=>'f'){123}
     db.pool.should be_a_kind_of(Sequel::ConnectionPool)
-    db = Sequel::Database.new(:single_threaded=>'0')
+    db = Sequel::Database.new(:single_threaded=>'0'){123}
     db.pool.should be_a_kind_of(Sequel::ConnectionPool)
   end
 
@@ -204,7 +205,7 @@ end
 
 context "Database#connect" do
   specify "should raise NotImplementedError" do
-    proc {Sequel::Database.new.connect}.should raise_error(NotImplementedError)
+    proc {Sequel::Database.new.connect(:default)}.should raise_error(NotImplementedError)
   end
 end
 
@@ -315,8 +316,7 @@ end
 
 context "Database#synchronize" do
   before do
-    @db = Sequel::Database.new(:max_connections => 1)
-    @db.pool.connection_proc = proc {12345}
+    @db = Sequel::Database.new(:max_connections => 1){12345}
   end
   
   specify "should wrap the supplied block in pool.hold" do
@@ -339,9 +339,7 @@ end
 
 context "Database#test_connection" do
   before do
-    @db = Sequel::Database.new
-    @test = nil
-    @db.pool.connection_proc = proc {@test = rand(100)}
+    @db = Sequel::Database.new{@test = rand(100)}
   end
   
   specify "should call pool#hold" do
@@ -593,8 +591,7 @@ end
 
 context "Database#transaction" do
   before do
-    @db = Dummy3Database.new
-    @db.pool.connection_proc = proc {Dummy3Database::DummyConnection.new(@db)}
+    @db = Dummy3Database.new{Dummy3Database::DummyConnection.new(@db)}
   end
   
   specify "should wrap the supplied block with BEGIN + COMMIT statements" do
@@ -659,9 +656,8 @@ end
 
 context "Database#transaction with savepoints" do
   before do
-    @db = Dummy3Database.new
+    @db = Dummy3Database.new{Dummy3Database::DummyConnection.new(@db)}
     @db.meta_def(:supports_savepoints?){true}
-    @db.pool.connection_proc = proc {Dummy3Database::DummyConnection.new(@db)}
   end
   
   specify "should wrap the supplied block with BEGIN + COMMIT statements" do
@@ -825,26 +821,27 @@ context "A Database adapter with a scheme" do
     proc {Sequel.ccc('abc', 'def')}.should raise_error(Sequel::Error)
     
     c = Sequel.ccc('mydb')
+    p = proc{c.opts.delete_if{|k,v| k == :disconnection_proc || k == :single_threaded}}
     c.should be_a_kind_of(CCC)
-    c.opts.should == {:adapter=>:ccc, :database => 'mydb'}
+    p.call.should == {:adapter=>:ccc, :database => 'mydb'}
     
     c = Sequel.ccc('mydb', :host => 'localhost')
     c.should be_a_kind_of(CCC)
-    c.opts.should == {:adapter=>:ccc, :database => 'mydb', :host => 'localhost'}
+    p.call.should == {:adapter=>:ccc, :database => 'mydb', :host => 'localhost'}
     
     c = Sequel.ccc
     c.should be_a_kind_of(CCC)
-    c.opts.should == {:adapter=>:ccc}
+    p.call.should == {:adapter=>:ccc}
     
     c = Sequel.ccc(:database => 'mydb', :host => 'localhost')
     c.should be_a_kind_of(CCC)
-    c.opts.should == {:adapter=>:ccc, :database => 'mydb', :host => 'localhost'}
+    p.call.should == {:adapter=>:ccc, :database => 'mydb', :host => 'localhost'}
   end
   
   specify "should be accessible through Sequel.connect with options" do
     c = Sequel.connect(:adapter => :ccc, :database => 'mydb')
     c.should be_a_kind_of(CCC)
-    c.opts.should == {:adapter => :ccc, :database => 'mydb'}
+    c.opts[:adapter].should == :ccc
   end
 
   specify "should be accessible through Sequel.connect with URL parameters" do
@@ -915,26 +912,26 @@ context "A single threaded database" do
     Sequel::Database.single_threaded = false
   end
   
-  specify "should use a SingleThreadedPool instead of a ConnectionPool" do
-    db = Sequel::Database.new(:single_threaded => true)
-    db.pool.should be_a_kind_of(Sequel::SingleThreadedPool)
+  specify "should use a SingleConnectionPool instead of a ConnectionPool" do
+    db = Sequel::Database.new(:single_threaded => true){123}
+    db.pool.should be_a_kind_of(Sequel::SingleConnectionPool)
   end
   
   specify "should be constructable using :single_threaded => true option" do
-    db = Sequel::Database.new(:single_threaded => true)
-    db.pool.should be_a_kind_of(Sequel::SingleThreadedPool)
+    db = Sequel::Database.new(:single_threaded => true){123}
+    db.pool.should be_a_kind_of(Sequel::SingleConnectionPool)
   end
   
   specify "should be constructable using Database.single_threaded = true" do
     Sequel::Database.single_threaded = true
-    db = Sequel::Database.new
-    db.pool.should be_a_kind_of(Sequel::SingleThreadedPool)
+    db = Sequel::Database.new{123}
+    db.pool.should be_a_kind_of(Sequel::SingleConnectionPool)
   end
 
   specify "should be constructable using Sequel.single_threaded = true" do
     Sequel.single_threaded = true
-    db = Sequel::Database.new
-    db.pool.should be_a_kind_of(Sequel::SingleThreadedPool)
+    db = Sequel::Database.new{123}
+    db.pool.should be_a_kind_of(Sequel::SingleConnectionPool)
   end
 end
 
@@ -956,26 +953,20 @@ context "A single threaded database" do
     def @db.dc; @dc end
     x = nil
     @db.pool.hold{|c| x = c}
-    @db.pool.conn.should == x
+    @db.pool.hold{|c| c.should == x}
     proc{@db.disconnect}.should_not raise_error
-    @db.pool.conn.should == nil
     @db.dc.should == x
   end
   
   specify "should convert an Exception on connection into a DatabaseConnectionError" do
-    db = Sequel::Database.new(:single_threaded => true){raise Exception}
+    db = Sequel::Database.new(:single_threaded => true, :servers=>{}){raise Exception}
     proc {db.pool.hold {|c|}}.should raise_error(Sequel::DatabaseConnectionError)
   end
   
   specify "should raise a DatabaseConnectionError if the connection proc returns nil" do
-    db = Sequel::Database.new(:single_threaded => true){nil}
+    db = Sequel::Database.new(:single_threaded => true, :servers=>{}){nil}
     proc {db.pool.hold {|c|}}.should raise_error(Sequel::DatabaseConnectionError)
   end
-  
-  specify "should convert an Exceptions during use into RuntimeErrors" do
-    db = Sequel::Database.new(:single_threaded => true){Object.new}
-    proc {db.synchronize{raise Exception}}.should raise_error(RuntimeError)
-  end
 end
 
 context "A database" do
@@ -988,7 +979,7 @@ context "A database" do
   end
   
   specify "should have single_threaded? respond to true if in single threaded mode" do
-    db = Sequel::Database.new(:single_threaded => true)
+    db = Sequel::Database.new(:single_threaded => true){1234}
     db.should be_single_threaded
     
     db = Sequel::Database.new(:max_options => 1)
@@ -999,10 +990,10 @@ context "A database" do
     
     Sequel::Database.single_threaded = true
     
-    db = Sequel::Database.new
+    db = Sequel::Database.new{123}
     db.should be_single_threaded
     
-    db = Sequel::Database.new(:max_options => 4)
+    db = Sequel::Database.new(:max_options => 4){123}
     db.should be_single_threaded
   end
   
@@ -1226,22 +1217,22 @@ end
 context "Database#server_opts" do
   specify "should return the general opts if no :servers option is used" do
     opts = {:host=>1, :database=>2}
-    MockDatabase.new(opts).send(:server_opts, :server1).should == {:host=>1, :database=>2}
+    MockDatabase.new(opts).send(:server_opts, :server1)[:host].should == 1
   end
   
   specify "should return the general opts if entry for the server is present in the :servers option" do
     opts = {:host=>1, :database=>2, :servers=>{}}
-    MockDatabase.new(opts).send(:server_opts, :server1).should == {:host=>1, :database=>2}
+    MockDatabase.new(opts).send(:server_opts, :server1)[:host].should == 1
   end
   
   specify "should return the general opts merged with the specific opts if given as a hash" do
     opts = {:host=>1, :database=>2, :servers=>{:server1=>{:host=>3}}}
-    MockDatabase.new(opts).send(:server_opts, :server1).should == {:host=>3, :database=>2}
+    MockDatabase.new(opts).send(:server_opts, :server1)[:host].should == 3
   end
   
   specify "should return the sgeneral opts merged with the specific opts if given as a proc" do
     opts = {:host=>1, :database=>2, :servers=>{:server1=>proc{|db| {:host=>4}}}}
-    MockDatabase.new(opts).send(:server_opts, :server1).should == {:host=>4, :database=>2}
+    MockDatabase.new(opts).send(:server_opts, :server1)[:host].should == 4
   end
   
   specify "should raise an error if the specific opts is not a proc or hash" do