sequel 4.22.0 → 4.23.0

data/spec/adapters/informix_spec.rb

@@ -13,11 +13,11 @@ DB.create_table :test do
 end
 
 describe "A Informix database" do
-  specify "should provide disconnect functionality" do
+  it "should provide disconnect functionality" do
     DB.execute("select user from dual")
-    DB.pool.size.should == 1
+    DB.pool.size.must_equal 1
     DB.disconnect
-    DB.pool.size.should == 0
+    DB.pool.size.must_equal 0
   end
 end
 
@@ -27,28 +27,28 @@ describe "A Informix dataset" do
     @d.delete # remove all records
   end
   
-  specify "should return the correct record count" do
-    @d.count.should == 0
+  it "should return the correct record count" do
+    @d.count.must_equal 0
     @d << {:name => 'abc', :value => 123}
     @d << {:name => 'abc', :value => 456}
     @d << {:name => 'def', :value => 789}
-    @d.count.should == 3
+    @d.count.must_equal 3
   end
   
-  specify "should return the correct records" do
-    @d.to_a.should == []
+  it "should return the correct records" do
+    @d.to_a.must_equal []
     @d << {:name => 'abc', :value => 123}
     @d << {:name => 'abc', :value => 456}
     @d << {:name => 'def', :value => 789}
 
-    @d.order(:value).to_a.should == [
+    @d.order(:value).to_a.must_equal [
       {:name => 'abc', :value => 123},
       {:name => 'abc', :value => 456},
       {:name => 'def', :value => 789}
     ]
   end
   
-  specify "should update records correctly" do
+  it "should update records correctly" do
     @d << {:name => 'abc', :value => 123}
     @d << {:name => 'abc', :value => 456}
     @d << {:name => 'def', :value => 789}
@@ -56,45 +56,45 @@ describe "A Informix dataset" do
     
     # the third record should stay the same
     # floating-point precision bullshit
-    @d[:name => 'def'][:value].should == 789
-    @d.filter(:value => 530).count.should == 2
+    @d[:name => 'def'][:value].must_equal 789
+    @d.filter(:value => 530).count.must_equal 2
   end
   
-  specify "should delete records correctly" do
+  it "should delete records correctly" do
     @d << {:name => 'abc', :value => 123}
     @d << {:name => 'abc', :value => 456}
     @d << {:name => 'def', :value => 789}
     @d.filter(:name => 'abc').delete
     
-    @d.count.should == 1
-    @d.first[:name].should == 'def'
+    @d.count.must_equal 1
+    @d.first[:name].must_equal 'def'
   end
   
-  specify "should be able to literalize booleans" do
-    proc {@d.literal(true)}.should_not raise_error
-    proc {@d.literal(false)}.should_not raise_error
+  it "should be able to literalize booleans" do
+    @d.literal(true)
+    @d.literal(false)
   end
   
-  specify "should support transactions" do
+  it "should support transactions" do
     DB.transaction do
       @d << {:name => 'abc', :value => 1}
     end
 
-    @d.count.should == 1
+    @d.count.must_equal 1
   end
   
-  specify "should support #first and #last" do
+  it "should support #first and #last" do
     @d << {:name => 'abc', :value => 123}
     @d << {:name => 'abc', :value => 456}
     @d << {:name => 'def', :value => 789}
     
-    @d.order(:value).first.should == {:name => 'abc', :value => 123}
-    @d.order(:value).last.should == {:name => 'def', :value => 789}
+    @d.order(:value).first.must_equal(:name => 'abc', :value => 123)
+    @d.order(:value).last.must_equal(:name => 'def', :value => 789)
   end
 
-  specify "should return last inserted id" do
+  it "should return last inserted id" do
     first = @d.insert :name => 'abc', :value => 123
     second = @d.insert :name => 'abc', :value => 123
-    (second - first).should == 1
+    (second - first).must_equal 1
   end
 end

data/spec/adapters/mssql_spec.rb

@@ -16,19 +16,19 @@ describe "A MSSQL database" do
     @db = DB
   end
 
-  specify "should be able to read fractional part of timestamp" do
+  it "should be able to read fractional part of timestamp" do
     rs = @db["select getutcdate() as full_date, cast(datepart(millisecond, getutcdate()) as int) as milliseconds"].first
-    rs[:milliseconds].should == rs[:full_date].usec/1000
+    rs[:milliseconds].must_equal rs[:full_date].usec/1000
   end
 
-  specify "should be able to write fractional part of timestamp" do
+  it "should be able to write fractional part of timestamp" do
     t = Time.utc(2001, 12, 31, 23, 59, 59, 997000)
-    (t.usec/1000).should == @db["select cast(datepart(millisecond, ?) as int) as milliseconds", t].get
+    (t.usec/1000).must_equal @db["select cast(datepart(millisecond, ?) as int) as milliseconds", t].get
   end
   
-  specify "should not raise an error when getting the server version" do
-    proc{@db.server_version}.should_not raise_error
-    proc{@db.dataset.server_version}.should_not raise_error
+  it "should not raise an error when getting the server version" do
+    @db.server_version
+    @db.dataset.server_version
   end
 end
   
@@ -44,8 +44,8 @@ describe "A MSSQL database" do
     @db.drop_table?(:test3)
   end
 
-  specify "should work with NOLOCK" do
-    @db.transaction{@db[:test3].nolock.all.should == []}
+  it "should work with NOLOCK" do
+    @db.transaction{@db[:test3].nolock.all.must_equal []}
   end
 end
 
@@ -61,12 +61,12 @@ describe "MSSQL" do
     @db.drop_table?(:test3, :test4)
   end
 
-  specify "should should support CROSS APPLY" do
-    @db[:test3].cross_apply(@db[:test4].where(:test3__v3=>:test4__v4)).select_order_map([:v3, :v4]).should == [[1,1]]
+  it "should should support CROSS APPLY" do
+    @db[:test3].cross_apply(@db[:test4].where(:test3__v3=>:test4__v4)).select_order_map([:v3, :v4]).must_equal [[1,1]]
   end
 
-  specify "should should support OUTER APPLY" do
-    @db[:test3].outer_apply(@db[:test4].where(:test3__v3=>:test4__v4)).select_order_map([:v3, :v4]).should == [[1,1], [2, nil]]
+  it "should should support OUTER APPLY" do
+    @db[:test3].outer_apply(@db[:test4].where(:test3__v3=>:test4__v4)).select_order_map([:v3, :v4]).must_equal [[1,1], [2, nil]]
   end
 end
 
@@ -83,31 +83,29 @@ describe "MSSQL full_text_search" do
     @db.drop_table?(:posts)
   end
   
-  specify "should support fulltext indexes and full_text_search" do
+  it "should support fulltext indexes and full_text_search" do
     log do
       @db.create_table(:posts){Integer :id, :null=>false; String :title; String :body; index :id, :name=>:fts_id_idx, :unique=>true; full_text_index :title, :key_index=>:fts_id_idx; full_text_index [:title, :body], :key_index=>:fts_id_idx}
       @db[:posts].insert(:title=>'ruby rails', :body=>'y')
       @db[:posts].insert(:title=>'sequel', :body=>'ruby')
       @db[:posts].insert(:title=>'ruby scooby', :body=>'x')
 
-      @db[:posts].full_text_search(:title, 'rails').all.should == [{:title=>'ruby rails', :body=>'y'}]
-      @db[:posts].full_text_search([:title, :body], ['sequel', 'ruby']).all.should == [{:title=>'sequel', :body=>'ruby'}]
+      @db[:posts].full_text_search(:title, 'rails').all.must_equal [{:title=>'ruby rails', :body=>'y'}]
+      @db[:posts].full_text_search([:title, :body], ['sequel', 'ruby']).all.must_equal [{:title=>'sequel', :body=>'ruby'}]
 
-      @db[:posts].full_text_search(:title, :$n).call(:select, :n=>'rails').should == [{:title=>'ruby rails', :body=>'y'}]
-      @db[:posts].full_text_search(:title, :$n).prepare(:select, :fts_select).call(:n=>'rails').should == [{:title=>'ruby rails', :body=>'y'}]
+      @db[:posts].full_text_search(:title, :$n).call(:select, :n=>'rails').must_equal [{:title=>'ruby rails', :body=>'y'}]
+      @db[:posts].full_text_search(:title, :$n).prepare(:select, :fts_select).call(:n=>'rails').must_equal [{:title=>'ruby rails', :body=>'y'}]
     end
   end
 end if false
 
 describe "MSSQL Dataset#join_table" do
-  specify "should emulate the USING clause with ON" do
-    DB[:items].join(:categories, [:id]).sql.should ==
-      'SELECT * FROM [ITEMS] INNER JOIN [CATEGORIES] ON ([CATEGORIES].[ID] = [ITEMS].[ID])'
+  it "should emulate the USING clause with ON" do
+    DB[:items].join(:categories, [:id]).sql.must_equal 'SELECT * FROM [ITEMS] INNER JOIN [CATEGORIES] ON ([CATEGORIES].[ID] = [ITEMS].[ID])'
     ['SELECT * FROM [ITEMS] INNER JOIN [CATEGORIES] ON (([CATEGORIES].[ID1] = [ITEMS].[ID1]) AND ([CATEGORIES].[ID2] = [ITEMS].[ID2]))',
       'SELECT * FROM [ITEMS] INNER JOIN [CATEGORIES] ON (([CATEGORIES].[ID2] = [ITEMS].[ID2]) AND ([CATEGORIES].[ID1] = [ITEMS].[ID1]))'].
-      should include(DB[:items].join(:categories, [:id1, :id2]).sql)
-    DB[:items___i].join(:categories___c, [:id]).sql.should ==
-      'SELECT * FROM [ITEMS] AS [I] INNER JOIN [CATEGORIES] AS [C] ON ([C].[ID] = [I].[ID])'
+      must_include(DB[:items].join(:categories, [:id1, :id2]).sql)
+    DB[:items___i].join(:categories___c, [:id]).sql.must_equal 'SELECT * FROM [ITEMS] AS [I] INNER JOIN [CATEGORIES] AS [C] ON ([C].[ID] = [I].[ID])'
   end
 end
 
@@ -122,70 +120,58 @@ describe "MSSQL Dataset#output" do
     @db.drop_table?(:items, :out)
   end
 
-  specify "should format OUTPUT clauses without INTO for DELETE statements" do
-    @ds.output(nil, [:deleted__name, :deleted__value]).delete_sql.should =~
-      /DELETE FROM \[ITEMS\] OUTPUT \[DELETED\].\[(NAME|VALUE)\], \[DELETED\].\[(NAME|VALUE)\]/
-    @ds.output(nil, [Sequel::SQL::ColumnAll.new(:deleted)]).delete_sql.should =~
-      /DELETE FROM \[ITEMS\] OUTPUT \[DELETED\].*/
+  it "should format OUTPUT clauses without INTO for DELETE statements" do
+    @ds.output(nil, [:deleted__name, :deleted__value]).delete_sql.must_match(/DELETE FROM \[ITEMS\] OUTPUT \[DELETED\].\[(NAME|VALUE)\], \[DELETED\].\[(NAME|VALUE)\]/)
+    @ds.output(nil, [Sequel::SQL::ColumnAll.new(:deleted)]).delete_sql.must_match(/DELETE FROM \[ITEMS\] OUTPUT \[DELETED\].*/)
   end
   
-  specify "should format OUTPUT clauses with INTO for DELETE statements" do
-    @ds.output(:out, [:deleted__name, :deleted__value]).delete_sql.should =~
-      /DELETE FROM \[ITEMS\] OUTPUT \[DELETED\].\[(NAME|VALUE)\], \[DELETED\].\[(NAME|VALUE)\] INTO \[OUT\]/
-    @ds.output(:out, {:name => :deleted__name, :value => :deleted__value}).delete_sql.should =~
-      /DELETE FROM \[ITEMS\] OUTPUT \[DELETED\].\[(NAME|VALUE)\], \[DELETED\].\[(NAME|VALUE)\] INTO \[OUT\] \(\[(NAME|VALUE)\], \[(NAME|VALUE)\]\)/
+  it "should format OUTPUT clauses with INTO for DELETE statements" do
+    @ds.output(:out, [:deleted__name, :deleted__value]).delete_sql.must_match(/DELETE FROM \[ITEMS\] OUTPUT \[DELETED\].\[(NAME|VALUE)\], \[DELETED\].\[(NAME|VALUE)\] INTO \[OUT\]/)
+    @ds.output(:out, {:name => :deleted__name, :value => :deleted__value}).delete_sql.must_match(/DELETE FROM \[ITEMS\] OUTPUT \[DELETED\].\[(NAME|VALUE)\], \[DELETED\].\[(NAME|VALUE)\] INTO \[OUT\] \(\[(NAME|VALUE)\], \[(NAME|VALUE)\]\)/)
   end
 
-  specify "should format OUTPUT clauses without INTO for INSERT statements" do
-    @ds.output(nil, [:inserted__name, :inserted__value]).insert_sql(:name => "name", :value => 1).should =~
-      /INSERT INTO \[ITEMS\] \(\[(NAME|VALUE)\], \[(NAME|VALUE)\]\) OUTPUT \[INSERTED\].\[(NAME|VALUE)\], \[INSERTED\].\[(NAME|VALUE)\] VALUES \((N'name'|1), (N'name'|1)\)/
-    @ds.output(nil, [Sequel::SQL::ColumnAll.new(:inserted)]).insert_sql(:name => "name", :value => 1).should =~
-      /INSERT INTO \[ITEMS\] \(\[(NAME|VALUE)\], \[(NAME|VALUE)\]\) OUTPUT \[INSERTED\].* VALUES \((N'name'|1), (N'name'|1)\)/
+  it "should format OUTPUT clauses without INTO for INSERT statements" do
+    @ds.output(nil, [:inserted__name, :inserted__value]).insert_sql(:name => "name", :value => 1).must_match(/INSERT INTO \[ITEMS\] \(\[(NAME|VALUE)\], \[(NAME|VALUE)\]\) OUTPUT \[INSERTED\].\[(NAME|VALUE)\], \[INSERTED\].\[(NAME|VALUE)\] VALUES \((N'name'|1), (N'name'|1)\)/)
+    @ds.output(nil, [Sequel::SQL::ColumnAll.new(:inserted)]).insert_sql(:name => "name", :value => 1).must_match(/INSERT INTO \[ITEMS\] \(\[(NAME|VALUE)\], \[(NAME|VALUE)\]\) OUTPUT \[INSERTED\].* VALUES \((N'name'|1), (N'name'|1)\)/)
   end
 
-  specify "should format OUTPUT clauses with INTO for INSERT statements" do
-    @ds.output(:out, [:inserted__name, :inserted__value]).insert_sql(:name => "name", :value => 1).should =~
-      /INSERT INTO \[ITEMS\] \((\[NAME\]|\[VALUE\]), (\[NAME\]|\[VALUE\])\) OUTPUT \[INSERTED\].\[(NAME|VALUE)\], \[INSERTED\].\[(NAME|VALUE)\] INTO \[OUT\] VALUES \((N'name'|1), (N'name'|1)\)/
-    @ds.output(:out, {:name => :inserted__name, :value => :inserted__value}).insert_sql(:name => "name", :value => 1).should =~
-      /INSERT INTO \[ITEMS\] \(\[(NAME|VALUE)\], \[(NAME|VALUE)\]\) OUTPUT \[INSERTED\].\[(NAME|VALUE)\], \[INSERTED\].\[(NAME|VALUE)\] INTO \[OUT\] \(\[(NAME|VALUE)\], \[(NAME|VALUE)\]\) VALUES \((N'name'|1), (N'name'|1)\)/
+  it "should format OUTPUT clauses with INTO for INSERT statements" do
+    @ds.output(:out, [:inserted__name, :inserted__value]).insert_sql(:name => "name", :value => 1).must_match(/INSERT INTO \[ITEMS\] \((\[NAME\]|\[VALUE\]), (\[NAME\]|\[VALUE\])\) OUTPUT \[INSERTED\].\[(NAME|VALUE)\], \[INSERTED\].\[(NAME|VALUE)\] INTO \[OUT\] VALUES \((N'name'|1), (N'name'|1)\)/)
+    @ds.output(:out, {:name => :inserted__name, :value => :inserted__value}).insert_sql(:name => "name", :value => 1).must_match(/INSERT INTO \[ITEMS\] \(\[(NAME|VALUE)\], \[(NAME|VALUE)\]\) OUTPUT \[INSERTED\].\[(NAME|VALUE)\], \[INSERTED\].\[(NAME|VALUE)\] INTO \[OUT\] \(\[(NAME|VALUE)\], \[(NAME|VALUE)\]\) VALUES \((N'name'|1), (N'name'|1)\)/)
   end
 
-  specify "should format OUTPUT clauses without INTO for UPDATE statements" do
-    @ds.output(nil, [:inserted__name, :deleted__value]).update_sql(:value => 2).should =~
-      /UPDATE \[ITEMS\] SET \[VALUE\] = 2 OUTPUT \[(INSERTED\].\[NAME|DELETED\].\[VALUE)\], \[(INSERTED\].\[NAME|DELETED\].\[VALUE)\]/
-    @ds.output(nil, [Sequel::SQL::ColumnAll.new(:inserted)]).update_sql(:value => 2).should =~
-      /UPDATE \[ITEMS\] SET \[VALUE\] = 2 OUTPUT \[INSERTED\].*/
+  it "should format OUTPUT clauses without INTO for UPDATE statements" do
+    @ds.output(nil, [:inserted__name, :deleted__value]).update_sql(:value => 2).must_match(/UPDATE \[ITEMS\] SET \[VALUE\] = 2 OUTPUT \[(INSERTED\].\[NAME|DELETED\].\[VALUE)\], \[(INSERTED\].\[NAME|DELETED\].\[VALUE)\]/)
+    @ds.output(nil, [Sequel::SQL::ColumnAll.new(:inserted)]).update_sql(:value => 2).must_match(/UPDATE \[ITEMS\] SET \[VALUE\] = 2 OUTPUT \[INSERTED\].*/)
   end
 
-  specify "should format OUTPUT clauses with INTO for UPDATE statements" do
-    @ds.output(:out, [:inserted__name, :deleted__value]).update_sql(:value => 2).should =~
-      /UPDATE \[ITEMS\] SET \[VALUE\] = 2 OUTPUT \[(INSERTED\].\[NAME|DELETED\].\[VALUE)\], \[(INSERTED\].\[NAME|DELETED\].\[VALUE)\] INTO \[OUT\]/
-    @ds.output(:out, {:name => :inserted__name, :value => :deleted__value}).update_sql(:value => 2).should =~
-      /UPDATE \[ITEMS\] SET \[VALUE\] = 2 OUTPUT \[(INSERTED\].\[NAME|DELETED\].\[VALUE)\], \[(INSERTED\].\[NAME|DELETED\].\[VALUE)\] INTO \[OUT\] \(\[(NAME|VALUE)\], \[(NAME|VALUE)\]\)/
+  it "should format OUTPUT clauses with INTO for UPDATE statements" do
+    @ds.output(:out, [:inserted__name, :deleted__value]).update_sql(:value => 2).must_match(/UPDATE \[ITEMS\] SET \[VALUE\] = 2 OUTPUT \[(INSERTED\].\[NAME|DELETED\].\[VALUE)\], \[(INSERTED\].\[NAME|DELETED\].\[VALUE)\] INTO \[OUT\]/)
+    @ds.output(:out, {:name => :inserted__name, :value => :deleted__value}).update_sql(:value => 2).must_match(/UPDATE \[ITEMS\] SET \[VALUE\] = 2 OUTPUT \[(INSERTED\].\[NAME|DELETED\].\[VALUE)\], \[(INSERTED\].\[NAME|DELETED\].\[VALUE)\] INTO \[OUT\] \(\[(NAME|VALUE)\], \[(NAME|VALUE)\]\)/)
   end
 
-  specify "should execute OUTPUT clauses in DELETE statements" do
+  it "should execute OUTPUT clauses in DELETE statements" do
     @ds.insert(:name => "name", :value => 1)
     @ds.output(:out, [:deleted__name, :deleted__value]).delete
-    @db[:out].all.should == [{:name => "name", :value => 1}]
+    @db[:out].all.must_equal [{:name => "name", :value => 1}]
     @ds.insert(:name => "name", :value => 2)
     @ds.output(:out, {:name => :deleted__name, :value => :deleted__value}).delete
-    @db[:out].all.should == [{:name => "name", :value => 1}, {:name => "name", :value => 2}]
+    @db[:out].all.must_equal [{:name => "name", :value => 1}, {:name => "name", :value => 2}]
   end
 
-  specify "should execute OUTPUT clauses in INSERT statements" do
+  it "should execute OUTPUT clauses in INSERT statements" do
     @ds.output(:out, [:inserted__name, :inserted__value]).insert(:name => "name", :value => 1)
-    @db[:out].all.should == [{:name => "name", :value => 1}]
+    @db[:out].all.must_equal [{:name => "name", :value => 1}]
     @ds.output(:out, {:name => :inserted__name, :value => :inserted__value}).insert(:name => "name", :value => 2)
-    @db[:out].all.should == [{:name => "name", :value => 1}, {:name => "name", :value => 2}]
+    @db[:out].all.must_equal [{:name => "name", :value => 1}, {:name => "name", :value => 2}]
   end
 
-  specify "should execute OUTPUT clauses in UPDATE statements" do
+  it "should execute OUTPUT clauses in UPDATE statements" do
     @ds.insert(:name => "name", :value => 1)
     @ds.output(:out, [:inserted__name, :deleted__value]).update(:value => 2)
-    @db[:out].all.should == [{:name => "name", :value => 1}]
+    @db[:out].all.must_equal [{:name => "name", :value => 1}]
     @ds.output(:out, {:name => :inserted__name, :value => :deleted__value}).update(:value => 3)
-    @db[:out].all.should == [{:name => "name", :value => 1}, {:name => "name", :value => 2}]
+    @db[:out].all.must_equal [{:name => "name", :value => 1}, {:name => "name", :value => 2}]
   end
 end
 
@@ -197,24 +183,24 @@ describe "MSSQL dataset using #with and #with_recursive" do
       @ds2 = @ds.with_recursive(:t, @db[:x], @db[:t])
   end
 
-  specify "should prepend UPDATE statements with WITH clause" do
-    @ds1.update_sql(:x => :y).should == 'WITH [T] AS (SELECT * FROM [X]) UPDATE [T] SET [X] = [Y]'
-    @ds2.update_sql(:x => :y).should == 'WITH [T] AS (SELECT * FROM [X] UNION ALL SELECT * FROM [T]) UPDATE [T] SET [X] = [Y]'
+  it "should prepend UPDATE statements with WITH clause" do
+    @ds1.update_sql(:x => :y).must_equal 'WITH [T] AS (SELECT * FROM [X]) UPDATE [T] SET [X] = [Y]'
+    @ds2.update_sql(:x => :y).must_equal 'WITH [T] AS (SELECT * FROM [X] UNION ALL SELECT * FROM [T]) UPDATE [T] SET [X] = [Y]'
   end
 
-  specify "should prepend DELETE statements with WITH clause" do
-    @ds1.filter(:y => 1).delete_sql.should == 'WITH [T] AS (SELECT * FROM [X]) DELETE FROM [T] WHERE ([Y] = 1)'
-    @ds2.filter(:y => 1).delete_sql.should == 'WITH [T] AS (SELECT * FROM [X] UNION ALL SELECT * FROM [T]) DELETE FROM [T] WHERE ([Y] = 1)'
+  it "should prepend DELETE statements with WITH clause" do
+    @ds1.filter(:y => 1).delete_sql.must_equal 'WITH [T] AS (SELECT * FROM [X]) DELETE FROM [T] WHERE ([Y] = 1)'
+    @ds2.filter(:y => 1).delete_sql.must_equal 'WITH [T] AS (SELECT * FROM [X] UNION ALL SELECT * FROM [T]) DELETE FROM [T] WHERE ([Y] = 1)'
   end
 
-  specify "should prepend INSERT statements with WITH clause" do
-    @ds1.insert_sql(@db[:t]).should == 'WITH [T] AS (SELECT * FROM [X]) INSERT INTO [T] SELECT * FROM [T]'
-    @ds2.insert_sql(@db[:t]).should == 'WITH [T] AS (SELECT * FROM [X] UNION ALL SELECT * FROM [T]) INSERT INTO [T] SELECT * FROM [T]'
+  it "should prepend INSERT statements with WITH clause" do
+    @ds1.insert_sql(@db[:t]).must_equal 'WITH [T] AS (SELECT * FROM [X]) INSERT INTO [T] SELECT * FROM [T]'
+    @ds2.insert_sql(@db[:t]).must_equal 'WITH [T] AS (SELECT * FROM [X] UNION ALL SELECT * FROM [T]) INSERT INTO [T] SELECT * FROM [T]'
   end
 
-  specify "should move WITH clause on joined dataset to top level" do
-    @db[:s].inner_join(@ds1).sql.should == "WITH [T] AS (SELECT * FROM [X]) SELECT * FROM [S] INNER JOIN (SELECT * FROM [T]) AS [T1]"
-    @ds1.inner_join(@db[:s].with(:s, @db[:y])).sql.should == "WITH [T] AS (SELECT * FROM [X]), [S] AS (SELECT * FROM [Y]) SELECT * FROM [T] INNER JOIN (SELECT * FROM [S]) AS [T1]"
+  it "should move WITH clause on joined dataset to top level" do
+    @db[:s].inner_join(@ds1).sql.must_equal "WITH [T] AS (SELECT * FROM [X]) SELECT * FROM [S] INNER JOIN (SELECT * FROM [T]) AS [T1]"
+    @ds1.inner_join(@db[:s].with(:s, @db[:y])).sql.must_equal "WITH [T] AS (SELECT * FROM [X]), [S] AS (SELECT * FROM [Y]) SELECT * FROM [T] INNER JOIN (SELECT * FROM [S]) AS [T1]"
   end
 end
 
@@ -228,16 +214,16 @@ describe "MSSQL::Dataset#import" do
     @db.drop_table?(:test)
   end
   
-  specify "#import should work correctly with an arbitrary output value" do
+  it "#import should work correctly with an arbitrary output value" do
     @db.create_table!(:test){primary_key :x; Integer :y}
-    @ds.output(nil, [:inserted__y, :inserted__x]).import([:y], [[3], [4]]).should == [{:y=>3, :x=>1}, {:y=>4, :x=>2}]
-    @ds.all.should == [{:x=>1, :y=>3}, {:x=>2, :y=>4}]
+    @ds.output(nil, [:inserted__y, :inserted__x]).import([:y], [[3], [4]]).must_equal [{:y=>3, :x=>1}, {:y=>4, :x=>2}]
+    @ds.all.must_equal [{:x=>1, :y=>3}, {:x=>2, :y=>4}]
   end
 
-  specify "should handle WITH statements" do
+  it "should handle WITH statements" do
     @db.create_table!(:test){Integer :x; Integer :y}
     @db[:testx].with(:testx, @db[:test]).import([:x, :y], [[1, 2], [3, 4], [5, 6]], :slice => 2)
-    @ds.select_order_map([:x, :y]).should == [[1, 2], [3, 4], [5, 6]]
+    @ds.select_order_map([:x, :y]).must_equal [[1, 2], [3, 4], [5, 6]]
   end
 end
 
@@ -246,14 +232,12 @@ describe "MSSQL joined datasets" do
     @db = DB
   end
 
-  specify "should format DELETE statements" do
-    @db[:t1].inner_join(:t2, :t1__pk => :t2__pk).delete_sql.should ==
-      "DELETE FROM [T1] FROM [T1] INNER JOIN [T2] ON ([T1].[PK] = [T2].[PK])"
+  it "should format DELETE statements" do
+    @db[:t1].inner_join(:t2, :t1__pk => :t2__pk).delete_sql.must_equal "DELETE FROM [T1] FROM [T1] INNER JOIN [T2] ON ([T1].[PK] = [T2].[PK])"
   end
 
-  specify "should format UPDATE statements" do
-    @db[:t1].inner_join(:t2, :t1__pk => :t2__pk).update_sql(:pk => :t2__pk).should ==
-      "UPDATE [T1] SET [PK] = [T2].[PK] FROM [T1] INNER JOIN [T2] ON ([T1].[PK] = [T2].[PK])"
+  it "should format UPDATE statements" do
+    @db[:t1].inner_join(:t2, :t1__pk => :t2__pk).update_sql(:pk => :t2__pk).must_equal "UPDATE [T1] SET [PK] = [T2].[PK] FROM [T1] INNER JOIN [T2] ON ([T1].[PK] = [T2].[PK])"
   end
 end
 
@@ -270,13 +254,13 @@ describe "Offset support" do
     @db.drop_table?(:i)
   end
   
-  specify "should return correct rows" do
-    @ds.limit(2, 2).all.should == [{:id=>6, :parent_id=>3}, {:id=>8, :parent_id=>3}]
+  it "should return correct rows" do
+    @ds.limit(2, 2).all.must_equal [{:id=>6, :parent_id=>3}, {:id=>8, :parent_id=>3}]
   end
   
-  specify "should not include offset column in hashes passed to row_proc" do
+  it "should not include offset column in hashes passed to row_proc" do
     @ds.limit(2, 2).all
-    @hs.should == [{:id=>3, :parent_id=>1}, {:id=>4, :parent_id=>1}]
+    @hs.must_equal [{:id=>3, :parent_id=>1}, {:id=>4, :parent_id=>1}]
   end
 end
 
@@ -293,62 +277,62 @@ describe "Common Table Expressions" do
     @db.drop_table?(:i1, :i2)
   end
 
-  specify "using #with should be able to update" do
+  it "using #with should be able to update" do
     @ds.insert(:id=>1)
     @ds2.insert(:id=>2, :parent_id=>1)
     @ds2.insert(:id=>3, :parent_id=>2)
     @ds.with(:t, @ds2).filter(:id => @db[:t].select(:id)).update(:parent_id => @db[:t].filter(:id => :i1__id).select(:parent_id).limit(1))
-    @ds[:id => 1].should == {:id => 1, :parent_id => nil}
-    @ds[:id => 2].should == {:id => 2, :parent_id => 1}
-    @ds[:id => 3].should == {:id => 3, :parent_id => 2}
-    @ds[:id => 4].should == {:id => 4, :parent_id => 1}
+    @ds[:id => 1].must_equal(:id => 1, :parent_id => nil)
+    @ds[:id => 2].must_equal(:id => 2, :parent_id => 1)
+    @ds[:id => 3].must_equal(:id => 3, :parent_id => 2)
+    @ds[:id => 4].must_equal(:id => 4, :parent_id => 1)
   end
 
-  specify "using #with_recursive should be able to update" do
+  it "using #with_recursive should be able to update" do
     ds = @ds.with_recursive(:t, @ds.filter(:parent_id=>1).or(:id => 1), @ds.join(:t, :i=>:parent_id).select(:i1__id, :i1__parent_id), :args=>[:i, :pi])
     ds.exclude(:id => @db[:t].select(:i)).update(:parent_id => 1)
-    @ds[:id => 1].should == {:id => 1, :parent_id => nil}
-    @ds[:id => 2].should == {:id => 2, :parent_id => 1}
-    @ds[:id => 5].should == {:id => 5, :parent_id => 3}
+    @ds[:id => 1].must_equal(:id => 1, :parent_id => nil)
+    @ds[:id => 2].must_equal(:id => 2, :parent_id => 1)
+    @ds[:id => 5].must_equal(:id => 5, :parent_id => 3)
   end
 
-  specify "using #with should be able to insert" do
+  it "using #with should be able to insert" do
     @ds2.insert(:id=>7)
     @ds.with(:t, @ds2).insert(@db[:t])
-    @ds[:id => 7].should == {:id => 7, :parent_id => nil}
+    @ds[:id => 7].must_equal(:id => 7, :parent_id => nil)
   end
 
-  specify "using #with_recursive should be able to insert" do
+  it "using #with_recursive should be able to insert" do
     ds = @ds2.with_recursive(:t, @ds.filter(:parent_id=>1), @ds.join(:t, :i=>:parent_id).select(:i1__id, :i1__parent_id), :args=>[:i, :pi])
     ds.insert @db[:t]
-    @ds2.all.should == [{:id => 3, :parent_id => 1}, {:id => 4, :parent_id => 1}, {:id => 5, :parent_id => 3}, {:id => 6, :parent_id => 5}]
+    @ds2.all.must_equal [{:id => 3, :parent_id => 1}, {:id => 4, :parent_id => 1}, {:id => 5, :parent_id => 3}, {:id => 6, :parent_id => 5}]
   end
 
-  specify "using #with should be able to delete" do
+  it "using #with should be able to delete" do
     @ds2.insert(:id=>6)
     @ds2.insert(:id=>5)
     @ds2.insert(:id=>4)
     @ds.with(:t, @ds2).filter(:id => @db[:t].select(:id)).delete
-    @ds.all.should == [{:id => 1, :parent_id => nil}, {:id => 2, :parent_id => nil}, {:id => 3, :parent_id => 1}]
+    @ds.all.must_equal [{:id => 1, :parent_id => nil}, {:id => 2, :parent_id => nil}, {:id => 3, :parent_id => 1}]
   end
 
-  specify "using #with_recursive should be able to delete" do
+  it "using #with_recursive should be able to delete" do
     @ds.insert(:id=>7, :parent_id=>2)
     ds = @ds.with_recursive(:t, @ds.filter(:parent_id=>1), @ds.join(:t, :i=>:parent_id).select(:i1__id, :i1__parent_id), :args=>[:i, :pi])
     ds.filter(:i1__id => @db[:t].select(:i)).delete
-    @ds.all.should == [{:id => 1, :parent_id => nil}, {:id => 2, :parent_id => nil}, {:id => 7, :parent_id => 2}]
+    @ds.all.must_equal [{:id => 1, :parent_id => nil}, {:id => 2, :parent_id => nil}, {:id => 7, :parent_id => 2}]
   end
 
-  specify "using #with should be able to import" do
+  it "using #with should be able to import" do
     @ds2.insert(:id=>7)
     @ds.with(:t, @ds2).import [:id, :parent_id], @db[:t].select(:id, :parent_id)
-    @ds[:id => 7].should == {:id => 7, :parent_id => nil}
+    @ds[:id => 7].must_equal(:id => 7, :parent_id => nil)
   end
 
-  specify "using #with_recursive should be able to import" do
+  it "using #with_recursive should be able to import" do
     ds = @ds2.with_recursive(:t, @ds.filter(:parent_id=>1), @ds.join(:t, :i=>:parent_id).select(:i1__id, :i1__parent_id), :args=>[:i, :pi])
     ds.import [:id, :parent_id], @db[:t].select(:i, :pi)
-    @ds2.all.should == [{:id => 3, :parent_id => 1}, {:id => 4, :parent_id => 1}, {:id => 5, :parent_id => 3}, {:id => 6, :parent_id => 5}]
+    @ds2.all.must_equal [{:id => 3, :parent_id => 1}, {:id => 4, :parent_id => 1}, {:id => 5, :parent_id => 3}, {:id => 6, :parent_id => 5}]
   end
 end
 
@@ -367,31 +351,31 @@ describe "MSSSQL::Dataset#insert" do
     @db.drop_table?(:test5, :test4)
   end
 
-  specify "should have insert_select return nil if disable_insert_output is used" do
-    @ds.disable_insert_output.insert_select(:value=>10).should == nil
+  it "should have insert_select return nil if disable_insert_output is used" do
+    @ds.disable_insert_output.insert_select(:value=>10).must_equal nil
   end
   
-  specify "should have insert_select return nil if the server version is not 2005+" do
+  it "should have insert_select return nil if the server version is not 2005+" do
     def @ds.server_version() 8000760 end
-    @ds.insert_select(:value=>10).should == nil
+    @ds.insert_select(:value=>10).must_equal nil
   end
 
-  specify "should have insert_select insert the record and return the inserted record" do
+  it "should have insert_select insert the record and return the inserted record" do
     h = @ds.insert_select(:value=>10)
-    h[:value].should == 10
-    @ds.first(:xid=>h[:xid])[:value].should == 10
+    h[:value].must_equal 10
+    @ds.first(:xid=>h[:xid])[:value].must_equal 10
   end
 
-  cspecify "should allow large text and binary values", :odbc do
+  cspecify "should allow large text and binary values", [:odbc] do
     blob = Sequel::SQL::Blob.new("0" * (65*1024))
     @db[:test4].insert(:name => 'max varbinary test', :value => blob)
     b = @db[:test4].where(:name => 'max varbinary test').get(:value)
-    b.length.should == blob.length
-    b.should == blob
+    b.length.must_equal blob.length
+    b.must_equal blob
   end
 
-  specify "should play nicely with simple_select_all?" do
-    DB[:test4].disable_insert_output.send(:simple_select_all?).should == true
+  it "should play nicely with simple_select_all?" do
+    DB[:test4].disable_insert_output.send(:simple_select_all?).must_equal true
   end
 end
 
@@ -400,15 +384,15 @@ describe "MSSSQL::Dataset#into" do
     @db = DB
   end
 
-  specify "should format SELECT statement" do
-    @db[:t].into(:new).select_sql.should == "SELECT * INTO [NEW] FROM [T]"
+  it "should format SELECT statement" do
+    @db[:t].into(:new).select_sql.must_equal "SELECT * INTO [NEW] FROM [T]"
   end
 
-  specify "should select rows into a new table" do
+  it "should select rows into a new table" do
     @db.create_table!(:t) {Integer :id; String :value}
     @db[:t].insert(:id => 1, :value => "test")
     @db << @db[:t].into(:new).select_sql
-    @db[:new].all.should == [{:id => 1, :value => "test"}]
+    @db[:new].all.must_equal [{:id => 1, :value => "test"}]
     @db.drop_table?(:t, :new)
   end
 end
@@ -421,21 +405,21 @@ describe "A MSSQL database" do
     @db.drop_table?(:a)
   end
   
-  specify "should handle many existing types for set_column_allow_null" do
+  it "should handle many existing types for set_column_allow_null" do
     @db.create_table!(:a){column :a, 'integer'}
     @db.alter_table(:a){set_column_allow_null :a, false}
     @db.create_table!(:a){column :a, 'decimal(24, 2)'}
     @db.alter_table(:a){set_column_allow_null :a, false}
-    @db.schema(:a).first.last[:column_size].should == 24
-    @db.schema(:a).first.last[:scale].should == 2
+    @db.schema(:a).first.last[:column_size].must_equal 24
+    @db.schema(:a).first.last[:scale].must_equal 2
     @db.create_table!(:a){column :a, 'decimal(10)'}
-    @db.schema(:a).first.last[:column_size].should == 10
-    @db.schema(:a).first.last[:scale].should == 0
+    @db.schema(:a).first.last[:column_size].must_equal 10
+    @db.schema(:a).first.last[:scale].must_equal 0
     @db.alter_table(:a){set_column_allow_null :a, false}
     @db.create_table!(:a){column :a, 'nchar(2)'}
     @db.alter_table(:a){set_column_allow_null :a, false}
     s = @db.schema(:a).first.last
-    (s[:max_chars] || s[:column_size]).should == 2
+    (s[:max_chars] || s[:column_size]).must_equal 2
   end
 end
 
@@ -444,16 +428,16 @@ describe "MSSQL::Database#rename_table" do
     DB.drop_table?(:foo)
   end
 
-  specify "should work on non-schema bound tables which need escaping" do
+  it "should work on non-schema bound tables which need escaping" do
     DB.quote_identifiers = true
     DB.create_table! :'foo bar' do
       text :name
     end
     DB.drop_table? :foo
-    proc { DB.rename_table 'foo bar', 'foo' }.should_not raise_error
+    DB.rename_table 'foo bar', 'foo'
   end
   
-  specify "should work on schema bound tables" do
+  it "should work on schema bound tables" do
     DB.execute(<<-SQL)
       IF NOT EXISTS (SELECT * FROM sys.schemas WHERE name = 'MY')
         EXECUTE sp_executesql N'create schema MY'
@@ -461,26 +445,26 @@ describe "MSSQL::Database#rename_table" do
     DB.create_table! :MY__foo do
       text :name
     end
-    proc { DB.rename_table :MY__foo, :MY__bar }.should_not raise_error
-    proc { DB.rename_table :MY__bar, :foo }.should_not raise_error
+    DB.rename_table :MY__foo, :MY__bar
+    DB.rename_table :MY__bar, :foo
   end
 end
 
 describe "MSSQL::Dataset#count" do
-  specify "should work with a distinct query with an order clause" do
+  it "should work with a distinct query with an order clause" do
     DB.create_table!(:items){String :name; Integer :value}
     DB[:items].insert(:name => "name", :value => 1)
     DB[:items].insert(:name => "name", :value => 1)
-    DB[:items].select(:name, :value).distinct.order(:name).count.should == 1
-    DB[:items].select(:name, :value).group(:name, :value).order(:name).count.should == 1
+    DB[:items].select(:name, :value).distinct.order(:name).count.must_equal 1
+    DB[:items].select(:name, :value).group(:name, :value).order(:name).count.must_equal 1
   end
 end
 
 describe "MSSQL::Database#create_table" do
-  specify "should support collate with various other column options" do
+  it "should support collate with various other column options" do
     DB.create_table!(:items){ String :name, :size => 128, :collate => :sql_latin1_general_cp1_ci_as, :default => 'foo', :null => false, :unique => true}
     DB[:items].insert
-    DB[:items].select_map(:name).should == ["foo"]
+    DB[:items].select_map(:name).must_equal ["foo"]
   end
 end
 
@@ -493,21 +477,21 @@ describe "MSSQL::Database#mssql_unicode_strings = false" do
     DB.mssql_unicode_strings = true
   end
 
-  specify "should work correctly" do
+  it "should work correctly" do
     DB.create_table!(:items){String :name}
-    DB[:items].mssql_unicode_strings.should == false
+    DB[:items].mssql_unicode_strings.must_equal false
     DB[:items].insert(:name=>'foo')
-    DB[:items].select_map(:name).should == ['foo']
+    DB[:items].select_map(:name).must_equal ['foo']
   end
 
-  specify "should be overridable at the dataset level" do
+  it "should be overridable at the dataset level" do
     DB.create_table!(:items){String :name}
     ds = DB[:items]
-    ds.mssql_unicode_strings.should == false
+    ds.mssql_unicode_strings.must_equal false
     ds.mssql_unicode_strings = true
-    ds.mssql_unicode_strings.should == true
+    ds.mssql_unicode_strings.must_equal true
     ds.insert(:name=>'foo')
-    ds.select_map(:name).should == ['foo']
+    ds.select_map(:name).must_equal ['foo']
   end
 end
 
@@ -526,11 +510,11 @@ describe "A MSSQL database adds index with include" do
     @db.drop_table? @table_name
   end
 
-  cspecify "should be able add index with include" do
+  it "should be able add index with include" do
     @db.alter_table @table_name do
       add_index [:col1], :include => [:col2,:col3]
     end
-    @db.indexes(@table_name).should have_key("#{@table_name}_col1_index".to_sym)
+    @db.indexes(@table_name).keys.must_include("#{@table_name}_col1_index".to_sym)
   end
 end
 
@@ -543,10 +527,10 @@ describe "MSSQL::Database#drop_column with a schema" do
     DB.run "drop schema test" rescue nil
   end
 
-  specify "drops columns with a default value" do
+  it "drops columns with a default value" do
     DB.create_table!(:test__items){ Integer :id; String :name, :default => 'widget' }
     DB.drop_column(:test__items, :name)
-    DB[:test__items].columns.should == [:id]
+    DB[:test__items].columns.must_equal [:id]
   end
 end
 
@@ -576,7 +560,7 @@ describe "Database#foreign_key_list" do
     DB.drop_table :items
   end
   it "should support typical foreign keys" do
-    DB.foreign_key_list(:prices).should == [{:name      => :fk_prices_items, 
+    DB.foreign_key_list(:prices).must_equal [{:name      => :fk_prices_items, 
                                                    :table     => :items, 
                                                    :columns   => [:item_id], 
                                                    :key       => [:id], 
@@ -584,7 +568,7 @@ describe "Database#foreign_key_list" do
                                                    :on_delete => :no_action }]
   end
   it "should support a foreign key with multiple columns" do
-    DB.foreign_key_list(:sales).should == [{:name      => :fk_sales_prices, 
+    DB.foreign_key_list(:sales).must_equal [{:name      => :fk_sales_prices, 
                                                   :table     => :prices, 
                                                   :columns   => [:price_item_id, :price_valid_from], 
                                                   :key       => [:item_id, :valid_from], 
@@ -592,7 +576,7 @@ describe "Database#foreign_key_list" do
                                                   :on_delete => :cascade }]
   end
 
-  context "with multiple schemas" do
+  describe "with multiple schemas" do
     before(:all) do
       DB.execute_ddl "create schema vendor"
       DB.create_table! :vendor__vendors do
@@ -612,7 +596,7 @@ describe "Database#foreign_key_list" do
       DB.execute_ddl "drop schema vendor"
     end
     it "should support mixed schema bound tables" do
- DB.foreign_key_list(:vendor__mapping).sort_by{|h| h[:name].to_s}.should == [{:name => :fk_mapping_item, :table => :items, :columns => [:item_id], :key => [:id], :on_update => :no_action, :on_delete => :no_action }, {:name => :fk_mapping_vendor, :table => Sequel.qualify(:vendor, :vendors), :columns => [:vendor_id], :key => [:id], :on_update => :no_action, :on_delete => :no_action }]
+ DB.foreign_key_list(:vendor__mapping).sort_by{|h| h[:name].to_s}.must_equal [{:name => :fk_mapping_item, :table => :items, :columns => [:item_id], :key => [:id], :on_update => :no_action, :on_delete => :no_action }, {:name => :fk_mapping_vendor, :table => Sequel.qualify(:vendor, :vendors), :columns => [:vendor_id], :key => [:id], :on_update => :no_action, :on_delete => :no_action }]
     end
   end
 end
@@ -636,11 +620,11 @@ describe "MSSQL optimistic locking plugin" do
     o = c.create(:name=>'test')
     o2 = c.first
     ts = o.timestamp
-    ts.should_not be_nil
+    ts.wont_equal nil
     o.name = 'test2'
     o.save
-    o.timestamp.should_not == ts
-    proc{o2.save}.should raise_error(Sequel::NoExistingObject)
+    o.timestamp.wont_equal ts
+    proc{o2.save}.must_raise(Sequel::NoExistingObject)
   end
 end unless DB.adapter_scheme == :odbc
 
@@ -659,24 +643,24 @@ describe "MSSQL Stored Procedure support" do
   describe "with unnamed parameters" do
     it "should return a hash of output variables" do
       r = @db.call_mssql_sproc(:SequelTest, {:args => [@now, 1, :output, :output]})
-      r.should be_a_kind_of(Hash)
-      r.values_at(:var2, :var3).should == [@now, '1']
+      r.must_be_kind_of(Hash)
+      r.values_at(:var2, :var3).must_equal [@now, '1']
     end
 
     it "should support typed output variables" do
-      @db.call_mssql_sproc(:SequelTest, {:args => [@now, 1, :output, [:output, 'int']]})[:var3].should == 1
+      @db.call_mssql_sproc(:SequelTest, {:args => [@now, 1, :output, [:output, 'int']]})[:var3].must_equal 1
     end
 
     it "should support named output variables" do
-      @db.call_mssql_sproc(:SequelTest, {:args => [@now, 1, [:output, nil, 'output'], :output]})[:output].should == @now
+      @db.call_mssql_sproc(:SequelTest, {:args => [@now, 1, [:output, nil, 'output'], :output]})[:output].must_equal @now
     end
 
     it "should return the number of Affected Rows" do
-      @db.call_mssql_sproc(:SequelTest, {:args => [@now, 1, :output, :output]})[:numrows].should == 1
+      @db.call_mssql_sproc(:SequelTest, {:args => [@now, 1, :output, :output]})[:numrows].must_equal 1
     end
 
     it "should return the Result Code" do
-      @db.call_mssql_sproc(:SequelTest, {:args => [@now, 1, :output, :output]})[:result].should == 1
+      @db.call_mssql_sproc(:SequelTest, {:args => [@now, 1, :output, :output]})[:result].must_equal 1
     end
   end
 
@@ -688,8 +672,8 @@ describe "MSSQL Stored Procedure support" do
         'Output' => [:output, nil, 'output'],
         'IntegerOutput' => [:output, nil, 'integer_output']
       })
-      r.should be_a_kind_of(Hash)
-      r.values_at(:output, :integer_output).should == [@now, '1']
+      r.must_be_kind_of(Hash)
+      r.values_at(:output, :integer_output).must_equal [@now, '1']
     end
 
     it "should support typed output variables" do
@@ -698,7 +682,7 @@ describe "MSSQL Stored Procedure support" do
         'IntegerInput' => 1,
         'Output' => [:output, nil, 'output'],
         'IntegerOutput' => [:output, 'int', 'integer_output']
-      })[:integer_output].should == 1
+      })[:integer_output].must_equal 1
     end
 
     it "should return the number of Affected Rows" do
@@ -707,7 +691,7 @@ describe "MSSQL Stored Procedure support" do
         'IntegerInput' => 1,
         'Output' => [:output, nil, 'output'],
         'IntegerOutput' => [:output, nil, 'integer_output']
-      })[:numrows].should == 1
+      })[:numrows].must_equal 1
     end
 
     it "should return the Result Code" do
@@ -716,7 +700,7 @@ describe "MSSQL Stored Procedure support" do
         'IntegerInput' => 1,
         'Output' => [:output, nil, 'output'],
         'IntegerOutput' => [:output, nil, 'integer_output']
-      })[:result].should == 1
+      })[:result].must_equal 1
     end
   end
 end unless DB.adapter_scheme == :odbc