sequel 4.22.0 → 4.23.0

data/spec/extensions/constraint_validations_spec.rb

@@ -25,107 +25,107 @@ describe "constraint_validations extension" do
 
   it "should allow creating the sequel_constraint_validations table" do
     @db.create_constraint_validations_table
-    @db.sqls.should == ["CREATE TABLE sequel_constraint_validations (table varchar(255) NOT NULL, constraint_name varchar(255), validation_type varchar(255) NOT NULL, column varchar(255) NOT NULL, argument varchar(255), message varchar(255), allow_nil boolean)"]
+    @db.sqls.must_equal ["CREATE TABLE sequel_constraint_validations (table varchar(255) NOT NULL, constraint_name varchar(255), validation_type varchar(255) NOT NULL, column varchar(255) NOT NULL, argument varchar(255), message varchar(255), allow_nil boolean)"]
   end
 
   it "should allow creating the sequel_constraint_validations table with a non-default table name" do
     @db.constraint_validations_table = :foo
     @db.create_constraint_validations_table
-    @db.sqls.should == ["CREATE TABLE foo (table varchar(255) NOT NULL, constraint_name varchar(255), validation_type varchar(255) NOT NULL, column varchar(255) NOT NULL, argument varchar(255), message varchar(255), allow_nil boolean)"]
+    @db.sqls.must_equal ["CREATE TABLE foo (table varchar(255) NOT NULL, constraint_name varchar(255), validation_type varchar(255) NOT NULL, column varchar(255) NOT NULL, argument varchar(255), message varchar(255), allow_nil boolean)"]
   end
 
   it "should allow dropping the sequel_constraint_validations table" do
     @db.drop_constraint_validations_table
-    @db.sqls.should == ["DROP TABLE sequel_constraint_validations"]
+    @db.sqls.must_equal ["DROP TABLE sequel_constraint_validations"]
   end
 
   it "should allow dropping the sequel_constraint_validations table with a non-default table name" do
     @db.constraint_validations_table = :foo
     @db.drop_constraint_validations_table
-    @db.sqls.should == ["DROP TABLE foo"]
+    @db.sqls.must_equal ["DROP TABLE foo"]
   end
 
   it "should allow dropping validations for a given table" do
     @db.drop_constraint_validations_for(:table=>:foo)
-    @db.sqls.should == ["DELETE FROM sequel_constraint_validations WHERE (table = 'foo')"]
+    @db.sqls.must_equal ["DELETE FROM sequel_constraint_validations WHERE (table = 'foo')"]
   end
 
   it "should allow dropping validations for a given table and column" do
     @db.drop_constraint_validations_for(:table=>:foo, :column=>:bar)
-    @db.sqls.should == ["DELETE FROM sequel_constraint_validations WHERE ((table = 'foo') AND (column = 'bar'))"]
+    @db.sqls.must_equal ["DELETE FROM sequel_constraint_validations WHERE ((table = 'foo') AND (column = 'bar'))"]
   end
 
   it "should allow dropping validations for a given table and constraint" do
     @db.drop_constraint_validations_for(:table=>:foo, :constraint=>:bar)
-    @db.sqls.should == ["DELETE FROM sequel_constraint_validations WHERE ((table = 'foo') AND (constraint_name = 'bar'))"]
+    @db.sqls.must_equal ["DELETE FROM sequel_constraint_validations WHERE ((table = 'foo') AND (constraint_name = 'bar'))"]
   end
 
   it "should allow dropping validations for a non-default constraint_validations table" do
     @db.constraint_validations_table = :cv
     @db.drop_constraint_validations_for(:table=>:foo)
-    @db.sqls.should == ["DELETE FROM cv WHERE (table = 'foo')"]
+    @db.sqls.must_equal ["DELETE FROM cv WHERE (table = 'foo')"]
   end
 
   it "should raise an error without deleting if attempting to drop validations without table, column, or constraint" do
-    proc{@db.drop_constraint_validations_for({})}.should raise_error(Sequel::Error)
-    @db.sqls.should == []
+    proc{@db.drop_constraint_validations_for({})}.must_raise(Sequel::Error)
+    @db.sqls.must_equal []
   end
 
   it "should allow adding constraint validations via create_table validate" do
     @db.create_table(:foo){String :name; validate{presence :name}}
     sqls = @db.sqls
-    parse_insert(sqls.slice!(1)).should == {:validation_type=>"presence", :column=>"name", :table=>"foo"}
-    sqls.should == ["BEGIN", "COMMIT", "CREATE TABLE foo (name varchar(255), CHECK ((name IS NOT NULL) AND (trim(name) != '')))"]
+    parse_insert(sqls.slice!(1)).must_equal(:validation_type=>"presence", :column=>"name", :table=>"foo")
+    sqls.must_equal ["BEGIN", "COMMIT", "CREATE TABLE foo (name varchar(255), CHECK ((name IS NOT NULL) AND (trim(name) != '')))"]
   end
 
   it "should allow adding constraint validations via alter_table validate" do
     @db.schema = [[:name, {:type=>:string}]]
     @db.alter_table(:foo){validate{presence :name}}
     sqls = @db.sqls
-    parse_insert(sqls.slice!(2)).should == {:validation_type=>"presence", :column=>"name", :table=>"foo"}
-    sqls.should == ["parse schema for foo", "BEGIN", "COMMIT", "ALTER TABLE foo ADD CHECK ((name IS NOT NULL) AND (trim(name) != ''))"]
+    parse_insert(sqls.slice!(2)).must_equal(:validation_type=>"presence", :column=>"name", :table=>"foo")
+    sqls.must_equal ["parse schema for foo", "BEGIN", "COMMIT", "ALTER TABLE foo ADD CHECK ((name IS NOT NULL) AND (trim(name) != ''))"]
   end
 
   it "should handle :message option when adding validations" do
     @db.create_table(:foo){String :name; validate{presence :name, :message=>'not there'}}
     sqls = @db.sqls
-    parse_insert(sqls.slice!(1)).should == {:validation_type=>"presence", :column=>"name", :table=>"foo", :message=>'not there'}
-    sqls.should == ["BEGIN", "COMMIT", "CREATE TABLE foo (name varchar(255), CHECK ((name IS NOT NULL) AND (trim(name) != '')))"]
+    parse_insert(sqls.slice!(1)).must_equal(:validation_type=>"presence", :column=>"name", :table=>"foo", :message=>'not there')
+    sqls.must_equal ["BEGIN", "COMMIT", "CREATE TABLE foo (name varchar(255), CHECK ((name IS NOT NULL) AND (trim(name) != '')))"]
   end
 
   it "should handle :allow_nil option when adding validations" do
     @db.create_table(:foo){String :name; validate{presence :name, :allow_nil=>true}}
     sqls = @db.sqls
-    parse_insert(sqls.slice!(1)).should == {:validation_type=>"presence", :column=>"name", :table=>"foo", :allow_nil=>'t'}
-    sqls.should == ["BEGIN", "COMMIT", "CREATE TABLE foo (name varchar(255), CHECK ((name IS NULL) OR (trim(name) != '')))"]
+    parse_insert(sqls.slice!(1)).must_equal(:validation_type=>"presence", :column=>"name", :table=>"foo", :allow_nil=>'t')
+    sqls.must_equal ["BEGIN", "COMMIT", "CREATE TABLE foo (name varchar(255), CHECK ((name IS NULL) OR (trim(name) != '')))"]
   end
 
   it "should handle :name option when adding validations" do
     @db.create_table(:foo){String :name; validate{presence :name, :name=>'cons'}}
     sqls = @db.sqls
-    parse_insert(sqls.slice!(1)).should == {:validation_type=>"presence", :column=>"name", :table=>"foo", :constraint_name=>'cons'}
-    sqls.should == ["BEGIN", "COMMIT", "CREATE TABLE foo (name varchar(255), CONSTRAINT cons CHECK ((name IS NOT NULL) AND (trim(name) != '')))"]
+    parse_insert(sqls.slice!(1)).must_equal(:validation_type=>"presence", :column=>"name", :table=>"foo", :constraint_name=>'cons')
+    sqls.must_equal ["BEGIN", "COMMIT", "CREATE TABLE foo (name varchar(255), CONSTRAINT cons CHECK ((name IS NOT NULL) AND (trim(name) != '')))"]
   end
 
   it "should handle multiple columns when adding validations" do
     @db.create_table(:foo){String :name; String :bar; validate{presence [:name, :bar]}}
     sqls = @db.sqls
-    parse_insert(sqls.slice!(1)).should == {:validation_type=>"presence", :column=>"name", :table=>"foo"}
-    parse_insert(sqls.slice!(1)).should == {:validation_type=>"presence", :column=>"bar", :table=>"foo"}
-    sqls.should == ["BEGIN", "COMMIT", "CREATE TABLE foo (name varchar(255), bar varchar(255), CHECK ((name IS NOT NULL) AND (bar IS NOT NULL) AND (trim(name) != '') AND (trim(bar) != '')))"]
+    parse_insert(sqls.slice!(1)).must_equal(:validation_type=>"presence", :column=>"name", :table=>"foo")
+    parse_insert(sqls.slice!(1)).must_equal(:validation_type=>"presence", :column=>"bar", :table=>"foo")
+    sqls.must_equal ["BEGIN", "COMMIT", "CREATE TABLE foo (name varchar(255), bar varchar(255), CHECK ((name IS NOT NULL) AND (bar IS NOT NULL) AND (trim(name) != '') AND (trim(bar) != '')))"]
   end
 
   it "should handle presence validation on non-String columns" do
     @db.create_table(:foo){Integer :name; validate{presence :name}}
     sqls = @db.sqls
-    parse_insert(sqls.slice!(1)).should == {:validation_type=>"presence", :column=>"name", :table=>"foo"}
-    sqls.should == ["BEGIN", "COMMIT", "CREATE TABLE foo (name integer, CHECK (name IS NOT NULL))"]
+    parse_insert(sqls.slice!(1)).must_equal(:validation_type=>"presence", :column=>"name", :table=>"foo")
+    sqls.must_equal ["BEGIN", "COMMIT", "CREATE TABLE foo (name integer, CHECK (name IS NOT NULL))"]
 
     @db.schema = [[:name, {:type=>:integer}]]
     @db.alter_table(:foo){validate{presence :name}}
     sqls = @db.sqls
-    parse_insert(sqls.slice!(2)).should == {:validation_type=>"presence", :column=>"name", :table=>"foo"}
-    sqls.should == ["parse schema for foo", "BEGIN", "COMMIT", "ALTER TABLE foo ADD CHECK (name IS NOT NULL)"]
+    parse_insert(sqls.slice!(2)).must_equal(:validation_type=>"presence", :column=>"name", :table=>"foo")
+    sqls.must_equal ["parse schema for foo", "BEGIN", "COMMIT", "ALTER TABLE foo ADD CHECK (name IS NOT NULL)"]
   end
 
   it "should handle presence validation on Oracle with IS NOT NULL instead of != ''" do
@@ -135,61 +135,61 @@ describe "constraint_validations extension" do
     sqls = @db.sqls
     s = sqls.slice!(1)
     m = /\AINSERT INTO sequel_constraint_validations \((.*)\) SELECT (.*) FROM DUAL\z/.match(s)
-    Hash[*m[1].split(', ').map{|v| v.to_sym}.zip(m[2].split(', ').map{|v| parse_insert_value(v)}).reject{|k, v| v.nil?}.flatten].should == {:validation_type=>"presence", :column=>"name", :table=>"foo"}
-    sqls.should == ["BEGIN", "COMMIT", "CREATE TABLE foo (name varchar(255), CHECK ((name IS NOT NULL) AND (trim(name) IS NOT NULL)))"]
+    Hash[*m[1].split(', ').map{|v| v.to_sym}.zip(m[2].split(', ').map{|v| parse_insert_value(v)}).reject{|k, v| v.nil?}.flatten].must_equal(:validation_type=>"presence", :column=>"name", :table=>"foo")
+    sqls.must_equal ["BEGIN", "COMMIT", "CREATE TABLE foo (name varchar(255), CHECK ((name IS NOT NULL) AND (trim(name) IS NOT NULL)))"]
   end
 
   it "should assume column is not a String if it can't determine the type" do
     @db.create_table(:foo){Integer :name; validate{presence :bar}}
     sqls = @db.sqls
-    parse_insert(sqls.slice!(1)).should == {:validation_type=>"presence", :column=>"bar", :table=>"foo"}
-    sqls.should == ["BEGIN", "COMMIT", "CREATE TABLE foo (name integer, CHECK (bar IS NOT NULL))"]
+    parse_insert(sqls.slice!(1)).must_equal(:validation_type=>"presence", :column=>"bar", :table=>"foo")
+    sqls.must_equal ["BEGIN", "COMMIT", "CREATE TABLE foo (name integer, CHECK (bar IS NOT NULL))"]
 
     @db.schema = [[:name, {:type=>:integer}]]
     @db.alter_table(:foo){validate{presence :bar}}
     sqls = @db.sqls
-    parse_insert(sqls.slice!(2)).should == {:validation_type=>"presence", :column=>"bar", :table=>"foo"}
-    sqls.should == ["parse schema for foo", "BEGIN", "COMMIT", "ALTER TABLE foo ADD CHECK (bar IS NOT NULL)"]
+    parse_insert(sqls.slice!(2)).must_equal(:validation_type=>"presence", :column=>"bar", :table=>"foo")
+    sqls.must_equal ["parse schema for foo", "BEGIN", "COMMIT", "ALTER TABLE foo ADD CHECK (bar IS NOT NULL)"]
   end
 
   it "should handle presence validation on non-String columns with :allow_nil option" do
     @db.create_table(:foo){Integer :name; validate{presence :name, :allow_nil=>true}}
     sqls = @db.sqls
-    parse_insert(sqls.slice!(1)).should == {:validation_type=>"presence", :column=>"name", :table=>"foo", :allow_nil=>'t'}
-    sqls.should == ["BEGIN", "COMMIT", "CREATE TABLE foo (name integer)"]
+    parse_insert(sqls.slice!(1)).must_equal(:validation_type=>"presence", :column=>"name", :table=>"foo", :allow_nil=>'t')
+    sqls.must_equal ["BEGIN", "COMMIT", "CREATE TABLE foo (name integer)"]
   end
 
   it "should support :exact_length constraint validation" do
     @db.create_table(:foo){String :name; validate{exact_length 5, :name}}
     sqls = @db.sqls
-    parse_insert(sqls.slice!(1)).should == {:validation_type=>"exact_length", :column=>"name", :table=>"foo", :argument=>'5'}
-    sqls.should == ["BEGIN", "COMMIT", "CREATE TABLE foo (name varchar(255), CHECK ((name IS NOT NULL) AND (char_length(name) = 5)))"]
+    parse_insert(sqls.slice!(1)).must_equal(:validation_type=>"exact_length", :column=>"name", :table=>"foo", :argument=>'5')
+    sqls.must_equal ["BEGIN", "COMMIT", "CREATE TABLE foo (name varchar(255), CHECK ((name IS NOT NULL) AND (char_length(name) = 5)))"]
   end
 
   it "should support :min_length constraint validation" do
     @db.create_table(:foo){String :name; validate{min_length 5, :name}}
     sqls = @db.sqls
-    parse_insert(sqls.slice!(1)).should == {:validation_type=>"min_length", :column=>"name", :table=>"foo", :argument=>'5'}
-    sqls.should == ["BEGIN", "COMMIT", "CREATE TABLE foo (name varchar(255), CHECK ((name IS NOT NULL) AND (char_length(name) >= 5)))"]
+    parse_insert(sqls.slice!(1)).must_equal(:validation_type=>"min_length", :column=>"name", :table=>"foo", :argument=>'5')
+    sqls.must_equal ["BEGIN", "COMMIT", "CREATE TABLE foo (name varchar(255), CHECK ((name IS NOT NULL) AND (char_length(name) >= 5)))"]
   end
 
   it "should support :max_length constraint validation" do
     @db.create_table(:foo){String :name; validate{max_length 5, :name}}
     sqls = @db.sqls
-    parse_insert(sqls.slice!(1)).should == {:validation_type=>"max_length", :column=>"name", :table=>"foo", :argument=>'5'}
-    sqls.should == ["BEGIN", "COMMIT", "CREATE TABLE foo (name varchar(255), CHECK ((name IS NOT NULL) AND (char_length(name) <= 5)))"]
+    parse_insert(sqls.slice!(1)).must_equal(:validation_type=>"max_length", :column=>"name", :table=>"foo", :argument=>'5')
+    sqls.must_equal ["BEGIN", "COMMIT", "CREATE TABLE foo (name varchar(255), CHECK ((name IS NOT NULL) AND (char_length(name) <= 5)))"]
   end
 
   it "should support :length_range constraint validation" do
     @db.create_table(:foo){String :name; validate{length_range 3..5, :name}}
     sqls = @db.sqls
-    parse_insert(sqls.slice!(1)).should == {:validation_type=>"length_range", :column=>"name", :table=>"foo", :argument=>'3..5'}
-    sqls.should == ["BEGIN", "COMMIT", "CREATE TABLE foo (name varchar(255), CHECK ((name IS NOT NULL) AND (char_length(name) >= 3) AND (char_length(name) <= 5)))"]
+    parse_insert(sqls.slice!(1)).must_equal(:validation_type=>"length_range", :column=>"name", :table=>"foo", :argument=>'3..5')
+    sqls.must_equal ["BEGIN", "COMMIT", "CREATE TABLE foo (name varchar(255), CHECK ((name IS NOT NULL) AND (char_length(name) >= 3) AND (char_length(name) <= 5)))"]
 
     @db.create_table(:foo){String :name; validate{length_range 3...5, :name}}
     sqls = @db.sqls
-    parse_insert(sqls.slice!(1)).should == {:validation_type=>"length_range", :column=>"name", :table=>"foo", :argument=>'3...5'}
-    sqls.should == ["BEGIN", "COMMIT", "CREATE TABLE foo (name varchar(255), CHECK ((name IS NOT NULL) AND (char_length(name) >= 3) AND (char_length(name) < 5)))"]
+    parse_insert(sqls.slice!(1)).must_equal(:validation_type=>"length_range", :column=>"name", :table=>"foo", :argument=>'3...5')
+    sqls.must_equal ["BEGIN", "COMMIT", "CREATE TABLE foo (name varchar(255), CHECK ((name IS NOT NULL) AND (char_length(name) >= 3) AND (char_length(name) < 5)))"]
   end
 
   it "should support :format constraint validation" do
@@ -197,8 +197,8 @@ describe "constraint_validations extension" do
     @db.extension(:constraint_validations)
     @db.create_table(:foo){String :name; validate{format(/^foo.*/, :name)}}
     sqls = @db.sqls
-    parse_insert(sqls.slice!(1)).should == {:validation_type=>"format", :column=>"name", :table=>"foo", :argument=>'^foo.*'}
-    sqls.should == ["BEGIN", "COMMIT", "CREATE TABLE foo (name text, CHECK ((name IS NOT NULL) AND (name ~ '^foo.*')))"]
+    parse_insert(sqls.slice!(1)).must_equal(:validation_type=>"format", :column=>"name", :table=>"foo", :argument=>'^foo.*')
+    sqls.must_equal ["BEGIN", "COMMIT", "CREATE TABLE foo (name text, CHECK ((name IS NOT NULL) AND (name ~ '^foo.*')))"]
   end
 
   it "should support :format constraint validation with case insensitive format" do
@@ -206,120 +206,120 @@ describe "constraint_validations extension" do
     @db.extension(:constraint_validations)
     @db.create_table(:foo){String :name; validate{format(/^foo.*/i, :name)}}
     sqls = @db.sqls
-    parse_insert(sqls.slice!(1)).should == {:validation_type=>"iformat", :column=>"name", :table=>"foo", :argument=>'^foo.*'}
-    sqls.should == ["BEGIN", "COMMIT", "CREATE TABLE foo (name text, CHECK ((name IS NOT NULL) AND (name ~* '^foo.*')))"]
+    parse_insert(sqls.slice!(1)).must_equal(:validation_type=>"iformat", :column=>"name", :table=>"foo", :argument=>'^foo.*')
+    sqls.must_equal ["BEGIN", "COMMIT", "CREATE TABLE foo (name text, CHECK ((name IS NOT NULL) AND (name ~* '^foo.*')))"]
   end
 
   it "should support :includes constraint validation with an array of strings" do
     @db.create_table(:foo){String :name; validate{includes %w'a b c', :name}}
     sqls = @db.sqls
-    parse_insert(sqls.slice!(1)).should == {:validation_type=>"includes_str_array", :column=>"name", :table=>"foo", :argument=>'a,b,c'}
-    sqls.should == ["BEGIN", "COMMIT", "CREATE TABLE foo (name varchar(255), CHECK ((name IS NOT NULL) AND (name IN ('a', 'b', 'c'))))"]
+    parse_insert(sqls.slice!(1)).must_equal(:validation_type=>"includes_str_array", :column=>"name", :table=>"foo", :argument=>'a,b,c')
+    sqls.must_equal ["BEGIN", "COMMIT", "CREATE TABLE foo (name varchar(255), CHECK ((name IS NOT NULL) AND (name IN ('a', 'b', 'c'))))"]
   end
 
   it "should support :includes constraint validation with an array of integers" do
     @db.create_table(:foo){String :name; validate{includes [1, 2, 3], :name}}
     sqls = @db.sqls
-    parse_insert(sqls.slice!(1)).should == {:validation_type=>"includes_int_array", :column=>"name", :table=>"foo", :argument=>'1,2,3'}
-    sqls.should == ["BEGIN", "COMMIT", "CREATE TABLE foo (name varchar(255), CHECK ((name IS NOT NULL) AND (name IN (1, 2, 3))))"]
+    parse_insert(sqls.slice!(1)).must_equal(:validation_type=>"includes_int_array", :column=>"name", :table=>"foo", :argument=>'1,2,3')
+    sqls.must_equal ["BEGIN", "COMMIT", "CREATE TABLE foo (name varchar(255), CHECK ((name IS NOT NULL) AND (name IN (1, 2, 3))))"]
   end
 
   it "should support :includes constraint validation with a inclusive range of integers" do
     @db.create_table(:foo){String :name; validate{includes 3..5, :name}}
     sqls = @db.sqls
-    parse_insert(sqls.slice!(1)).should == {:validation_type=>"includes_int_range", :column=>"name", :table=>"foo", :argument=>'3..5'}
-    sqls.should == ["BEGIN", "COMMIT", "CREATE TABLE foo (name varchar(255), CHECK ((name IS NOT NULL) AND (name >= 3) AND (name <= 5)))"]
+    parse_insert(sqls.slice!(1)).must_equal(:validation_type=>"includes_int_range", :column=>"name", :table=>"foo", :argument=>'3..5')
+    sqls.must_equal ["BEGIN", "COMMIT", "CREATE TABLE foo (name varchar(255), CHECK ((name IS NOT NULL) AND (name >= 3) AND (name <= 5)))"]
   end
 
   it "should support :includes constraint validation with a exclusive range of integers" do
     @db.create_table(:foo){String :name; validate{includes 3...5, :name}}
     sqls = @db.sqls
-    parse_insert(sqls.slice!(1)).should == {:validation_type=>"includes_int_range", :column=>"name", :table=>"foo", :argument=>'3...5'}
-    sqls.should == ["BEGIN", "COMMIT", "CREATE TABLE foo (name varchar(255), CHECK ((name IS NOT NULL) AND (name >= 3) AND (name < 5)))"]
+    parse_insert(sqls.slice!(1)).must_equal(:validation_type=>"includes_int_range", :column=>"name", :table=>"foo", :argument=>'3...5')
+    sqls.must_equal ["BEGIN", "COMMIT", "CREATE TABLE foo (name varchar(255), CHECK ((name IS NOT NULL) AND (name >= 3) AND (name < 5)))"]
   end
 
   it "should support :like constraint validation" do
     @db.create_table(:foo){String :name; validate{like 'foo%', :name}}
     sqls = @db.sqls
-    parse_insert(sqls.slice!(1)).should == {:validation_type=>"like", :column=>"name", :table=>"foo", :argument=>'foo%'}
-    sqls.should == ["BEGIN", "COMMIT", "CREATE TABLE foo (name varchar(255), CHECK ((name IS NOT NULL) AND (name LIKE 'foo%' ESCAPE '\\')))"]
+    parse_insert(sqls.slice!(1)).must_equal(:validation_type=>"like", :column=>"name", :table=>"foo", :argument=>'foo%')
+    sqls.must_equal ["BEGIN", "COMMIT", "CREATE TABLE foo (name varchar(255), CHECK ((name IS NOT NULL) AND (name LIKE 'foo%' ESCAPE '\\')))"]
   end
 
   it "should support :ilike constraint validation" do
     @db.create_table(:foo){String :name; validate{ilike 'foo%', :name}}
     sqls = @db.sqls
-    parse_insert(sqls.slice!(1)).should == {:validation_type=>"ilike", :column=>"name", :table=>"foo", :argument=>'foo%'}
-    sqls.should == ["BEGIN", "COMMIT", "CREATE TABLE foo (name varchar(255), CHECK ((name IS NOT NULL) AND (UPPER(name) LIKE UPPER('foo%') ESCAPE '\\')))"]
+    parse_insert(sqls.slice!(1)).must_equal(:validation_type=>"ilike", :column=>"name", :table=>"foo", :argument=>'foo%')
+    sqls.must_equal ["BEGIN", "COMMIT", "CREATE TABLE foo (name varchar(255), CHECK ((name IS NOT NULL) AND (UPPER(name) LIKE UPPER('foo%') ESCAPE '\\')))"]
   end
 
   it "should support :unique constraint validation" do
     @db.create_table(:foo){String :name; validate{unique :name}}
     sqls = @db.sqls
-    parse_insert(sqls.slice!(1)).should == {:validation_type=>"unique", :column=>"name", :table=>"foo"}
-    sqls.should == ["BEGIN", "COMMIT", "CREATE TABLE foo (name varchar(255), UNIQUE (name))"]
+    parse_insert(sqls.slice!(1)).must_equal(:validation_type=>"unique", :column=>"name", :table=>"foo")
+    sqls.must_equal ["BEGIN", "COMMIT", "CREATE TABLE foo (name varchar(255), UNIQUE (name))"]
   end
 
   it "should support :unique constraint validation with multiple columns" do
     @db.create_table(:foo){String :name; Integer :id; validate{unique [:name, :id]}}
     sqls = @db.sqls
-    parse_insert(sqls.slice!(1)).should == {:validation_type=>"unique", :column=>"name,id", :table=>"foo"}
-    sqls.should == ["BEGIN", "COMMIT", "CREATE TABLE foo (name varchar(255), id integer, UNIQUE (name, id))"]
+    parse_insert(sqls.slice!(1)).must_equal(:validation_type=>"unique", :column=>"name,id", :table=>"foo")
+    sqls.must_equal ["BEGIN", "COMMIT", "CREATE TABLE foo (name varchar(255), id integer, UNIQUE (name, id))"]
   end
 
   it "should support :unique constraint validation in alter_table" do
     @db.alter_table(:foo){validate{unique :name}}
     sqls = @db.sqls
-    parse_insert(sqls.slice!(1)).should == {:validation_type=>"unique", :column=>"name", :table=>"foo"}
-    sqls.should == ["BEGIN", "COMMIT", "ALTER TABLE foo ADD UNIQUE (name)"]
+    parse_insert(sqls.slice!(1)).must_equal(:validation_type=>"unique", :column=>"name", :table=>"foo")
+    sqls.must_equal ["BEGIN", "COMMIT", "ALTER TABLE foo ADD UNIQUE (name)"]
   end
 
   it "should drop constraints and validations when dropping a constraint validation" do
     @db.alter_table(:foo){String :name; validate{drop :bar}}
-    @db.sqls.should == ["DELETE FROM sequel_constraint_validations WHERE ((table, constraint_name) IN (('foo', 'bar')))", "ALTER TABLE foo DROP CONSTRAINT bar"]
+    @db.sqls.must_equal ["DELETE FROM sequel_constraint_validations WHERE ((table, constraint_name) IN (('foo', 'bar')))", "ALTER TABLE foo DROP CONSTRAINT bar"]
   end
 
   it "should drop constraints and validations before adding new ones" do
     @db.alter_table(:foo){String :name; validate{unique :name; drop :bar}}
     sqls = @db.sqls
-    parse_insert(sqls.slice!(2)).should == {:validation_type=>"unique", :column=>"name", :table=>"foo"}
-    sqls.should == ["DELETE FROM sequel_constraint_validations WHERE ((table, constraint_name) IN (('foo', 'bar')))", "BEGIN", "COMMIT", "ALTER TABLE foo ADD UNIQUE (name)", "ALTER TABLE foo DROP CONSTRAINT bar"]
+    parse_insert(sqls.slice!(2)).must_equal(:validation_type=>"unique", :column=>"name", :table=>"foo")
+    sqls.must_equal ["DELETE FROM sequel_constraint_validations WHERE ((table, constraint_name) IN (('foo', 'bar')))", "BEGIN", "COMMIT", "ALTER TABLE foo ADD UNIQUE (name)", "ALTER TABLE foo DROP CONSTRAINT bar"]
   end
 
   it "should raise an error if attempting to validate inclusion with a range of non-integers" do
-    proc{@db.create_table(:foo){String :name; validate{includes 'a'..'z', :name}}}.should raise_error(Sequel::Error)
+    proc{@db.create_table(:foo){String :name; validate{includes 'a'..'z', :name}}}.must_raise(Sequel::Error)
   end
 
   it "should raise an error if attempting to validate inclusion with a range of non-integers or strings" do
-    proc{@db.create_table(:foo){String :name; validate{includes [1.0, 2.0], :name}}}.should raise_error(Sequel::Error)
+    proc{@db.create_table(:foo){String :name; validate{includes [1.0, 2.0], :name}}}.must_raise(Sequel::Error)
   end
 
   it "should raise an error if attempting to validate inclusion with a unsupported object" do
-    proc{@db.create_table(:foo){String :name; validate{includes 'a', :name}}}.should raise_error(Sequel::Error)
+    proc{@db.create_table(:foo){String :name; validate{includes 'a', :name}}}.must_raise(Sequel::Error)
   end
 
   it "should raise an error if attempting to drop a constraint validation in a create_table generator" do
-    proc{@db.create_table(:foo){String :name; validate{drop :foo}}}.should raise_error(Sequel::Error)
+    proc{@db.create_table(:foo){String :name; validate{drop :foo}}}.must_raise(Sequel::Error)
   end
 
   it "should raise an error if attempting to drop a constraint validation without a name" do
-    proc{@db.alter_table(:foo){String :name; validate{drop nil}}}.should raise_error(Sequel::Error)
+    proc{@db.alter_table(:foo){String :name; validate{drop nil}}}.must_raise(Sequel::Error)
   end
 
   it "should raise an error if attempting attempting to process a constraint validation with an unsupported type" do
-    proc{@db.alter_table(:foo){String :name; validations << {:type=>:foo}}}.should raise_error(Sequel::Error)
+    proc{@db.alter_table(:foo){String :name; validations << {:type=>:foo}}}.must_raise(Sequel::Error)
   end
 
   it "should allow adding constraint validations for tables specified as a SQL::Identifier" do
     @db.create_table(Sequel.identifier(:sch__foo)){String :name; validate{presence :name}}
     sqls = @db.sqls
-    parse_insert(sqls.slice!(1)).should == {:validation_type=>"presence", :column=>"name", :table=>"sch__foo"}
-    sqls.should == ["BEGIN", "COMMIT", "CREATE TABLE sch__foo (name varchar(255), CHECK ((name IS NOT NULL) AND (trim(name) != '')))"]
+    parse_insert(sqls.slice!(1)).must_equal(:validation_type=>"presence", :column=>"name", :table=>"sch__foo")
+    sqls.must_equal ["BEGIN", "COMMIT", "CREATE TABLE sch__foo (name varchar(255), CHECK ((name IS NOT NULL) AND (trim(name) != '')))"]
   end
 
   it "should allow adding constraint validations for tables specified as a SQL::QualifiedIdentifier" do
     @db.create_table(Sequel.qualify(:sch, :foo)){String :name; validate{presence :name}}
     sqls = @db.sqls
-    parse_insert(sqls.slice!(1)).should == {:validation_type=>"presence", :column=>"name", :table=>"sch.foo"}
-    sqls.should == ["BEGIN", "COMMIT", "CREATE TABLE sch.foo (name varchar(255), CHECK ((name IS NOT NULL) AND (trim(name) != '')))"]
+    parse_insert(sqls.slice!(1)).must_equal(:validation_type=>"presence", :column=>"name", :table=>"sch.foo")
+    sqls.must_equal ["BEGIN", "COMMIT", "CREATE TABLE sch.foo (name varchar(255), CHECK ((name IS NOT NULL) AND (trim(name) != '')))"]
   end
 end

data/spec/extensions/core_refinements_spec.rb

@@ -18,118 +18,118 @@ describe "Core refinements" do
   end
   
   it "should support NOT via Symbol#~" do
-    @d.l(~:x).should == 'NOT x'
-    @d.l(~:x__y).should == 'NOT x.y'
+    @d.l(~:x).must_equal 'NOT x'
+    @d.l(~:x__y).must_equal 'NOT x.y'
   end
   
   it "should support + - * / via Symbol#+,-,*,/" do
-    @d.l(:x + 1 > 100).should == '((x + 1) > 100)'
-    @d.l((:x * :y) < 100.01).should == '((x * y) < 100.01)'
-    @d.l((:x - :y/2) >= 100000000000000000000000000000000000).should == '((x - (y / 2)) >= 100000000000000000000000000000000000)'
-    @d.l((((:x - :y)/(:x + :y))*:z) <= 100).should == '((((x - y) / (x + y)) * z) <= 100)'
-    @d.l(~((((:x - :y)/(:x + :y))*:z) <= 100)).should == '((((x - y) / (x + y)) * z) > 100)'
+    @d.l(:x + 1 > 100).must_equal '((x + 1) > 100)'
+    @d.l((:x * :y) < 100.01).must_equal '((x * y) < 100.01)'
+    @d.l((:x - :y/2) >= 100000000000000000000000000000000000).must_equal '((x - (y / 2)) >= 100000000000000000000000000000000000)'
+    @d.l((((:x - :y)/(:x + :y))*:z) <= 100).must_equal '((((x - y) / (x + y)) * z) <= 100)'
+    @d.l(~((((:x - :y)/(:x + :y))*:z) <= 100)).must_equal '((((x - y) / (x + y)) * z) > 100)'
   end
   
   it "should support LIKE via Symbol#like" do
-    @d.l(:x.like('a')).should == '(x LIKE \'a\' ESCAPE \'\\\')'
-    @d.l(:x.like(/a/)).should == '(x ~ \'a\')'
-    @d.l(:x.like('a', 'b')).should == '((x LIKE \'a\' ESCAPE \'\\\') OR (x LIKE \'b\' ESCAPE \'\\\'))'
-    @d.l(:x.like(/a/, /b/i)).should == '((x ~ \'a\') OR (x ~* \'b\'))'
-    @d.l(:x.like('a', /b/)).should == '((x LIKE \'a\' ESCAPE \'\\\') OR (x ~ \'b\'))'
+    @d.l(:x.like('a')).must_equal '(x LIKE \'a\' ESCAPE \'\\\')'
+    @d.l(:x.like(/a/)).must_equal '(x ~ \'a\')'
+    @d.l(:x.like('a', 'b')).must_equal '((x LIKE \'a\' ESCAPE \'\\\') OR (x LIKE \'b\' ESCAPE \'\\\'))'
+    @d.l(:x.like(/a/, /b/i)).must_equal '((x ~ \'a\') OR (x ~* \'b\'))'
+    @d.l(:x.like('a', /b/)).must_equal '((x LIKE \'a\' ESCAPE \'\\\') OR (x ~ \'b\'))'
   end
 
   it "should support NOT LIKE via Symbol#like and Symbol#~" do
-    @d.l(~:x.like('a')).should == '(x NOT LIKE \'a\' ESCAPE \'\\\')'
-    @d.l(~:x.like(/a/)).should == '(x !~ \'a\')'
-    @d.l(~:x.like('a', 'b')).should == '((x NOT LIKE \'a\' ESCAPE \'\\\') AND (x NOT LIKE \'b\' ESCAPE \'\\\'))'
-    @d.l(~:x.like(/a/, /b/i)).should == '((x !~ \'a\') AND (x !~* \'b\'))'
-    @d.l(~:x.like('a', /b/)).should == '((x NOT LIKE \'a\' ESCAPE \'\\\') AND (x !~ \'b\'))'
+    @d.l(~:x.like('a')).must_equal '(x NOT LIKE \'a\' ESCAPE \'\\\')'
+    @d.l(~:x.like(/a/)).must_equal '(x !~ \'a\')'
+    @d.l(~:x.like('a', 'b')).must_equal '((x NOT LIKE \'a\' ESCAPE \'\\\') AND (x NOT LIKE \'b\' ESCAPE \'\\\'))'
+    @d.l(~:x.like(/a/, /b/i)).must_equal '((x !~ \'a\') AND (x !~* \'b\'))'
+    @d.l(~:x.like('a', /b/)).must_equal '((x NOT LIKE \'a\' ESCAPE \'\\\') AND (x !~ \'b\'))'
   end
 
   it "should support ILIKE via Symbol#ilike" do
-    @d.l(:x.ilike('a')).should == '(UPPER(x) LIKE UPPER(\'a\') ESCAPE \'\\\')'
-    @d.l(:x.ilike(/a/)).should == '(x ~* \'a\')'
-    @d.l(:x.ilike('a', 'b')).should == '((UPPER(x) LIKE UPPER(\'a\') ESCAPE \'\\\') OR (UPPER(x) LIKE UPPER(\'b\') ESCAPE \'\\\'))'
-    @d.l(:x.ilike(/a/, /b/i)).should == '((x ~* \'a\') OR (x ~* \'b\'))'
-    @d.l(:x.ilike('a', /b/)).should == '((UPPER(x) LIKE UPPER(\'a\') ESCAPE \'\\\') OR (x ~* \'b\'))'
+    @d.l(:x.ilike('a')).must_equal '(UPPER(x) LIKE UPPER(\'a\') ESCAPE \'\\\')'
+    @d.l(:x.ilike(/a/)).must_equal '(x ~* \'a\')'
+    @d.l(:x.ilike('a', 'b')).must_equal '((UPPER(x) LIKE UPPER(\'a\') ESCAPE \'\\\') OR (UPPER(x) LIKE UPPER(\'b\') ESCAPE \'\\\'))'
+    @d.l(:x.ilike(/a/, /b/i)).must_equal '((x ~* \'a\') OR (x ~* \'b\'))'
+    @d.l(:x.ilike('a', /b/)).must_equal '((UPPER(x) LIKE UPPER(\'a\') ESCAPE \'\\\') OR (x ~* \'b\'))'
   end
 
   it "should support NOT ILIKE via Symbol#ilike and Symbol#~" do
-    @d.l(~:x.ilike('a')).should == '(UPPER(x) NOT LIKE UPPER(\'a\') ESCAPE \'\\\')'
-    @d.l(~:x.ilike(/a/)).should == '(x !~* \'a\')'
-    @d.l(~:x.ilike('a', 'b')).should == '((UPPER(x) NOT LIKE UPPER(\'a\') ESCAPE \'\\\') AND (UPPER(x) NOT LIKE UPPER(\'b\') ESCAPE \'\\\'))'
-    @d.l(~:x.ilike(/a/, /b/i)).should == '((x !~* \'a\') AND (x !~* \'b\'))'
-    @d.l(~:x.ilike('a', /b/)).should == '((UPPER(x) NOT LIKE UPPER(\'a\') ESCAPE \'\\\') AND (x !~* \'b\'))'
+    @d.l(~:x.ilike('a')).must_equal '(UPPER(x) NOT LIKE UPPER(\'a\') ESCAPE \'\\\')'
+    @d.l(~:x.ilike(/a/)).must_equal '(x !~* \'a\')'
+    @d.l(~:x.ilike('a', 'b')).must_equal '((UPPER(x) NOT LIKE UPPER(\'a\') ESCAPE \'\\\') AND (UPPER(x) NOT LIKE UPPER(\'b\') ESCAPE \'\\\'))'
+    @d.l(~:x.ilike(/a/, /b/i)).must_equal '((x !~* \'a\') AND (x !~* \'b\'))'
+    @d.l(~:x.ilike('a', /b/)).must_equal '((UPPER(x) NOT LIKE UPPER(\'a\') ESCAPE \'\\\') AND (x !~* \'b\'))'
   end
 
   it "should support sql_expr on arrays with all two pairs" do
-    @d.l([[:x, 100],[:y, 'a']].sql_expr).should == '((x = 100) AND (y = \'a\'))'
-    @d.l([[:x, true], [:y, false]].sql_expr).should == '((x IS TRUE) AND (y IS FALSE))'
-    @d.l([[:x, nil], [:y, [1,2,3]]].sql_expr).should == '((x IS NULL) AND (y IN (1, 2, 3)))'
+    @d.l([[:x, 100],[:y, 'a']].sql_expr).must_equal '((x = 100) AND (y = \'a\'))'
+    @d.l([[:x, true], [:y, false]].sql_expr).must_equal '((x IS TRUE) AND (y IS FALSE))'
+    @d.l([[:x, nil], [:y, [1,2,3]]].sql_expr).must_equal '((x IS NULL) AND (y IN (1, 2, 3)))'
   end
   
   it "should support sql_negate on arrays with all two pairs" do
-    @d.l([[:x, 100],[:y, 'a']].sql_negate).should == '((x != 100) AND (y != \'a\'))'
-    @d.l([[:x, true], [:y, false]].sql_negate).should == '((x IS NOT TRUE) AND (y IS NOT FALSE))'
-    @d.l([[:x, nil], [:y, [1,2,3]]].sql_negate).should == '((x IS NOT NULL) AND (y NOT IN (1, 2, 3)))'
+    @d.l([[:x, 100],[:y, 'a']].sql_negate).must_equal '((x != 100) AND (y != \'a\'))'
+    @d.l([[:x, true], [:y, false]].sql_negate).must_equal '((x IS NOT TRUE) AND (y IS NOT FALSE))'
+    @d.l([[:x, nil], [:y, [1,2,3]]].sql_negate).must_equal '((x IS NOT NULL) AND (y NOT IN (1, 2, 3)))'
   end
   
   it "should support ~ on arrays with all two pairs" do
-    @d.l(~[[:x, 100],[:y, 'a']]).should == '((x != 100) OR (y != \'a\'))'
-    @d.l(~[[:x, true], [:y, false]]).should == '((x IS NOT TRUE) OR (y IS NOT FALSE))'
-    @d.l(~[[:x, nil], [:y, [1,2,3]]]).should == '((x IS NOT NULL) OR (y NOT IN (1, 2, 3)))'
+    @d.l(~[[:x, 100],[:y, 'a']]).must_equal '((x != 100) OR (y != \'a\'))'
+    @d.l(~[[:x, true], [:y, false]]).must_equal '((x IS NOT TRUE) OR (y IS NOT FALSE))'
+    @d.l(~[[:x, nil], [:y, [1,2,3]]]).must_equal '((x IS NOT NULL) OR (y NOT IN (1, 2, 3)))'
   end
   
   it "should support sql_or on arrays with all two pairs" do
-    @d.l([[:x, 100],[:y, 'a']].sql_or).should == '((x = 100) OR (y = \'a\'))'
-    @d.l([[:x, true], [:y, false]].sql_or).should == '((x IS TRUE) OR (y IS FALSE))'
-    @d.l([[:x, nil], [:y, [1,2,3]]].sql_or).should == '((x IS NULL) OR (y IN (1, 2, 3)))'
+    @d.l([[:x, 100],[:y, 'a']].sql_or).must_equal '((x = 100) OR (y = \'a\'))'
+    @d.l([[:x, true], [:y, false]].sql_or).must_equal '((x IS TRUE) OR (y IS FALSE))'
+    @d.l([[:x, nil], [:y, [1,2,3]]].sql_or).must_equal '((x IS NULL) OR (y IN (1, 2, 3)))'
   end
   
   it "should support Array#sql_string_join for concatenation of SQL strings" do
-    @d.lit([:x].sql_string_join).should == '(x)'
-    @d.lit([:x].sql_string_join(', ')).should == '(x)'
-    @d.lit([:x, :y].sql_string_join).should == '(x || y)'
-    @d.lit([:x, :y].sql_string_join(', ')).should == "(x || ', ' || y)"
-    @d.lit([:x.sql_function(1), :y.sql_subscript(1)].sql_string_join).should == '(x(1) || y[1])'
-    @d.lit([:x.sql_function(1), 'y.z'.lit].sql_string_join(', ')).should == "(x(1) || ', ' || y.z)"
-    @d.lit([:x, 1, :y].sql_string_join).should == "(x || '1' || y)"
-    @d.lit([:x, 1, :y].sql_string_join(', ')).should == "(x || ', ' || '1' || ', ' || y)"
-    @d.lit([:x, 1, :y].sql_string_join(:y__z)).should == "(x || y.z || '1' || y.z || y)"
-    @d.lit([:x, 1, :y].sql_string_join(1)).should == "(x || '1' || '1' || '1' || y)"
-    @d.lit([:x, :y].sql_string_join('y.x || x.y'.lit)).should == "(x || y.x || x.y || y)"
-    @d.lit([[:x, :y].sql_string_join, [:a, :b].sql_string_join].sql_string_join).should == "(x || y || a || b)"
+    @d.lit([:x].sql_string_join).must_equal '(x)'
+    @d.lit([:x].sql_string_join(', ')).must_equal '(x)'
+    @d.lit([:x, :y].sql_string_join).must_equal '(x || y)'
+    @d.lit([:x, :y].sql_string_join(', ')).must_equal "(x || ', ' || y)"
+    @d.lit([:x.sql_function(1), :y.sql_subscript(1)].sql_string_join).must_equal '(x(1) || y[1])'
+    @d.lit([:x.sql_function(1), 'y.z'.lit].sql_string_join(', ')).must_equal "(x(1) || ', ' || y.z)"
+    @d.lit([:x, 1, :y].sql_string_join).must_equal "(x || '1' || y)"
+    @d.lit([:x, 1, :y].sql_string_join(', ')).must_equal "(x || ', ' || '1' || ', ' || y)"
+    @d.lit([:x, 1, :y].sql_string_join(:y__z)).must_equal "(x || y.z || '1' || y.z || y)"
+    @d.lit([:x, 1, :y].sql_string_join(1)).must_equal "(x || '1' || '1' || '1' || y)"
+    @d.lit([:x, :y].sql_string_join('y.x || x.y'.lit)).must_equal "(x || y.x || x.y || y)"
+    @d.lit([[:x, :y].sql_string_join, [:a, :b].sql_string_join].sql_string_join).must_equal "(x || y || a || b)"
   end
 
   it "should support sql_expr on hashes" do
-    @d.l({:x => 100, :y => 'a'}.sql_expr)[1...-1].split(' AND ').sort.should == ['(x = 100)', '(y = \'a\')']
-    @d.l({:x => true, :y => false}.sql_expr)[1...-1].split(' AND ').sort.should == ['(x IS TRUE)', '(y IS FALSE)']
-    @d.l({:x => nil, :y => [1,2,3]}.sql_expr)[1...-1].split(' AND ').sort.should == ['(x IS NULL)', '(y IN (1, 2, 3))']
+    @d.l({:x => 100, :y => 'a'}.sql_expr)[1...-1].split(' AND ').sort.must_equal ['(x = 100)', '(y = \'a\')']
+    @d.l({:x => true, :y => false}.sql_expr)[1...-1].split(' AND ').sort.must_equal ['(x IS TRUE)', '(y IS FALSE)']
+    @d.l({:x => nil, :y => [1,2,3]}.sql_expr)[1...-1].split(' AND ').sort.must_equal ['(x IS NULL)', '(y IN (1, 2, 3))']
   end
   
   it "should support sql_negate on hashes" do
-    @d.l({:x => 100, :y => 'a'}.sql_negate)[1...-1].split(' AND ').sort.should == ['(x != 100)', '(y != \'a\')']
-    @d.l({:x => true, :y => false}.sql_negate)[1...-1].split(' AND ').sort.should == ['(x IS NOT TRUE)', '(y IS NOT FALSE)']
-    @d.l({:x => nil, :y => [1,2,3]}.sql_negate)[1...-1].split(' AND ').sort.should == ['(x IS NOT NULL)', '(y NOT IN (1, 2, 3))']
+    @d.l({:x => 100, :y => 'a'}.sql_negate)[1...-1].split(' AND ').sort.must_equal ['(x != 100)', '(y != \'a\')']
+    @d.l({:x => true, :y => false}.sql_negate)[1...-1].split(' AND ').sort.must_equal ['(x IS NOT TRUE)', '(y IS NOT FALSE)']
+    @d.l({:x => nil, :y => [1,2,3]}.sql_negate)[1...-1].split(' AND ').sort.must_equal ['(x IS NOT NULL)', '(y NOT IN (1, 2, 3))']
   end
   
   it "should support ~ on hashes" do
-    @d.l(~{:x => 100, :y => 'a'})[1...-1].split(' OR ').sort.should == ['(x != 100)', '(y != \'a\')']
-    @d.l(~{:x => true, :y => false})[1...-1].split(' OR ').sort.should == ['(x IS NOT TRUE)', '(y IS NOT FALSE)']
-    @d.l(~{:x => nil, :y => [1,2,3]})[1...-1].split(' OR ').sort.should == ['(x IS NOT NULL)', '(y NOT IN (1, 2, 3))']
+    @d.l(~{:x => 100, :y => 'a'})[1...-1].split(' OR ').sort.must_equal ['(x != 100)', '(y != \'a\')']
+    @d.l(~{:x => true, :y => false})[1...-1].split(' OR ').sort.must_equal ['(x IS NOT TRUE)', '(y IS NOT FALSE)']
+    @d.l(~{:x => nil, :y => [1,2,3]})[1...-1].split(' OR ').sort.must_equal ['(x IS NOT NULL)', '(y NOT IN (1, 2, 3))']
   end
   
   it "should support sql_or on hashes" do
-    @d.l({:x => 100, :y => 'a'}.sql_or)[1...-1].split(' OR ').sort.should == ['(x = 100)', '(y = \'a\')']
-    @d.l({:x => true, :y => false}.sql_or)[1...-1].split(' OR ').sort.should == ['(x IS TRUE)', '(y IS FALSE)']
-    @d.l({:x => nil, :y => [1,2,3]}.sql_or)[1...-1].split(' OR ').sort.should == ['(x IS NULL)', '(y IN (1, 2, 3))']
+    @d.l({:x => 100, :y => 'a'}.sql_or)[1...-1].split(' OR ').sort.must_equal ['(x = 100)', '(y = \'a\')']
+    @d.l({:x => true, :y => false}.sql_or)[1...-1].split(' OR ').sort.must_equal ['(x IS TRUE)', '(y IS FALSE)']
+    @d.l({:x => nil, :y => [1,2,3]}.sql_or)[1...-1].split(' OR ').sort.must_equal ['(x IS NULL)', '(y IN (1, 2, 3))']
   end
   
   it "should Hash#& and Hash#|" do
-    @d.l({:y => :z} & :x).should == '((y = z) AND x)'
-    @d.l({:x => :a} & {:y => :z}).should == '((x = a) AND (y = z))'
-    @d.l({:y => :z} | :x).should == '((y = z) OR x)'
-    @d.l({:x => :a} | {:y => :z}).should == '((x = a) OR (y = z))'
+    @d.l({:y => :z} & :x).must_equal '((y = z) AND x)'
+    @d.l({:x => :a} & {:y => :z}).must_equal '((x = a) AND (y = z))'
+    @d.l({:y => :z} | :x).must_equal '((y = z) OR x)'
+    @d.l({:x => :a} | {:y => :z}).must_equal '((x = a) OR (y = z))'
   end
 end
 
@@ -138,30 +138,30 @@ describe "Array#case and Hash#case" do
     @d = Sequel.mock.dataset
   end
 
-  specify "should return SQL CASE expression" do
-    @d.literal({:x=>:y}.case(:z)).should == '(CASE WHEN x THEN y ELSE z END)'
-    @d.literal({:x=>:y}.case(:z, :exp)).should == '(CASE exp WHEN x THEN y ELSE z END)'
+  it "should return SQL CASE expression" do
+    @d.literal({:x=>:y}.case(:z)).must_equal '(CASE WHEN x THEN y ELSE z END)'
+    @d.literal({:x=>:y}.case(:z, :exp)).must_equal '(CASE exp WHEN x THEN y ELSE z END)'
     ['(CASE WHEN x THEN y WHEN a THEN b ELSE z END)',
-     '(CASE WHEN a THEN b WHEN x THEN y ELSE z END)'].should(include(@d.literal({:x=>:y, :a=>:b}.case(:z))))
-    @d.literal([[:x, :y]].case(:z)).should == '(CASE WHEN x THEN y ELSE z END)'
-    @d.literal([[:x, :y], [:a, :b]].case(:z)).should == '(CASE WHEN x THEN y WHEN a THEN b ELSE z END)'
-    @d.literal([[:x, :y], [:a, :b]].case(:z, :exp)).should == '(CASE exp WHEN x THEN y WHEN a THEN b ELSE z END)'
-    @d.literal([[:x, :y], [:a, :b]].case(:z, :exp__w)).should == '(CASE exp.w WHEN x THEN y WHEN a THEN b ELSE z END)'
+     '(CASE WHEN a THEN b WHEN x THEN y ELSE z END)'].must_include(@d.literal({:x=>:y, :a=>:b}.case(:z)))
+    @d.literal([[:x, :y]].case(:z)).must_equal '(CASE WHEN x THEN y ELSE z END)'
+    @d.literal([[:x, :y], [:a, :b]].case(:z)).must_equal '(CASE WHEN x THEN y WHEN a THEN b ELSE z END)'
+    @d.literal([[:x, :y], [:a, :b]].case(:z, :exp)).must_equal '(CASE exp WHEN x THEN y WHEN a THEN b ELSE z END)'
+    @d.literal([[:x, :y], [:a, :b]].case(:z, :exp__w)).must_equal '(CASE exp.w WHEN x THEN y WHEN a THEN b ELSE z END)'
   end
 
-  specify "should return SQL CASE expression with expression even if nil" do
-    @d.literal({:x=>:y}.case(:z, nil)).should == '(CASE NULL WHEN x THEN y ELSE z END)'
+  it "should return SQL CASE expression with expression even if nil" do
+    @d.literal({:x=>:y}.case(:z, nil)).must_equal '(CASE NULL WHEN x THEN y ELSE z END)'
   end
 
-  specify "should raise an error if an array that isn't all two pairs is used" do
-    proc{[:b].case(:a)}.should raise_error(Sequel::Error)
-    proc{[:b, :c].case(:a)}.should raise_error(Sequel::Error)
-    proc{[[:b, :c], :d].case(:a)}.should raise_error(Sequel::Error)
+  it "should raise an error if an array that isn't all two pairs is used" do
+    proc{[:b].case(:a)}.must_raise(Sequel::Error)
+    proc{[:b, :c].case(:a)}.must_raise(Sequel::Error)
+    proc{[[:b, :c], :d].case(:a)}.must_raise(Sequel::Error)
   end
 
-  specify "should raise an error if an empty array/hash is used" do
-    proc{[].case(:a)}.should raise_error(Sequel::Error)
-    proc{{}.case(:a)}.should raise_error(Sequel::Error)
+  it "should raise an error if an empty array/hash is used" do
+    proc{[].case(:a)}.must_raise(Sequel::Error)
+    proc{{}.case(:a)}.must_raise(Sequel::Error)
   end
 end
 
@@ -170,14 +170,14 @@ describe "Array#sql_value_list and #sql_array" do
     @d = Sequel.mock.dataset
   end
 
-  specify "should treat the array as an SQL value list instead of conditions when used as a placeholder value" do
-    @d.filter("(a, b) IN ?", [[:x, 1], [:y, 2]]).sql.should == 'SELECT * WHERE ((a, b) IN ((x = 1) AND (y = 2)))'
-    @d.filter("(a, b) IN ?", [[:x, 1], [:y, 2]].sql_value_list).sql.should == 'SELECT * WHERE ((a, b) IN ((x, 1), (y, 2)))'
+  it "should treat the array as an SQL value list instead of conditions when used as a placeholder value" do
+    @d.filter("(a, b) IN ?", [[:x, 1], [:y, 2]]).sql.must_equal 'SELECT * WHERE ((a, b) IN ((x = 1) AND (y = 2)))'
+    @d.filter("(a, b) IN ?", [[:x, 1], [:y, 2]].sql_value_list).sql.must_equal 'SELECT * WHERE ((a, b) IN ((x, 1), (y, 2)))'
   end
 
-  specify "should be no difference when used as a hash value" do
-    @d.filter([:a, :b]=>[[:x, 1], [:y, 2]]).sql.should == 'SELECT * WHERE ((a, b) IN ((x, 1), (y, 2)))'
-    @d.filter([:a, :b]=>[[:x, 1], [:y, 2]].sql_value_list).sql.should == 'SELECT * WHERE ((a, b) IN ((x, 1), (y, 2)))'
+  it "should be no difference when used as a hash value" do
+    @d.filter([:a, :b]=>[[:x, 1], [:y, 2]]).sql.must_equal 'SELECT * WHERE ((a, b) IN ((x, 1), (y, 2)))'
+    @d.filter([:a, :b]=>[[:x, 1], [:y, 2]].sql_value_list).sql.must_equal 'SELECT * WHERE ((a, b) IN ((x, 1), (y, 2)))'
   end
 end
 
@@ -186,47 +186,47 @@ describe "String#lit" do
     @ds = Sequel::Database.new[:t]
   end
 
-  specify "should return an LiteralString object" do
-    'xyz'.lit.should be_a_kind_of(Sequel::LiteralString)
-    'xyz'.lit.to_s.should == 'xyz'
+  it "should return an LiteralString object" do
+    'xyz'.lit.must_be_kind_of(Sequel::LiteralString)
+    'xyz'.lit.to_s.must_equal 'xyz'
   end
   
-  specify "should inhibit string literalization" do
-    @ds.update_sql(:stamp => "NOW()".lit).should == "UPDATE t SET stamp = NOW()"
+  it "should inhibit string literalization" do
+    @ds.update_sql(:stamp => "NOW()".lit).must_equal "UPDATE t SET stamp = NOW()"
   end
 
-  specify "should return a PlaceholderLiteralString object if args are given" do
+  it "should return a PlaceholderLiteralString object if args are given" do
     a = 'DISTINCT ?'.lit(:a)
-    a.should be_a_kind_of(Sequel::SQL::PlaceholderLiteralString)
-    @ds.literal(a).should == 'DISTINCT a'
+    a.must_be_kind_of(Sequel::SQL::PlaceholderLiteralString)
+    @ds.literal(a).must_equal 'DISTINCT a'
     @ds.quote_identifiers = true
-    @ds.literal(a).should == 'DISTINCT "a"'
+    @ds.literal(a).must_equal 'DISTINCT "a"'
   end
   
-  specify "should handle named placeholders if given a single argument hash" do
+  it "should handle named placeholders if given a single argument hash" do
     a = 'DISTINCT :b'.lit(:b=>:a)
-    a.should be_a_kind_of(Sequel::SQL::PlaceholderLiteralString)
-    @ds.literal(a).should == 'DISTINCT a'
+    a.must_be_kind_of(Sequel::SQL::PlaceholderLiteralString)
+    @ds.literal(a).must_equal 'DISTINCT a'
     @ds.quote_identifiers = true
-    @ds.literal(a).should == 'DISTINCT "a"'
+    @ds.literal(a).must_equal 'DISTINCT "a"'
   end
 
-  specify "should treat placeholder literal strings as generic expressions" do
+  it "should treat placeholder literal strings as generic expressions" do
     a = ':b'.lit(:b=>:a)
-    @ds.literal(a + 1).should == "(a + 1)"
-    @ds.literal(a & :b).should == "(a AND b)"
-    @ds.literal(a.sql_string + :b).should == "(a || b)"
+    @ds.literal(a + 1).must_equal "(a + 1)"
+    @ds.literal(a & :b).must_equal "(a AND b)"
+    @ds.literal(a.sql_string + :b).must_equal "(a || b)"
   end
 end
 
 describe "String#to_sequel_blob" do
-  specify "should return a Blob object" do
-    'xyz'.to_sequel_blob.should be_a_kind_of(::Sequel::SQL::Blob)
-    'xyz'.to_sequel_blob.should == 'xyz'
+  it "should return a Blob object" do
+    'xyz'.to_sequel_blob.must_be_kind_of(::Sequel::SQL::Blob)
+    'xyz'.to_sequel_blob.must_equal 'xyz'
   end
 
-  specify "should retain binary data" do
-    "\1\2\3\4".to_sequel_blob.should == "\1\2\3\4"
+  it "should retain binary data" do
+    "\1\2\3\4".to_sequel_blob.must_equal "\1\2\3\4"
   end
 end
 
@@ -235,14 +235,14 @@ describe "#desc" do
     @ds = Sequel.mock.dataset
   end
   
-  specify "should format a DESC clause for a column ref" do
-    @ds.literal(:test.desc).should == 'test DESC'
+  it "should format a DESC clause for a column ref" do
+    @ds.literal(:test.desc).must_equal 'test DESC'
     
-    @ds.literal(:items__price.desc).should == 'items.price DESC'
+    @ds.literal(:items__price.desc).must_equal 'items.price DESC'
   end
 
-  specify "should format a DESC clause for a function" do
-    @ds.literal(:avg.sql_function(:test).desc).should == 'avg(test) DESC'
+  it "should format a DESC clause for a function" do
+    @ds.literal(:avg.sql_function(:test).desc).must_equal 'avg(test) DESC'
   end
 end
 
@@ -251,14 +251,14 @@ describe "#asc" do
     @ds = Sequel.mock.dataset
   end
   
-  specify "should format a ASC clause for a column ref" do
-    @ds.literal(:test.asc).should == 'test ASC'
+  it "should format a ASC clause for a column ref" do
+    @ds.literal(:test.asc).must_equal 'test ASC'
     
-    @ds.literal(:items__price.asc).should == 'items.price ASC'
+    @ds.literal(:items__price.asc).must_equal 'items.price ASC'
   end
 
-  specify "should format a ASC clause for a function" do
-    @ds.literal(:avg.sql_function(:test).asc).should == 'avg(test) ASC'
+  it "should format a ASC clause for a function" do
+    @ds.literal(:avg.sql_function(:test).asc).must_equal 'avg(test) ASC'
   end
 end
 
@@ -267,18 +267,18 @@ describe "#as" do
     @ds = Sequel.mock.dataset
   end
   
-  specify "should format a AS clause for a column ref" do
-    @ds.literal(:test.as(:t)).should == 'test AS t'
+  it "should format a AS clause for a column ref" do
+    @ds.literal(:test.as(:t)).must_equal 'test AS t'
     
-    @ds.literal(:items__price.as(:p)).should == 'items.price AS p'
+    @ds.literal(:items__price.as(:p)).must_equal 'items.price AS p'
   end
 
-  specify "should format a AS clause for a function" do
-    @ds.literal(:avg.sql_function(:test).as(:avg)).should == 'avg(test) AS avg'
+  it "should format a AS clause for a function" do
+    @ds.literal(:avg.sql_function(:test).as(:avg)).must_equal 'avg(test) AS avg'
   end
   
-  specify "should format a AS clause for a literal value" do
-    @ds.literal('abc'.as(:abc)).should == "'abc' AS abc"
+  it "should format a AS clause for a literal value" do
+    @ds.literal('abc'.as(:abc)).must_equal "'abc' AS abc"
   end
 end
 
@@ -291,38 +291,38 @@ describe "Column references" do
     @ds.quote_identifiers = true
   end
   
-  specify "should be quoted properly" do
-    @ds.literal(:xyz).should == "`xyz`"
-    @ds.literal(:xyz__abc).should == "`xyz`.`abc`"
+  it "should be quoted properly" do
+    @ds.literal(:xyz).must_equal "`xyz`"
+    @ds.literal(:xyz__abc).must_equal "`xyz`.`abc`"
 
-    @ds.literal(:xyz.as(:x)).should == "`xyz` AS `x`"
-    @ds.literal(:xyz__abc.as(:x)).should == "`xyz`.`abc` AS `x`"
+    @ds.literal(:xyz.as(:x)).must_equal "`xyz` AS `x`"
+    @ds.literal(:xyz__abc.as(:x)).must_equal "`xyz`.`abc` AS `x`"
 
-    @ds.literal(:xyz___x).should == "`xyz` AS `x`"
-    @ds.literal(:xyz__abc___x).should == "`xyz`.`abc` AS `x`"
+    @ds.literal(:xyz___x).must_equal "`xyz` AS `x`"
+    @ds.literal(:xyz__abc___x).must_equal "`xyz`.`abc` AS `x`"
   end
   
-  specify "should be quoted properly in SQL functions" do
-    @ds.literal(:avg.sql_function(:xyz)).should == "avg(`xyz`)"
-    @ds.literal(:avg.sql_function(:xyz, 1)).should == "avg(`xyz`, 1)"
-    @ds.literal(:avg.sql_function(:xyz).as(:a)).should == "avg(`xyz`) AS `a`"
+  it "should be quoted properly in SQL functions" do
+    @ds.literal(:avg.sql_function(:xyz)).must_equal "avg(`xyz`)"
+    @ds.literal(:avg.sql_function(:xyz, 1)).must_equal "avg(`xyz`, 1)"
+    @ds.literal(:avg.sql_function(:xyz).as(:a)).must_equal "avg(`xyz`) AS `a`"
   end
 
-  specify "should be quoted properly in ASC/DESC clauses" do
-    @ds.literal(:xyz.asc).should == "`xyz` ASC"
-    @ds.literal(:avg.sql_function(:xyz, 1).desc).should == "avg(`xyz`, 1) DESC"
+  it "should be quoted properly in ASC/DESC clauses" do
+    @ds.literal(:xyz.asc).must_equal "`xyz` ASC"
+    @ds.literal(:avg.sql_function(:xyz, 1).desc).must_equal "avg(`xyz`, 1) DESC"
   end
   
-  specify "should be quoted properly in a cast function" do
-    @ds.literal(:x.cast(:integer)).should == "CAST(`x` AS integer)"
-    @ds.literal(:x__y.cast('varchar(20)')).should == "CAST(`x`.`y` AS varchar(20))"
+  it "should be quoted properly in a cast function" do
+    @ds.literal(:x.cast(:integer)).must_equal "CAST(`x` AS integer)"
+    @ds.literal(:x__y.cast('varchar(20)')).must_equal "CAST(`x`.`y` AS varchar(20))"
   end
 end
 
 describe "Blob" do
-  specify "#to_sequel_blob should return self" do
+  it "#to_sequel_blob should return self" do
     blob = "x".to_sequel_blob
-    blob.to_sequel_blob.object_id.should == blob.object_id
+    blob.to_sequel_blob.object_id.must_equal blob.object_id
   end
 end
 
@@ -331,18 +331,18 @@ describe "Symbol#*" do
     @ds = Sequel.mock.dataset
   end
   
-  specify "should format a qualified wildcard if no argument" do
-    @ds.literal(:xyz.*).should == 'xyz.*'
-    @ds.literal(:abc.*).should == 'abc.*'
+  it "should format a qualified wildcard if no argument" do
+    @ds.literal(:xyz.*).must_equal 'xyz.*'
+    @ds.literal(:abc.*).must_equal 'abc.*'
   end
 
-  specify "should format a filter expression if an argument" do
-    @ds.literal(:xyz.*(3)).should == '(xyz * 3)'
-    @ds.literal(:abc.*(5)).should == '(abc * 5)'
+  it "should format a filter expression if an argument" do
+    @ds.literal(:xyz.*(3)).must_equal '(xyz * 3)'
+    @ds.literal(:abc.*(5)).must_equal '(abc * 5)'
   end
 
-  specify "should support qualified symbols if no argument" do
-    @ds.literal(:xyz__abc.*).should == 'xyz.abc.*'
+  it "should support qualified symbols if no argument" do
+    @ds.literal(:xyz__abc.*).must_equal 'xyz.abc.*'
   end
 end
 
@@ -353,40 +353,40 @@ describe "Symbol" do
     @ds.identifier_input_method = :upcase
   end
 
-  specify "#identifier should format an identifier" do
-    @ds.literal(:xyz__abc.identifier).should == '"XYZ__ABC"'
+  it "#identifier should format an identifier" do
+    @ds.literal(:xyz__abc.identifier).must_equal '"XYZ__ABC"'
   end
 
-  specify "#qualify should format a qualified column" do
-    @ds.literal(:xyz.qualify(:abc)).should == '"ABC"."XYZ"'
+  it "#qualify should format a qualified column" do
+    @ds.literal(:xyz.qualify(:abc)).must_equal '"ABC"."XYZ"'
   end
 
-  specify "#qualify should work on QualifiedIdentifiers" do
-    @ds.literal(:xyz.qualify(:abc).qualify(:def)).should == '"DEF"."ABC"."XYZ"'
+  it "#qualify should work on QualifiedIdentifiers" do
+    @ds.literal(:xyz.qualify(:abc).qualify(:def)).must_equal '"DEF"."ABC"."XYZ"'
   end
 
-  specify "should be able to qualify an identifier" do
-    @ds.literal(:xyz.identifier.qualify(:xyz__abc)).should == '"XYZ"."ABC"."XYZ"'
+  it "should be able to qualify an identifier" do
+    @ds.literal(:xyz.identifier.qualify(:xyz__abc)).must_equal '"XYZ"."ABC"."XYZ"'
   end
 
-  specify "should be able to specify a schema.table.column" do
-    @ds.literal(:column.qualify(:table.qualify(:schema))).should == '"SCHEMA"."TABLE"."COLUMN"'
-    @ds.literal(:column.qualify(:table__name.identifier.qualify(:schema))).should == '"SCHEMA"."TABLE__NAME"."COLUMN"'
+  it "should be able to specify a schema.table.column" do
+    @ds.literal(:column.qualify(:table.qualify(:schema))).must_equal '"SCHEMA"."TABLE"."COLUMN"'
+    @ds.literal(:column.qualify(:table__name.identifier.qualify(:schema))).must_equal '"SCHEMA"."TABLE__NAME"."COLUMN"'
   end
 
-  specify "should be able to specify order" do
+  it "should be able to specify order" do
     @oe = :xyz.desc
-    @oe.class.should == Sequel::SQL::OrderedExpression
-    @oe.descending.should == true
+    @oe.class.must_equal Sequel::SQL::OrderedExpression
+    @oe.descending.must_equal true
     @oe = :xyz.asc
-    @oe.class.should == Sequel::SQL::OrderedExpression
-    @oe.descending.should == false
+    @oe.class.must_equal Sequel::SQL::OrderedExpression
+    @oe.descending.must_equal false
   end
 
-  specify "should work correctly with objects" do
+  it "should work correctly with objects" do
     o = Object.new
     def o.sql_literal(ds) "(foo)" end
-    @ds.literal(:column.qualify(o)).should == '(foo)."COLUMN"'
+    @ds.literal(:column.qualify(o)).must_equal '(foo)."COLUMN"'
   end
 end
 
@@ -395,57 +395,57 @@ describe "Symbol" do
     @ds = Sequel::Database.new.dataset
   end
   
-  specify "should support sql_function method" do
-    @ds.literal(:COUNT.sql_function('1')).should == "COUNT('1')"
-    @ds.select(:COUNT.sql_function('1')).sql.should == "SELECT COUNT('1')"
+  it "should support sql_function method" do
+    @ds.literal(:COUNT.sql_function('1')).must_equal "COUNT('1')"
+    @ds.select(:COUNT.sql_function('1')).sql.must_equal "SELECT COUNT('1')"
   end
   
-  specify "should support cast method" do
-    @ds.literal(:abc.cast(:integer)).should == "CAST(abc AS integer)"
+  it "should support cast method" do
+    @ds.literal(:abc.cast(:integer)).must_equal "CAST(abc AS integer)"
   end
 
-  specify "should support sql array accesses via sql_subscript" do
-    @ds.literal(:abc.sql_subscript(1)).should == "abc[1]"
-    @ds.literal(:abc__def.sql_subscript(1)).should == "abc.def[1]"
-    @ds.literal(:abc.sql_subscript(1)|2).should == "abc[1, 2]"
-    @ds.literal(:abc.sql_subscript(1)[2]).should == "abc[1][2]"
+  it "should support sql array accesses via sql_subscript" do
+    @ds.literal(:abc.sql_subscript(1)).must_equal "abc[1]"
+    @ds.literal(:abc__def.sql_subscript(1)).must_equal "abc.def[1]"
+    @ds.literal(:abc.sql_subscript(1)|2).must_equal "abc[1, 2]"
+    @ds.literal(:abc.sql_subscript(1)[2]).must_equal "abc[1][2]"
   end
 
-  specify "should support cast_numeric and cast_string" do
+  it "should support cast_numeric and cast_string" do
     x = :abc.cast_numeric
-    x.should be_a_kind_of(Sequel::SQL::NumericExpression)
-    @ds.literal(x).should == "CAST(abc AS integer)"
+    x.must_be_kind_of(Sequel::SQL::NumericExpression)
+    @ds.literal(x).must_equal "CAST(abc AS integer)"
 
     x = :abc.cast_numeric(:real)
-    x.should be_a_kind_of(Sequel::SQL::NumericExpression)
-    @ds.literal(x).should == "CAST(abc AS real)"
+    x.must_be_kind_of(Sequel::SQL::NumericExpression)
+    @ds.literal(x).must_equal "CAST(abc AS real)"
 
     x = :abc.cast_string
-    x.should be_a_kind_of(Sequel::SQL::StringExpression)
-    @ds.literal(x).should == "CAST(abc AS varchar(255))"
+    x.must_be_kind_of(Sequel::SQL::StringExpression)
+    @ds.literal(x).must_equal "CAST(abc AS varchar(255))"
 
     x = :abc.cast_string(:varchar)
-    x.should be_a_kind_of(Sequel::SQL::StringExpression)
-    @ds.literal(x).should == "CAST(abc AS varchar(255))"
+    x.must_be_kind_of(Sequel::SQL::StringExpression)
+    @ds.literal(x).must_equal "CAST(abc AS varchar(255))"
   end
   
-  specify "should allow database independent types when casting" do
+  it "should allow database independent types when casting" do
     db = @ds.db
     def db.cast_type_literal(type)
       return :foo if type == Integer
       return :bar if type == String
       type
     end
-    @ds.literal(:abc.cast(String)).should == "CAST(abc AS bar)"
-    @ds.literal(:abc.cast(String)).should == "CAST(abc AS bar)"
-    @ds.literal(:abc.cast_string).should == "CAST(abc AS bar)"
-    @ds.literal(:abc.cast_string(Integer)).should == "CAST(abc AS foo)"
-    @ds.literal(:abc.cast_numeric).should == "CAST(abc AS foo)"
-    @ds.literal(:abc.cast_numeric(String)).should == "CAST(abc AS bar)"
+    @ds.literal(:abc.cast(String)).must_equal "CAST(abc AS bar)"
+    @ds.literal(:abc.cast(String)).must_equal "CAST(abc AS bar)"
+    @ds.literal(:abc.cast_string).must_equal "CAST(abc AS bar)"
+    @ds.literal(:abc.cast_string(Integer)).must_equal "CAST(abc AS foo)"
+    @ds.literal(:abc.cast_numeric).must_equal "CAST(abc AS foo)"
+    @ds.literal(:abc.cast_numeric(String)).must_equal "CAST(abc AS bar)"
   end
 
-  specify "should support SQL EXTRACT function via #extract " do
-    @ds.literal(:abc.extract(:year)).should == "extract(year FROM abc)"
+  it "should support SQL EXTRACT function via #extract " do
+    @ds.literal(:abc.extract(:year)).must_equal "extract(year FROM abc)"
   end
 end
 
@@ -455,63 +455,63 @@ describe "Postgres extensions integration" do
   end
 
   it "Symbol#pg_array should return an ArrayOp" do
-    @db.literal(:a.pg_array.unnest).should == "unnest(a)"
+    @db.literal(:a.pg_array.unnest).must_equal "unnest(a)"
   end
 
   it "Symbol#pg_row should return a PGRowOp" do
-    @db.literal(:a.pg_row[:a]).should == "(a).a"
+    @db.literal(:a.pg_row[:a]).must_equal "(a).a"
   end
 
   it "Symbol#hstore should return an HStoreOp" do
-    @db.literal(:a.hstore['a']).should == "(a -> 'a')"
+    @db.literal(:a.hstore['a']).must_equal "(a -> 'a')"
   end
 
   it "Symbol#pg_json should return an JSONOp" do
-    @db.literal(:a.pg_json[%w'a b']).should == "(a #> ARRAY['a','b'])"
-    @db.literal(:a.pg_json.extract('a')).should == "json_extract_path(a, 'a')"
+    @db.literal(:a.pg_json[%w'a b']).must_equal "(a #> ARRAY['a','b'])"
+    @db.literal(:a.pg_json.extract('a')).must_equal "json_extract_path(a, 'a')"
   end
 
   it "Symbol#pg_jsonb should return an JSONBOp" do
-    @db.literal(:a.pg_jsonb[%w'a b']).should == "(a #> ARRAY['a','b'])"
-    @db.literal(:a.pg_jsonb.extract('a')).should == "jsonb_extract_path(a, 'a')"
+    @db.literal(:a.pg_jsonb[%w'a b']).must_equal "(a #> ARRAY['a','b'])"
+    @db.literal(:a.pg_jsonb.extract('a')).must_equal "jsonb_extract_path(a, 'a')"
   end
 
   it "Symbol#pg_range should return a RangeOp" do
-    @db.literal(:a.pg_range.lower).should == "lower(a)"
+    @db.literal(:a.pg_range.lower).must_equal "lower(a)"
   end
 
   it "Array#pg_array should return a PGArray" do
-    @db.literal([1].pg_array.op.unnest).should == "unnest(ARRAY[1])"
-    @db.literal([1].pg_array(:int4).op.unnest).should == "unnest(ARRAY[1]::int4[])"
+    @db.literal([1].pg_array.op.unnest).must_equal "unnest(ARRAY[1])"
+    @db.literal([1].pg_array(:int4).op.unnest).must_equal "unnest(ARRAY[1]::int4[])"
   end
 
   it "Array#pg_json should return a JSONArray" do
-    @db.literal([1].pg_json).should == "'[1]'::json"
+    @db.literal([1].pg_json).must_equal "'[1]'::json"
   end
 
   it "Array#pg_jsonb should return a JSONBArray" do
-    @db.literal([1].pg_jsonb).should == "'[1]'::jsonb"
+    @db.literal([1].pg_jsonb).must_equal "'[1]'::jsonb"
   end
 
   it "Array#pg_row should return a ArrayRow" do
-    @db.literal([1].pg_row).should == "ROW(1)"
+    @db.literal([1].pg_row).must_equal "ROW(1)"
   end
 
   it "Hash#hstore should return an HStore" do
-    @db.literal({'a'=>1}.hstore.op['a']).should == '(\'"a"=>"1"\'::hstore -> \'a\')'
+    @db.literal({'a'=>1}.hstore.op['a']).must_equal '(\'"a"=>"1"\'::hstore -> \'a\')'
   end
 
   it "Hash#pg_json should return an JSONHash" do
-    @db.literal({'a'=>'b'}.pg_json).should == "'{\"a\":\"b\"}'::json"
+    @db.literal({'a'=>'b'}.pg_json).must_equal "'{\"a\":\"b\"}'::json"
   end
 
   it "Hash#pg_jsonb should return an JSONBHash" do
-    @db.literal({'a'=>'b'}.pg_jsonb).should == "'{\"a\":\"b\"}'::jsonb"
+    @db.literal({'a'=>'b'}.pg_jsonb).must_equal "'{\"a\":\"b\"}'::jsonb"
   end
 
   it "Range#pg_range should return an PGRange" do
-    @db.literal((1..2).pg_range).should == "'[1,2]'"
-    @db.literal((1..2).pg_range(:int4range)).should == "'[1,2]'::int4range"
+    @db.literal((1..2).pg_range).must_equal "'[1,2]'"
+    @db.literal((1..2).pg_range(:int4range)).must_equal "'[1,2]'::int4range"
   end
 end
 else