sequel 4.22.0 → 4.23.0

data/spec/bin_spec.rb

@@ -26,7 +26,7 @@ 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")
+require 'minitest/autorun'
 
 describe "bin/sequel" do
   def bin(opts={})
@@ -41,22 +41,20 @@ describe "bin/sequel" do
     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 /
+    help.must_match(/\ASequel: The Database Toolkit for Ruby/)
+    help.must_match(/^Usage: sequel /)
   end
 
   it "-c should run code" do
-    bin(:args=>'-c "print DB.tables.inspect"').should == '[]'
+    bin(:args=>'-c "print DB.tables.inspect"').must_equal '[]'
     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]"
+    bin(:args=>'-c "print DB.tables.inspect"').must_equal '[:a]'
+    bin(:args=>'-v -c "print DB.tables.inspect"').strip.must_equal "sequel #{Sequel.version}\n[:a]"
   end
 
   it "-C should copy databases" do
@@ -70,7 +68,7 @@ describe "bin/sequel" do
     end
     DB[:a].insert(1, 'foo')
     DB[:b].insert(1)
-    bin(:args=>'-C', :post=>"#{CONN_PREFIX}#{BIN_SPEC_DB2}").should =~ Regexp.new(<<END)
+    bin(:args=>'-C', :post=>"#{CONN_PREFIX}#{BIN_SPEC_DB2}").must_match Regexp.new(<<END)
 Databases connections successful
 Migrations dumped successfully
 Tables created
@@ -86,15 +84,15 @@ 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}]
+    DB2.tables.sort_by{|t| t.to_s}.must_equal [:a, :b]
+    DB[:a].all.must_equal [{:a=>1, :name=>'foo'}]
+    DB[:b].all.must_equal [{:a=>1}]
+    DB2.schema(:a).map{|col, sch| [col, *sch.values_at(:allow_null, :default, :primary_key, :db_type, :type, :ruby_default)]}.must_equal [[: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)]}.must_equal [[:a, true, nil, false, "integer", :integer, nil]]
+    DB2.indexes(:a).must_equal({})
+    DB2.indexes(:b).must_equal(:b_a_index=>{:unique=>false, :columns=>[:a]})
+    DB2.foreign_key_list(:a).must_equal []
+    DB2.foreign_key_list(:b).must_equal [{: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
@@ -106,7 +104,7 @@ END
       foreign_key :a, :a
       index :a
     end
-    bin(:args=>'-d').should == <<END
+    bin(:args=>'-d').must_equal <<END
 Sequel.migration do
   change do
     create_table(:a) do
@@ -122,7 +120,7 @@ Sequel.migration do
   end
 end
 END
-    bin(:args=>'-D').should == <<END
+    bin(:args=>'-D').must_equal <<END
 Sequel.migration do
   change do
     create_table(:a) do
@@ -141,79 +139,79 @@ 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}
+    bin(:args=>'-E -c DB.tables').must_match %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"
+    bin(:args=>'-Ifoo -c "p 1 if $:.include?(\'foo\')"').must_equal "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}
+    bin(:args=>"-l #{TMP_FILE} -c DB.tables").must_equal ''
+    File.read(TMP_FILE).must_match %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"
+    bin(:args=>'-L ./lib/sequel/connection_pool -c "p [Sequel::SingleConnectionPool, Sequel::ThreadedConnectionPool, Sequel::ShardedSingleConnectionPool, Sequel::ShardedThreadedConnectionPool].length"').must_equal "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]
+    bin(:args=>"-m spec/files/integer_migrations").must_equal ''
+    DB.tables.sort_by{|t| t.to_s}.must_equal [: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]
+    bin(:args=>"-m spec/files/integer_migrations -M 2").must_equal ''
+    DB.tables.sort_by{|t| t.to_s}.must_equal [: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: /
+    bin(:no_conn=>true, :args=>"-c '' -N #{CONN_PREFIX}spec/nonexistent/foo").must_equal ''
+    bin(:no_conn=>true, :args=>"-c '' #{CONN_PREFIX}spec/nonexistent/foo", :stderr=>true).must_match(/\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"
+    bin(:args=>'-rsequel/extensions/sql_expr -c "print DB.literal(1.sql_expr)"').must_equal "1"
   end
 
   it "-S should dump the schema cache" do
-    bin(:args=>"-S #{TMP_FILE}").should == ''
-    Marshal.load(File.read(TMP_FILE)).should == {}
+    bin(:args=>"-S #{TMP_FILE}").must_equal ''
+    Marshal.load(File.read(TMP_FILE)).must_equal({})
     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}]]}
+    bin(:args=>"-S #{TMP_FILE}").must_equal ''
+    Marshal.load(File.read(TMP_FILE)).must_equal("`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
+    bin(:args=>'-c "lambda{lambda{lambda{raise \'foo\'}.call}.call}.call"', :stderr=>true).count("\n").must_be :<,  3
+    bin(:args=>'-t -c "lambda{lambda{lambda{raise \'foo\'}.call}.call}.call"', :stderr=>true).count("\n").must_be :>,  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"
+    bin(:args=>"-v", :no_conn=>true).strip.must_equal "sequel #{Sequel.version}"
   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"
+    bin(:args=>'-M 2', :stderr=>true).must_equal "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"
+    bin(:args=>'-c foo -d', :stderr=>true).must_equal "Error: Cannot specify -c and -d together\n"
+    bin(:args=>'-D -d', :stderr=>true).must_equal "Error: Cannot specify -D and -d together\n"
+    bin(:args=>'-m foo -d', :stderr=>true).must_equal "Error: Cannot specify -m and -d together\n"
+    bin(:args=>'-S foo -d', :stderr=>true).must_equal "Error: Cannot specify -S and -d together\n"
+    bin(:args=>'-S foo -C', :stderr=>true).must_equal "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"
+    bin(:args=>'-c "print DB.adapter_scheme"', :no_conn=>true).must_equal "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 == "[]"
+    bin(:args=>"-c \"print DB.tables.inspect\" #{TMP_FILE}", :no_conn=>true).must_equal "[]"
     DB.create_table(:a){Integer :a}
-    bin(:args=>"-c \"print DB.tables.inspect\" #{TMP_FILE}", :no_conn=>true).should == "[:a]"
+    bin(:args=>"-c \"print DB.tables.inspect\" #{TMP_FILE}", :no_conn=>true).must_equal "[:a]"
   end
 
   it "should work with a yaml config file with string keys" do
@@ -221,36 +219,36 @@ END
     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]"
+    bin(:args=>"-c \"print DB.tables.inspect\" #{TMP_FILE}", :no_conn=>true).must_equal "[: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 == "[]"
+    bin(:args=>"-c \"print DB.tables.inspect\" #{TMP_FILE}", :no_conn=>true).must_equal "[]"
     DB.create_table(:a){Integer :a}
-    bin(:args=>"-c \"print DB.tables.inspect\" #{TMP_FILE}", :no_conn=>true).should == "[:a]"
+    bin(:args=>"-c \"print DB.tables.inspect\" #{TMP_FILE}", :no_conn=>true).must_equal "[: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 == "[]"
+    bin(:args=>"-c \"print DB.tables.inspect\" -e foo #{TMP_FILE}", :no_conn=>true).must_equal "[]"
     DB.create_table(:a){Integer :a}
-    bin(:args=>"-c \"print DB.tables.inspect\" -e foo #{TMP_FILE}", :no_conn=>true).should == "[:a]"
+    bin(:args=>"-c \"print DB.tables.inspect\" -e foo #{TMP_FILE}", :no_conn=>true).must_equal "[: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]"
+    bin(:args=>"-c \"print DB.tables.inspect\" -e foo #{TMP_FILE}", :no_conn=>true).must_equal "[: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 == '[]'
+    bin(:post=>TMP_FILE).must_equal '[]'
     DB.create_table(:a){Integer :a}
-    bin(:post=>TMP_FILE).should == '[:a]'
-    bin(:post=>TMP_FILE, :args=>'-v').should == "sequel #{Sequel.version}\n[:a]"
+    bin(:post=>TMP_FILE).must_equal '[:a]'
+    bin(:post=>TMP_FILE, :args=>'-v').strip.must_equal "sequel #{Sequel.version}\n[:a]"
   end
 
   it "should run code provided on stdin" do
-    bin(:pre=>'echo print DB.tables.inspect | ').should == '[]'
+    bin(:pre=>'echo print DB.tables.inspect | ').must_equal '[]'
     DB.create_table(:a){Integer :a}
-    bin(:pre=>'echo print DB.tables.inspect | ').should == '[:a]'
+    bin(:pre=>'echo print DB.tables.inspect | ').must_equal '[:a]'
   end
 end

data/spec/core/connection_pool_spec.rb

@@ -15,32 +15,32 @@ describe "An empty ConnectionPool" do
     @cpool = Sequel::ConnectionPool.get_pool(mock_db.call, CONNECTION_POOL_DEFAULTS)
   end
 
-  specify "should have no available connections" do
-    @cpool.available_connections.should == []
+  it "should have no available connections" do
+    @cpool.available_connections.must_equal []
   end
 
-  specify "should have no allocated connections" do
-    @cpool.allocated.should == {}
+  it "should have no allocated connections" do
+    @cpool.allocated.must_equal({})
   end
 
-  specify "should have a created_count of zero" do
-    @cpool.created_count.should == 0
+  it "should have a created_count of zero" do
+    @cpool.created_count.must_equal 0
   end
 end
 
 describe "ConnectionPool options" do
-  specify "should support string option values" do
+  it "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 unless cpool.class::USE_WAITER
+    cpool.max_size.must_equal 5
+    cpool.instance_variable_get(:@timeout).must_equal 3
+    cpool.instance_variable_get(:@sleep_time).must_equal 0.01 unless cpool.class::USE_WAITER
   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)
+  it "should raise an error unless size is positive" do
+    lambda{Sequel::ConnectionPool.get_pool(mock_db.call{1}, :max_connections=>0)}.must_raise(Sequel::Error)
+    lambda{Sequel::ConnectionPool.get_pool(mock_db.call{1}, :max_connections=>-10)}.must_raise(Sequel::Error)
+    lambda{Sequel::ConnectionPool.get_pool(mock_db.call{1}, :max_connections=>'-10')}.must_raise(Sequel::Error)
+    lambda{Sequel::ConnectionPool.get_pool(mock_db.call{1}, :max_connections=>'0')}.must_raise(Sequel::Error)
   end
 end
 
@@ -51,86 +51,86 @@ describe "A connection pool handling connections" do
     @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
+  it "#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
+      @cpool.created_count.must_equal 1
+      @cpool.hold {@cpool.hold {@cpool.created_count.must_equal 1}}
+      Thread.new{@cpool.hold {_(@cpool.created_count).must_equal 2}}.join
     end
   end
 
-  specify "#hold should add the connection to the #allocated array" do
+  it "#hold should add the connection to the #allocated array" do
     @cpool.hold do
-      @cpool.allocated.size.should == 1
+      @cpool.allocated.size.must_equal 1
   
-      @cpool.allocated.should == {Thread.current=>:got_connection}
+      @cpool.allocated.must_equal(Thread.current=>:got_connection)
     end
   end
 
-  specify "#hold should yield a new connection" do
-    @cpool.hold {|conn| conn.should == :got_connection}
+  it "#hold should yield a new connection" do
+    @cpool.hold {|conn| conn.must_equal :got_connection}
   end
 
-  specify "a connection should be de-allocated after it has been used in #hold" do
+  it "a connection should be de-allocated after it has been used in #hold" do
     @cpool.hold {}
-    @cpool.allocated.size.should == 0
+    @cpool.allocated.size.must_equal 0
   end
 
-  specify "#hold should return the value of its block" do
-    @cpool.hold {:block_return}.should == :block_return
+  it "#hold should return the value of its block" do
+    @cpool.hold {:block_return}.must_equal :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
+    it "#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]
+      @cpool.allocated.keys.map{|t| t.alive?}.must_equal [false]
 
       Thread.new{@cpool.hold{Thread.current.exit!}}.join
-      @cpool.allocated.keys.map{|t| t.alive?}.should == [false, false]
+      @cpool.allocated.keys.map{|t| t.alive?}.must_equal [false, false]
 
       Thread.new{@cpool.hold{}}.join
-      @cpool.allocated.should == {}
+      @cpool.allocated.must_equal({})
     end
   end
 
-  specify "#make_new should not make more than max_size connections" do
+  it "#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
+    @cpool.created_count.must_be :<=,  @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
+  it "database's disconnect connection method should be called when a disconnect is detected" do
+    @max_size.must_equal 2
+    proc{@cpool.hold{raise Sequel::DatabaseDisconnectError}}.must_raise(Sequel::DatabaseDisconnectError)
+    @max_size.must_equal 3
   end
 
-  specify "#hold should remove the connection if a DatabaseDisconnectError is raised" do
-    @cpool.created_count.should == 0
+  it "#hold should remove the connection if a DatabaseDisconnectError is raised" do
+    @cpool.created_count.must_equal 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
+    @cpool.created_count.must_equal 2
+    proc{@cpool.hold{raise Sequel::DatabaseDisconnectError}}.must_raise(Sequel::DatabaseDisconnectError)
+    @cpool.created_count.must_equal 1
+    proc{@cpool.hold{raise Sequel::DatabaseDisconnectError}}.must_raise(Sequel::DatabaseDisconnectError)
+    @cpool.created_count.must_equal 0
+    proc{@cpool.hold{raise Sequel::DatabaseDisconnectError}}.must_raise(Sequel::DatabaseDisconnectError)
+    @cpool.created_count.must_equal 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
+  it "#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
+    proc{cpool.hold{:block_return}}.must_raise(Sequel::DatabaseConnectionError)
+    cpool.created_count.must_equal 0
   end
 
-  specify "#hold should raise a Sequel::DatabaseConnectionError if nil is returned by the connection_proc" do
+  it "#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
+    proc{cpool.hold{:block_return}}.must_raise(Sequel::DatabaseConnectionError)
+    cpool.created_count.must_equal 0
   end
 end
 
@@ -144,24 +144,24 @@ describe "ConnectionPool#hold" do
     @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
+  it "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
+    res.must_be_kind_of(@c)
+    res.value.must_equal 1
     @pool.hold {|c| res = c}
-    res.should be_a_kind_of(@c)
-    res.value.should == 1 # the connection maker is invoked only once
+    res.must_be_kind_of(@c)
+    res.value.must_equal 1 # the connection maker is invoked only once
   end
   
-  specify "should be re-entrant by the same thread" do
+  it "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)
+    cc.must_be_kind_of(@c)
   end
   
-  specify "should catch exceptions and reraise them" do
-    proc {@pool.hold {|c| c.foobar}}.should raise_error(NoMethodError)
+  it "should catch exceptions and reraise them" do
+    proc {@pool.hold {|c| c.foobar}}.must_raise(NoMethodError)
   end
 end
 
@@ -172,51 +172,51 @@ describe "A connection pool with a max size of 1" do
     @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
+  it "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'
+    cc.must_equal 'herro'
+    c1.must_equal '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
+    t1.must_be :alive?
+    t2.must_be :alive?
     
-    cc.should == 'herro'
-    c1.should == 'herro'
-    c2.should be_nil
+    cc.must_equal 'herro'
+    c1.must_equal 'herro'
+    c2.must_equal nil
     
-    @pool.available_connections.should be_empty
-    @pool.allocated.should == {t1=>cc}
+    @pool.available_connections.must_be :empty?
+    @pool.allocated.must_equal(t1=>cc)
 
     cc.gsub!('rr', 'll')
     q.push nil
     q1.pop
 
     t1.join
-    t2.should be_alive
+    t2.must_be :alive?
     
-    c2.should == 'hello'
+    c2.must_equal 'hello'
 
-    @pool.available_connections.should be_empty
-    @pool.allocated.should == {t2=>cc}
+    @pool.available_connections.must_be :empty?
+    @pool.allocated.must_equal(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
+    @invoked_count.must_equal 1
+    @pool.size.must_equal 1
+    @pool.available_connections.must_equal [cc]
+    @pool.allocated.must_be :empty?
   end
   
-  specify "should let the same thread reenter #hold" do
+  it "should let the same thread reenter #hold" do
     c1, c2, c3 = nil
     @pool.hold do |c|
       c1 = c
@@ -227,19 +227,19 @@ describe "A connection pool with a max size of 1" do
         end
       end
     end
-    c1.should == 'herro'
-    c2.should == 'herro'
-    c3.should == 'herro'
+    c1.must_equal 'herro'
+    c2.must_equal 'herro'
+    c3.must_equal 'herro'
     
-    @invoked_count.should == 1
-    @pool.size.should == 1
-    @pool.available_connections.size.should == 1
-    @pool.allocated.should be_empty
+    @invoked_count.must_equal 1
+    @pool.size.must_equal 1
+    @pool.available_connections.size.must_equal 1
+    @pool.allocated.must_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
+ThreadedConnectionPoolSpecs = shared_description do
+  it "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
@@ -250,13 +250,13 @@ shared_examples_for "A threaded connection pool" do
     end
     pool.hold do |c1|
       q1.pop
-      pool.all_connections{|c| c.should == c1}
+      pool.all_connections{|c| c.must_equal c1}
       q.push nil
     end
     t.join
   end
 
-  specify "should wait until a connection is available if all are checked out" do
+  it "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
@@ -267,12 +267,12 @@ shared_examples_for "A threaded connection pool" do
       end
     end
     q1.pop
-    proc{pool.hold{}}.should raise_error(Sequel::PoolTimeout)
+    proc{pool.hold{}}.must_raise(Sequel::PoolTimeout)
     q.push nil
     t.join
   end
 
-  specify "should not have all_connections yield all available connections" do
+  it "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 = []
@@ -291,128 +291,128 @@ shared_examples_for "A threaded connection pool" do
     t.join
     a = []
     pool.all_connections{|c| a << c}
-    a.sort.should == b.sort
+    a.sort.must_equal b.sort
   end
 
-  specify "should raise a PoolTimeout error if a connection couldn't be acquired before timeout" do
+  it "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)
+    proc{pool.hold{|c|}}.must_raise(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
+    proc{pool.hold{raise Sequel::DatabaseDisconnectError}}.must_raise(Sequel::Error)
+    pool.available_connections.length.must_equal 0
   end
 
-  specify "should let five threads simultaneously access separate connections" do
+  it "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
+    threads.each {|t| t.must_be :alive?}
+    cc.size.must_equal 5
+    @invoked_count.must_equal 5
+    @pool.size.must_equal 5
+    @pool.available_connections.must_be :empty?
 
     h = {}
     i = 0
     threads.each{|t| h[t] = (i+=1)}
-    @pool.allocated.should == h
-    @pool.available_connections.should == []
+    @pool.allocated.must_equal h
+    @pool.available_connections.must_equal []
     5.times{q2.push nil}
     threads.each{|t| t.join}
     
-    @pool.available_connections.size.should == 5
-    @pool.allocated.should be_empty
+    @pool.available_connections.size.must_equal 5
+    @pool.allocated.must_be :empty?
   end
   
-  specify "should block threads until a connection becomes available" do
+  it "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
+    threads.each {|t| t.must_be :alive?}
+    @pool.available_connections.must_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
+    threads[5].must_be :alive?
+    threads[6].must_be :alive?
+    threads[7].must_be :alive?
+    cc.size.must_equal 5
+    cc[5].must_equal nil
+    cc[6].must_equal nil
+    cc[7].must_equal 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}
+    threads.each {|t| t.wont_be :alive?}
     
-    @pool.size.should == 5
-    @invoked_count.should == 5
-    @pool.available_connections.size.should == 5
-    @pool.allocated.should be_empty
+    @pool.size.must_equal 5
+    @invoked_count.must_equal 5
+    @pool.available_connections.size.must_equal 5
+    @pool.allocated.must_be :empty?
   end
 
-  specify "should store connections in a stack if :connection_handling=>:stack" do
+  it "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.size.must_equal 2
+    @pool.hold{|cc| cc.must_equal c}
+    @pool.hold{|cc| cc.must_equal c}
     @pool.hold do |cc|
-      cc.should == c
-      Thread.new{@pool.hold{|cc2| cc2.should == c2}}
+      cc.must_equal c
+      Thread.new{@pool.hold{|cc2| cc2.must_equal c2}}
     end
   end
 
-  specify "should store connections in a queue if :connection_handling=>:queue" do
+  it "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.size.must_equal 2
+    @pool.hold{|cc| cc.must_equal c2}
+    @pool.hold{|cc| cc.must_equal c}
     @pool.hold do |cc|
-      cc.should == c2
-      Thread.new{@pool.hold{|cc2| cc2.should == c}}
+      cc.must_equal c2
+      Thread.new{@pool.hold{|cc2| cc2.must_equal c}}
     end
   end
 
-  specify "should not store connections if :connection_handling=>:disconnect" do
+  it "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}
+      cc.must_equal 1
+      Thread.new{@pool.hold{|cc2| _(cc2).must_equal 2}}.join
+      d.must_equal [2]
+      @pool.hold{|cc3| cc3.must_equal 1}
     end
-    @pool.size.should == 0
-    d.should == [2, 1]
+    @pool.size.must_equal 0
+    d.must_equal [2, 1]
 
-    @pool.hold{|cc| cc.should == 3}
-    @pool.size.should == 0
-    d.should == [2, 1, 3]
+    @pool.hold{|cc| cc.must_equal 3}
+    @pool.size.must_equal 0
+    d.must_equal [2, 1, 3]
 
-    @pool.hold{|cc| cc.should == 4}
-    @pool.size.should == 0
-    d.should == [2, 1, 3, 4]
+    @pool.hold{|cc| cc.must_equal 4}
+    @pool.size.must_equal 0
+    d.must_equal [2, 1, 3, 4]
   end
 end
 
@@ -424,7 +424,7 @@ describe "Threaded Unsharded Connection Pool" do
     @pool = Sequel::ConnectionPool.get_pool(mock_db.call(&@icpp), @cp_opts)
   end
   
-  it_should_behave_like "A threaded connection pool"
+  include ThreadedConnectionPoolSpecs
 end
 
 describe "Threaded Sharded Connection Pool" do
@@ -435,7 +435,7 @@ describe "Threaded Sharded Connection Pool" do
     @pool = Sequel::ConnectionPool.get_pool(mock_db.call(&@icpp), @cp_opts)
   end
 
-  it_should_behave_like "A threaded connection pool"
+  include ThreadedConnectionPoolSpecs
 end
 
 describe "ConnectionPool#disconnect" do
@@ -451,34 +451,34 @@ describe "ConnectionPool#disconnect" do
     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}
+  it "should invoke the given block for each available connection" do
+    @pool.size.must_equal 5
+    @pool.available_connections.size.must_equal 5
+    @pool.available_connections.each {|c| c[:id].wont_equal nil}
     conns = []
     meta_def(@pool.db, :disconnect_connection){|c| conns << c}
     @pool.disconnect
-    conns.size.should == 5
+    conns.size.must_equal 5
   end
   
-  specify "should remove all available connections" do
-    @pool.size.should == 5
+  it "should remove all available connections" do
+    @pool.size.must_equal 5
     @pool.disconnect
-    @pool.size.should == 0
+    @pool.size.must_equal 0
   end
 
-  specify "should disconnect connections in use as soon as they are no longer in use" do
-    @pool.size.should == 5
+  it "should disconnect connections in use as soon as they are no longer in use" do
+    @pool.size.must_equal 5
     @pool.hold do |conn|
-      @pool.available_connections.size.should == 4
-      @pool.available_connections.each {|c| c.should_not be(conn)}
+      @pool.available_connections.size.must_equal 4
+      @pool.available_connections.each {|c| c.wont_be_same_as(conn)}
       conns = []
       meta_def(@pool.db, :disconnect_connection){|c| conns << c}
       @pool.disconnect
-      conns.size.should == 4
-      @pool.size.should == 1
+      conns.size.must_equal 4
+      @pool.size.must_equal 1
     end
-    @pool.size.should == 0
+    @pool.size.must_equal 0
   end
 end
 
@@ -488,187 +488,187 @@ describe "A connection pool with multiple servers" do
     @pool = Sequel::ConnectionPool.get_pool(mock_db.call{|server| "#{server}#{ic[server] += 1}"}, CONNECTION_POOL_DEFAULTS.merge(:servers=>{:read_only=>{}}))
   end
   
-  specify "should support preconnect method that immediately creates the maximum number of connections" do
+  it "should support preconnect method that immediately creates the maximum number of connections" do
     @pool.send(:preconnect)
     i = 0
     @pool.all_connections{|c1| i+=1}
-    i.should == @pool.max_size * 2
+    i.must_equal @pool.max_size * 2
   end
 
-  specify "#all_connections should return connections for all servers" do
+  it "#all_connections should return connections for all servers" do
     @pool.hold{}
-    @pool.all_connections{|c1| c1.should == "default1"}
+    @pool.all_connections{|c1| c1.must_equal "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"]
+    a.sort_by{|c| c.to_s}.must_equal ["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]
+  it "#servers should return symbols for all servers" do
+    @pool.servers.sort_by{|s| s.to_s}.must_equal [:default, :read_only]
   end
 
-  specify "should use the :default server by default" do
-    @pool.size.should == 0
+  it "should use the :default server by default" do
+    @pool.size.must_equal 0
     @pool.hold do |c|
-      c.should == "default1"
-      @pool.allocated.should == {Thread.current=>"default1"}
+      c.must_equal "default1"
+      @pool.allocated.must_equal(Thread.current=>"default1")
     end
-    @pool.available_connections.should == ["default1"]
-    @pool.size.should == 1
-    @invoked_counts.should == {:default=>1}
+    @pool.available_connections.must_equal ["default1"]
+    @pool.size.must_equal 1
+    @invoked_counts.must_equal(:default=>1)
   end
   
-  specify "should use the :default server an invalid server is used" do
+  it "should use the :default server an invalid server is used" do
     @pool.hold do |c1|
-      c1.should == "default1"
+      c1.must_equal "default1"
       @pool.hold(:blah) do |c2|
-        c2.should == c1
+        c2.must_equal c1
         @pool.hold(:blah2) do |c3|
-          c2.should == c3
+          c2.must_equal c3
         end
       end
     end
   end
 
-  specify "should support a :servers_hash option used for converting the server argument" do
+  it "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"
+      c1.must_equal "read_only1"
       @pool.hold(:blah) do |c2|
-        c2.should == c1
+        c2.must_equal c1
         @pool.hold(:blah2) do |c3|
-          c2.should == c3
+          c2.must_equal 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)
+    proc{@pool.hold(:blah){|c1|}}.must_raise(Sequel::Error)
   end
 
-  specify "should use the requested server if server is given" do
-    @pool.size(:read_only).should == 0
+  it "should use the requested server if server is given" do
+    @pool.size(:read_only).must_equal 0
     @pool.hold(:read_only) do |c|
-      c.should == "read_only1"
-      @pool.allocated(:read_only).should == {Thread.current=>"read_only1"}
+      c.must_equal "read_only1"
+      @pool.allocated(:read_only).must_equal(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}
+    @pool.available_connections(:read_only).must_equal ["read_only1"]
+    @pool.size(:read_only).must_equal 1
+    @invoked_counts.must_equal(:read_only=>1)
   end
   
-  specify "#hold should only yield connections for the server requested" do
+  it "#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"}
+      c.must_equal "read_only1"
+      @pool.allocated(:read_only).must_equal(Thread.current=>"read_only1")
       @pool.hold do |d|
-        d.should == "default1"
+        d.must_equal "default1"
         @pool.hold do |e|
-          e.should == d
-          @pool.hold(:read_only){|b| b.should == c}
+          e.must_equal d
+          @pool.hold(:read_only){|b| b.must_equal c}
         end
-        @pool.allocated.should == {Thread.current=>"default1"}
+        @pool.allocated.must_equal(Thread.current=>"default1")
       end
     end
-    @invoked_counts.should == {:read_only=>1, :default=>1}
+    @invoked_counts.must_equal(:read_only=>1, :default=>1)
   end
   
-  specify "#disconnect should disconnect from all servers" do
+  it "#disconnect should disconnect from all servers" do
     @pool.hold(:read_only){}
     @pool.hold{}
     conns = []
-    @pool.size.should == 1
-    @pool.size(:read_only).should == 1
+    @pool.size.must_equal 1
+    @pool.size(:read_only).must_equal 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'}
+    conns.sort.must_equal %w'default1 read_only1'
+    @pool.size.must_equal 0
+    @pool.size(:read_only).must_equal 0
+    @pool.hold(:read_only){|c| c.must_equal 'read_only2'}
+    @pool.hold{|c| c.must_equal 'default2'}
   end
   
-  specify "#add_servers should add new servers to the pool" do
+  it "#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.allocated.length.must_equal 0
+      pool.allocated(:server1).length.must_equal 1
+      pool.allocated(:server2).must_equal nil
+      pool.allocated(:server3).must_equal nil
+      pool.available_connections.length.must_equal 1
+      pool.available_connections(:server1).length.must_equal 0
+      pool.available_connections(:server2).must_equal nil
+      pool.available_connections(:server3).must_equal 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
+        pool.allocated.length.must_equal 0
+        pool.allocated(:server1).length.must_equal 1
+        pool.allocated(:server2).length.must_equal 0
+        pool.allocated(:server3).length.must_equal 1
+        pool.available_connections.length.must_equal 1
+        pool.available_connections(:server1).length.must_equal 0
+        pool.available_connections(:server2).length.must_equal 1
+        pool.available_connections(:server3).length.must_equal 0
       end
     end
   end
 
-  specify "#add_servers should ignore existing keys" do
+  it "#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.allocated.length.must_equal 0
+    pool.allocated(:server1).length.must_equal 0
+    pool.available_connections.length.must_equal 0
+    pool.available_connections(:server1).length.must_equal 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
+      c1.must_equal :default
+      pool.allocated.length.must_equal 1
+      pool.allocated(:server1).length.must_equal 0
+      pool.available_connections.length.must_equal 0
+      pool.available_connections(:server1).length.must_equal 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
+        c2.must_equal :server1
+        pool.allocated.length.must_equal 1
+        pool.allocated(:server1).length.must_equal 1
+        pool.available_connections.length.must_equal 0
+        pool.available_connections(:server1).length.must_equal 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
+        pool.allocated.length.must_equal 1
+        pool.allocated(:server1).length.must_equal 1
+        pool.available_connections.length.must_equal 0
+        pool.available_connections(:server1).length.must_equal 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.allocated.length.must_equal 1
+      pool.allocated(:server1).length.must_equal 0
+      pool.available_connections.length.must_equal 0
+      pool.available_connections(:server1).length.must_equal 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
+      pool.allocated.length.must_equal 1
+      pool.allocated(:server1).length.must_equal 0
+      pool.available_connections.length.must_equal 0
+      pool.available_connections(:server1).length.must_equal 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.allocated.length.must_equal 0
+    pool.allocated(:server1).length.must_equal 0
+    pool.available_connections.length.must_equal 1
+    pool.available_connections(:server1).length.must_equal 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
+    pool.allocated.length.must_equal 0
+    pool.allocated(:server1).length.must_equal 0
+    pool.available_connections.length.must_equal 1
+    pool.available_connections(:server1).length.must_equal 1
   end
   
-  specify "#remove_servers should disconnect available connections immediately" do
+  it "#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
@@ -677,57 +677,57 @@ describe "A connection pool with multiple servers" do
     5.times{q.push nil}
     threads.each {|t| t.join}
     
-    pool.size(:server1).should == 5
+    pool.size(:server1).must_equal 5
     pool.remove_servers([:server1])
-    pool.size(:server1).should == 0
+    pool.size(:server1).must_equal 0
   end
   
-  specify "#remove_servers should disconnect connections in use as soon as they are returned to the pool" do
+  it "#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.size(:server1).must_equal 1
+      dc.must_equal []
       pool.remove_servers([:server1])
-      pool.size(:server1).should == 0
-      dc.should == []
+      pool.size(:server1).must_equal 0
+      dc.must_equal []
       c1 = c
     end
-    pool.size(:server1).should == 0
-    dc.should == [c1]
+    pool.size(:server1).must_equal 0
+    dc.must_equal [c1]
   end
   
-  specify "#remove_servers should remove server related data structures immediately" do
+  it "#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.available_connections(:server1).must_equal []
+    pool.allocated(:server1).must_equal({})
     pool.remove_servers([:server1])
-    pool.available_connections(:server1).should == nil
-    pool.allocated(:server1).should == nil
+    pool.available_connections(:server1).must_equal nil
+    pool.allocated(:server1).must_equal nil
   end
   
-  specify "#remove_servers should not allow the removal of the default server" do
+  it "#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)
+    pool.remove_servers([:server1])
+    proc{pool.remove_servers([:default])}.must_raise(Sequel::Error)
   end
   
-  specify "#remove_servers should ignore servers that have already been removed" do
+  it "#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.size(:server1).must_equal 1
+      dc.must_equal []
       pool.remove_servers([:server1])
       pool.remove_servers([:server1])
-      pool.size(:server1).should == 0
-      dc.should == []
+      pool.size(:server1).must_equal 0
+      dc.must_equal []
       c1 = c
     end
-    pool.size(:server1).should == 0
-    dc.should == [c1]
+    pool.size(:server1).must_equal 0
+    dc.must_equal [c1]
   end
 end
 
@@ -738,20 +738,20 @@ describe "SingleConnectionPool" do
     @pool = Sequel::ConnectionPool.get_pool(mock_db.call{1234}, ST_CONNECTION_POOL_DEFAULTS)
   end
   
-  specify "should provide a #hold method" do
+  it "should provide a #hold method" do
     conn = nil
     @pool.hold{|c| conn = c}
-    conn.should == 1234
+    conn.must_equal 1234
   end
   
-  specify "should provide a #disconnect method" do
+  it "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
+    x.must_equal 1234
     pool.disconnect
-    conn.should == 1234
+    conn.must_equal 1234
   end
 end
 
@@ -762,242 +762,242 @@ describe "A single threaded pool with multiple servers" do
     @pool = Sequel::ConnectionPool.get_pool(mock_db.call(proc{|c| msp.call}){|c| c}, ST_CONNECTION_POOL_DEFAULTS.merge(:servers=>{:read_only=>{}}))
   end
   
-  specify "should support preconnect method that immediately creates the maximum number of connections" do
+  it "should support preconnect method that immediately creates the maximum number of connections" do
     @pool.send(:preconnect)
     i = 0
     @pool.all_connections{|c1| i+=1}
-    i.should == 2
+    i.must_equal 2
   end
 
-  specify "#all_connections should return connections for all servers" do
+  it "#all_connections should return connections for all servers" do
     @pool.hold{}
-    @pool.all_connections{|c1| c1.should == :default}
+    @pool.all_connections{|c1| c1.must_equal :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]
+    a.sort_by{|c| c.to_s}.must_equal [: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]
+  it "#servers should return symbols for all servers" do
+    @pool.servers.sort_by{|s| s.to_s}.must_equal [:default, :read_only]
   end
   
-  specify "#add_servers should add new servers to the pool" do
-    @pool.hold(:blah){|c| c.should == :default}
+  it "#add_servers should add new servers to the pool" do
+    @pool.hold(:blah){|c| c.must_equal :default}
     @pool.add_servers([:blah])
-    @pool.hold(:blah){|c| c.should == :blah}
+    @pool.hold(:blah){|c| c.must_equal :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}
+  it "#add_servers should ignore keys already existing" do
+    @pool.hold{|c| c.must_equal :default}
+    @pool.hold(:read_only){|c| c.must_equal :read_only}
     @pool.add_servers([:default, :read_only])
-    @pool.conn.should == :default
-    @pool.conn(:read_only).should == :read_only
+    @pool.conn.must_equal :default
+    @pool.conn(:read_only).must_equal :read_only
   end
   
-  specify "#remove_servers should remove servers from the pool" do
-    @pool.hold(:read_only){|c| c.should == :read_only}
+  it "#remove_servers should remove servers from the pool" do
+    @pool.hold(:read_only){|c| c.must_equal :read_only}
     @pool.remove_servers([:read_only])
-    @pool.hold(:read_only){|c| c.should == :default}
+    @pool.hold(:read_only){|c| c.must_equal :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)
+  it "#remove_servers should not allow the removal of the default server" do
+    proc{@pool.remove_servers([:default])}.must_raise(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
+  it "#remove_servers should disconnect connection immediately" do
+    @pool.hold(:read_only){|c| c.must_equal :read_only}
+    @pool.conn(:read_only).must_equal :read_only
     @pool.remove_servers([:read_only])
-    @pool.conn(:read_only).should == nil
+    @pool.conn(:read_only).must_equal nil
     @pool.hold{}
-    @pool.conn(:read_only).should == :default
+    @pool.conn(:read_only).must_equal :default
   end
   
-  specify "#remove_servers should ignore keys that do not exist" do
-    proc{@pool.remove_servers([:blah])}.should_not raise_error
+  it "#remove_servers should ignore keys that do not exist" do
+    @pool.remove_servers([:blah])
   end
   
-  specify "should use the :default server by default" do
-    @pool.hold{|c| c.should == :default}
-    @pool.conn.should == :default
+  it "should use the :default server by default" do
+    @pool.hold{|c| c.must_equal :default}
+    @pool.conn.must_equal :default
   end
   
-  specify "should use the :default server an invalid server is used" do
+  it "should use the :default server an invalid server is used" do
     @pool.hold do |c1|
-      c1.should == :default
+      c1.must_equal :default
       @pool.hold(:blah) do |c2|
-        c2.should == c1
+        c2.must_equal c1
         @pool.hold(:blah2) do |c3|
-          c2.should == c3
+          c2.must_equal 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
+  it "should use the requested server if server is given" do
+    @pool.hold(:read_only){|c| c.must_equal :read_only}
+    @pool.conn(:read_only).must_equal :read_only
   end
   
-  specify "#hold should only yield connections for the server requested" do
+  it "#hold should only yield connections for the server requested" do
     @pool.hold(:read_only) do |c|
-      c.should == :read_only
+      c.must_equal :read_only
       @pool.hold do |d|
-        d.should == :default
+        d.must_equal :default
         @pool.hold do |e|
-          e.should == d
-          @pool.hold(:read_only){|b| b.should == c}
+          e.must_equal d
+          @pool.hold(:read_only){|b| b.must_equal c}
         end
       end
     end
-    @pool.conn.should == :default
-    @pool.conn(:read_only).should == :read_only
+    @pool.conn.must_equal :default
+    @pool.conn(:read_only).must_equal :read_only
   end
   
-  specify "#disconnect should disconnect from all servers" do
+  it "#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.conn.must_equal :default
+    @pool.conn(:read_only).must_equal :read_only
     @pool.disconnect
-    @max_size.should == 4
-    @pool.conn.should == nil
-    @pool.conn(:read_only).should == nil
+    @max_size.must_equal 4
+    @pool.conn.must_equal nil
+    @pool.conn(:read_only).must_equal 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
+  it ":disconnection_proc option should set the disconnection proc to use" do
+    @max_size.must_equal 2
+    proc{@pool.hold{raise Sequel::DatabaseDisconnectError}}.must_raise(Sequel::DatabaseDisconnectError)
+    @max_size.must_equal 3
   end
 
-  specify "#hold should remove the connection if a DatabaseDisconnectError is raised" do
-    @pool.instance_variable_get(:@conns).length.should == 0
+  it "#hold should remove the connection if a DatabaseDisconnectError is raised" do
+    @pool.instance_variable_get(:@conns).length.must_equal 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
+    @pool.instance_variable_get(:@conns).length.must_equal 1
+    proc{@pool.hold{raise Sequel::DatabaseDisconnectError}}.must_raise(Sequel::DatabaseDisconnectError)
+    @pool.instance_variable_get(:@conns).length.must_equal 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)
+AllConnectionPoolClassesSpecs = shared_description do
+  it "should have pool_type return a symbol" do
+    @class.new(mock_db.call{123}, {}).pool_type.must_be_kind_of(Symbol)
   end
 
-  specify "should have all_connections yield current and available connections" do
+  it "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}}
+    p.hold{|c| p.all_connections{|c1| c.must_equal c1}}
   end
 
-  specify "should have a size method that gives the current size of the pool" do
+  it "should have a size method that gives the current size of the pool" do
     p = @class.new(mock_db.call{123}, {})
-    p.size.should == 0
+    p.size.must_equal 0
     p.hold{}
-    p.size.should == 1
+    p.size.must_equal 1
   end
 
-  specify "should have a max_size method that gives the maximum size of the pool" do
-    @class.new(mock_db.call{123}, {}).max_size.should >= 1
+  it "should have a max_size method that gives the maximum size of the pool" do
+    @class.new(mock_db.call{123}, {}).max_size.must_be :>=,  1
   end
 
-  specify "should support preconnect method that immediately creates the maximum number of connections" do
+  it "should support preconnect method that immediately creates the maximum number of connections" do
     p = @class.new(mock_db.call{123}, {})
     p.send(:preconnect)
     i = 0
     p.all_connections{|c1| i+=1}
-    i.should == p.max_size
+    i.must_equal p.max_size
   end
 
-  specify "should be able to modify after_connect proc after the pool is created" do
+  it "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.after_connect.must_equal pr
+    a.must_equal []
     p.hold{}
-    a.should == [123]
+    a.must_equal [123]
   end
 
-  specify "should not raise an error when disconnecting twice" do
+  it "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
+    c.disconnect
+    c.disconnect
   end
   
-  specify "should yield a connection created by the initialize block to hold" do
+  it "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
+    x.must_equal 123
   end
   
-  specify "should have the initialize block accept a shard/server argument" do
+  it "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]
+    x.must_equal [:default, :default]
   end
   
-  specify "should have respect an :after_connect proc that is called with each newly created connection" do
+  it "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]
+    x.must_equal [123, 123]
     @class.new(mock_db.call{123}, :after_connect=>lambda{|c| x = [c, c]}).hold{}
-    x.should == [123, 123]
+    x.must_equal [123, 123]
     @class.new(mock_db.call{123}, :after_connect=>proc{|c, s| x = [c, s]}).hold{}
-    x.should == [123, :default]
+    x.must_equal [123, :default]
     @class.new(mock_db.call{123}, :after_connect=>lambda{|c, s| x = [c, s]}).hold{}
-    x.should == [123, :default]
+    x.must_equal [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)
+  it "should raise a DatabaseConnectionError if the connection raises an exception" do
+    proc{@class.new(mock_db.call{|c| raise Exception}, {}).hold{}}.must_raise(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)
+  it "should raise a DatabaseConnectionError if the initialize block returns nil" do
+    proc{@class.new(mock_db.call{}, {}).hold{}}.must_raise(Sequel::DatabaseConnectionError)
   end
   
-  specify "should call the disconnection_proc option if the hold block raises a DatabaseDisconnectError" do
+  it "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
+    proc{@class.new(mock_db.call(proc{|c| x = c}){123}).hold{raise Sequel::DatabaseDisconnectError}}.must_raise(Sequel::DatabaseDisconnectError)
+    x.must_equal 123
   end
   
-  specify "should have a disconnect method that disconnects the connection" do
+  it "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
+    x.must_equal nil
     c.disconnect
-    x.should == 123
+    x.must_equal 123
   end
   
-  specify "should have a reentrent hold method" do
+  it "should have a reentrent hold method" do
     o = Object.new
     c = @class.new(mock_db.call{o}, {})
     c.hold do |x|
-      x.should == o
+      x.must_equal o
       c.hold do |x1|
-        x1.should == o
+        x1.must_equal o
         c.hold do |x2|
-          x2.should == o
+          x2.must_equal 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]
+  it "should have a servers method that returns an array of shard/server symbols" do
+    @class.new(mock_db.call{123}, {}).servers.must_equal [:default]
   end
   
-  specify "should have a servers method that returns an array of shard/server symbols" do
+  it "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.size.must_equal 0
     c.hold{}
-    c.size.should == 1
+    c.size.must_equal 1
   end
 end
 
@@ -1010,6 +1010,7 @@ Sequel::ConnectionPool::CONNECTION_POOL_MAP.keys.each do |k, v|
     before do
       @class = Sequel::ConnectionPool.send(:connection_pool_class, opts)
     end
-    it_should_behave_like "All connection pools classes"
+
+    include AllConnectionPoolClassesSpecs
   end
 end