sequel 4.22.0 → 4.23.0

data/spec/extensions/pg_row_ops_spec.rb

@@ -9,52 +9,52 @@ describe "Sequel::Postgres::PGRowOp" do
   end
 
   it "#[] should access members of the composite type" do
-    @db.literal(@a[:b]).should == "(a).b"
+    @db.literal(@a[:b]).must_equal "(a).b"
   end
 
   it "#[] should be chainable" do
-    @db.literal(@a[:b][:c]).should == "((a).b).c"
+    @db.literal(@a[:b][:c]).must_equal "((a).b).c"
   end
 
   it "#[] should support array access if not given an identifier" do
-    @db.literal(@a[:b][1]).should == "(a).b[1]"
+    @db.literal(@a[:b][1]).must_equal "(a).b[1]"
   end
 
   it "#[] should be chainable with array access" do
-    @db.literal(@a[1][:b]).should == "(a[1]).b"
+    @db.literal(@a[1][:b]).must_equal "(a[1]).b"
   end
 
   it "#splat should return a splatted argument inside parentheses" do
-    @db.literal(@a.splat).should == "(a.*)"
+    @db.literal(@a.splat).must_equal "(a.*)"
   end
 
   it "#splat(type) should return a splatted argument cast to given type" do
-    @db.literal(@a.splat(:b)).should == "(a.*)::b"
+    @db.literal(@a.splat(:b)).must_equal "(a.*)::b"
   end
 
   it "#splat should not work on an already accessed composite type" do
-    proc{@a[:a].splat(:b)}.should raise_error(Sequel::Error)
+    proc{@a[:a].splat(:b)}.must_raise(Sequel::Error)
   end
 
   it "#* should reference all members of the composite type as separate columns if given no arguments" do
-    @db.literal(@a.*).should == "(a).*"
-    @db.literal(@a[:b].*).should == "((a).b).*"
+    @db.literal(@a.*).must_equal "(a).*"
+    @db.literal(@a[:b].*).must_equal "((a).b).*"
   end
 
   it "#* should use a multiplication operation if any arguments are given" do
-    @db.literal(@a.*(1)).should == "(a * 1)"
-    @db.literal(@a[:b].*(1)).should == "((a).b * 1)"
+    @db.literal(@a.*(1)).must_equal "(a * 1)"
+    @db.literal(@a[:b].*(1)).must_equal "((a).b * 1)"
   end
 
   it "#pg_row should be callable on literal strings" do
-    @db.literal(Sequel.lit('a').pg_row[:b]).should == "(a).b"
+    @db.literal(Sequel.lit('a').pg_row[:b]).must_equal "(a).b"
   end
 
   it "#pg_row should be callable on Sequel expressions" do
-    @db.literal(Sequel.function(:a).pg_row[:b]).should == "(a()).b"
+    @db.literal(Sequel.function(:a).pg_row[:b]).must_equal "(a()).b"
   end
 
   it "Sequel.pg_row should work as well if the pg_row extension is loaded" do
-    @db.literal(Sequel.pg_row(Sequel.function(:a))[:b]).should == "(a()).b"
+    @db.literal(Sequel.pg_row(Sequel.function(:a))[:b]).must_equal "(a()).b"
   end
 end

data/spec/extensions/pg_row_plugin_spec.rb

@@ -20,43 +20,43 @@ describe "Sequel::Plugins::PgRow" do
   end
 
   it "should have schema_type_class include Sequel::Model" do
-    @c2.new.send(:schema_type_class, :address).should == @c
-    @db.conversion_procs[1098].call('(123 Foo St,Bar City)').should == @c.load(:street=>'123 Foo St', :city=>'Bar City')
+    @c2.new.send(:schema_type_class, :address).must_equal @c
+    @db.conversion_procs[1098].call('(123 Foo St,Bar City)').must_equal @c.load(:street=>'123 Foo St', :city=>'Bar City')
   end
 
   it "should set up a parser for the type that creates a model class" do
-    @db.conversion_procs[1098].call('(123 Foo St,Bar City)').should == @c.load(:street=>'123 Foo St', :city=>'Bar City')
+    @db.conversion_procs[1098].call('(123 Foo St,Bar City)').must_equal @c.load(:street=>'123 Foo St', :city=>'Bar City')
   end
 
   it "should set up type casting for the type" do
-    @c2.new(:address=>{'street'=>123, 'city'=>:Bar}).address.should == @c.load(:street=>'123', :city=>'Bar')
+    @c2.new(:address=>{'street'=>123, 'city'=>:Bar}).address.must_equal @c.load(:street=>'123', :city=>'Bar')
   end
 
   it "should return model instances as is when typecasting to rows" do
     o = @c.load(:street=>'123', :city=>'Bar')
-    @c2.new(:address=>o).address.should equal(o)
+    @c2.new(:address=>o).address.must_be_same_as(o)
   end
 
   it "should handle literalizing model instances" do
-    @db.literal(@c.load(:street=>'123 Foo St', :city=>'Bar City')).should == "ROW('123 Foo St', 'Bar City')::address"
+    @db.literal(@c.load(:street=>'123 Foo St', :city=>'Bar City')).must_equal "ROW('123 Foo St', 'Bar City')::address"
   end
 
   it "should handle literalizing model instances when model table is aliased" do
     @c.dataset.opts[:from] = [Sequel.as(:address, :a)]
-    @db.literal(@c.load(:street=>'123 Foo St', :city=>'Bar City')).should == "ROW('123 Foo St', 'Bar City')::address"
+    @db.literal(@c.load(:street=>'123 Foo St', :city=>'Bar City')).must_equal "ROW('123 Foo St', 'Bar City')::address"
   end
 
   it "should handle model instances in bound variables" do
-    @db.bound_variable_arg(1, nil).should == 1
-    @db.bound_variable_arg(@c.load(:street=>'123 Foo St', :city=>'Bar City'), nil).should == '("123 Foo St","Bar City")'
+    @db.bound_variable_arg(1, nil).must_equal 1
+    @db.bound_variable_arg(@c.load(:street=>'123 Foo St', :city=>'Bar City'), nil).must_equal '("123 Foo St","Bar City")'
   end
 
   it "should handle model instances in arrays of bound variables" do
-    @db.bound_variable_arg(1, nil).should == 1
-    @db.bound_variable_arg(Sequel.pg_array([@c.load(:street=>'123 Foo St', :city=>'Bar City')]), nil).should == '{"(\\"123 Foo St\\",\\"Bar City\\")"}'
+    @db.bound_variable_arg(1, nil).must_equal 1
+    @db.bound_variable_arg(Sequel.pg_array([@c.load(:street=>'123 Foo St', :city=>'Bar City')]), nil).must_equal '{"(\\"123 Foo St\\",\\"Bar City\\")"}'
   end
 
   it "should allow inserting just this model value" do
-    @c2.dataset.insert_sql(@c.load(:street=>'123', :city=>'Bar')).should == "INSERT INTO company VALUES (ROW('123', 'Bar')::address)"
+    @c2.dataset.insert_sql(@c.load(:street=>'123', :city=>'Bar')).must_equal "INSERT INTO company VALUES (ROW('123', 'Bar')::address)"
   end
 end

data/spec/extensions/pg_row_spec.rb

@@ -10,128 +10,128 @@ describe "pg_row extension" do
 
   it "should parse record objects as arrays" do
     a = Sequel::Postgres::PG_TYPES[2249].call("(a,b,c)")
-    a.should be_a_kind_of(@m::ArrayRow)
-    a.to_a.should be_a_kind_of(Array)
-    a[0].should == 'a'
-    a.should == %w'a b c'
-    a.db_type.should == nil
-    @db.literal(a).should == "ROW('a', 'b', 'c')"
+    a.class.must_equal(@m::ArrayRow)
+    a.to_a.must_be_kind_of(Array)
+    a[0].must_equal 'a'
+    a.must_equal %w'a b c'
+    a.db_type.must_equal nil
+    @db.literal(a).must_equal "ROW('a', 'b', 'c')"
   end
 
   it "should parse arrays of record objects as arrays of arrays" do
     as = Sequel::Postgres::PG_TYPES[2287].call('{"(a,b,c)","(d,e,f)"}')
-    as.should == [%w'a b c', %w'd e f']
+    as.must_equal [%w'a b c', %w'd e f']
     as.each do |a|
-      a.should be_a_kind_of(@m::ArrayRow)
-      a.to_a.should be_a_kind_of(Array)
-      a.db_type.should == nil
+      a.class.must_equal(@m::ArrayRow)
+      a.to_a.must_be_kind_of(Array)
+      a.db_type.must_equal nil
     end
-    @db.literal(as).should == "ARRAY[ROW('a', 'b', 'c'),ROW('d', 'e', 'f')]::record[]"
+    @db.literal(as).must_equal "ARRAY[ROW('a', 'b', 'c'),ROW('d', 'e', 'f')]::record[]"
   end
 
   it "should be able to register custom parsing of row types as array-like objects" do
     klass = @m::ArrayRow.subclass(:foo)
     parser = @m::Parser.new(:converter=>klass)
     a = parser.call("(a,b,c)")
-    a.should be_a_kind_of(klass)
-    a.to_a.should be_a_kind_of(Array)
-    a[0].should == 'a'
-    a.should == %w'a b c'
-    a.db_type.should == :foo
-    @db.literal(a).should == "ROW('a', 'b', 'c')::foo"
+    a.class.must_equal(klass)
+    a.to_a.must_be_kind_of(Array)
+    a[0].must_equal 'a'
+    a.must_equal %w'a b c'
+    a.db_type.must_equal :foo
+    @db.literal(a).must_equal "ROW('a', 'b', 'c')::foo"
   end
 
   it "should be able to register custom parsing of row types as hash-like objects" do
     klass = @m::HashRow.subclass(:foo, [:a, :b, :c])
     parser = @m::Parser.new(:converter=>klass, :columns=>[:a, :b, :c])
     a = parser.call("(a,b,c)")
-    a.should be_a_kind_of(klass)
-    a.to_hash.should be_a_kind_of(Hash)
-    a[:a].should == 'a'
-    a.should == {:a=>'a', :b=>'b', :c=>'c'}
-    a.db_type.should == :foo
-    a.columns.should == [:a, :b, :c]
-    @db.literal(a).should == "ROW('a', 'b', 'c')::foo"
+    a.class.must_equal(klass)
+    a.to_hash.must_be_kind_of(Hash)
+    a[:a].must_equal 'a'
+    a.must_equal(:a=>'a', :b=>'b', :c=>'c')
+    a.db_type.must_equal :foo
+    a.columns.must_equal [:a, :b, :c]
+    @db.literal(a).must_equal "ROW('a', 'b', 'c')::foo"
   end
 
   it "should raise an error if attempting to literalize a HashRow without column information" do
     h = @m::HashRow.call(:a=>'a', :b=>'b', :c=>'c')
-    proc{@db.literal(h)}.should raise_error(Sequel::Error)
+    proc{@db.literal(h)}.must_raise(Sequel::Error)
   end
 
   it "should be able to manually override db_type per ArrayRow instance" do
     a = @m::ArrayRow.call(%w'a b c')
     a.db_type = :foo
-    @db.literal(a).should == "ROW('a', 'b', 'c')::foo"
+    @db.literal(a).must_equal "ROW('a', 'b', 'c')::foo"
   end
 
   it "should be able to manually override db_type and columns per HashRow instance" do
     h = @m::HashRow.call(:a=>'a', :c=>'c', :b=>'b')
     h.db_type = :foo
     h.columns = [:a, :b, :c]
-    @db.literal(h).should == "ROW('a', 'b', 'c')::foo"
+    @db.literal(h).must_equal "ROW('a', 'b', 'c')::foo"
   end
 
   it "should correctly split an empty row" do
-    @m::Splitter.new("()").parse.should == [nil]
+    @m::Splitter.new("()").parse.must_equal [nil]
   end
 
   it "should correctly split a row with a single value" do
-    @m::Splitter.new("(1)").parse.should == %w'1'
+    @m::Splitter.new("(1)").parse.must_equal %w'1'
   end
 
   it "should correctly split a row with multiple values" do
-    @m::Splitter.new("(1,2)").parse.should == %w'1 2'
+    @m::Splitter.new("(1,2)").parse.must_equal %w'1 2'
   end
 
   it "should correctly NULL values when splitting" do
-    @m::Splitter.new("(1,)").parse.should == ['1', nil]
+    @m::Splitter.new("(1,)").parse.must_equal ['1', nil]
   end
 
   it "should correctly empty string values when splitting" do
-    @m::Splitter.new('(1,"")').parse.should == ['1', '']
+    @m::Splitter.new('(1,"")').parse.must_equal ['1', '']
   end
 
   it "should handle quoted values when splitting" do
-    @m::Splitter.new('("1","2")').parse.should == %w'1 2'
+    @m::Splitter.new('("1","2")').parse.must_equal %w'1 2'
   end
 
   it "should handle escaped backslashes in quoted values when splitting" do
-    @m::Splitter.new('("\\\\1","2\\\\")').parse.should == ['\\1', '2\\']
+    @m::Splitter.new('("\\\\1","2\\\\")').parse.must_equal ['\\1', '2\\']
   end
 
   it "should handle doubled quotes in quoted values when splitting" do
-    @m::Splitter.new('("""1","2""")').parse.should == ['"1', '2"']
+    @m::Splitter.new('("""1","2""")').parse.must_equal ['"1', '2"']
   end
 
   it "should correctly convert types when parsing into an array" do
-    @m::Parser.new(:column_converters=>[proc{|s| s*2}, proc{|s| s*3}, proc{|s| s*4}]).call("(a,b,c)").should == %w'aa bbb cccc'
+    @m::Parser.new(:column_converters=>[proc{|s| s*2}, proc{|s| s*3}, proc{|s| s*4}]).call("(a,b,c)").must_equal %w'aa bbb cccc'
   end
 
   it "should correctly convert types into hashes if columns are known" do
-    @m::Parser.new(:columns=>[:a, :b, :c]).call("(a,b,c)").should == {:a=>'a', :b=>'b', :c=>'c'}
+    @m::Parser.new(:columns=>[:a, :b, :c]).call("(a,b,c)").must_equal(:a=>'a', :b=>'b', :c=>'c')
   end
 
   it "should correctly handle type conversion when converting into hashes" do
-    @m::Parser.new(:column_converters=>[proc{|s| s*2}, proc{|s| s*3}, proc{|s| s*4}], :columns=>[:a, :b, :c]).call("(a,b,c)").should == {:a=>'aa', :b=>'bbb', :c=>'cccc'}
+    @m::Parser.new(:column_converters=>[proc{|s| s*2}, proc{|s| s*3}, proc{|s| s*4}], :columns=>[:a, :b, :c]).call("(a,b,c)").must_equal(:a=>'aa', :b=>'bbb', :c=>'cccc')
   end
 
   it "should correctly wrap arrays when converting" do
-    @m::Parser.new(:converter=>proc{|s| [:foo, s]}).call("(a,b,c)").should == [:foo, %w'a b c']
+    @m::Parser.new(:converter=>proc{|s| [:foo, s]}).call("(a,b,c)").must_equal [:foo, %w'a b c']
   end
 
   it "should correctly wrap hashes when converting" do
-    @m::Parser.new(:converter=>proc{|s| [:foo, s]}, :columns=>[:a, :b, :c]).call("(a,b,c)").should == [:foo, {:a=>'a', :b=>'b', :c=>'c'}]
+    @m::Parser.new(:converter=>proc{|s| [:foo, s]}, :columns=>[:a, :b, :c]).call("(a,b,c)").must_equal [:foo, {:a=>'a', :b=>'b', :c=>'c'}]
   end
 
   it "should have parser store reflection information" do
     p = @m::Parser.new(:oid=>1, :column_oids=>[2], :columns=>[:a], :converter=>Array, :typecaster=>Hash, :column_converters=>[Array])
-    p.oid.should == 1
-    p.column_oids.should == [2]
-    p.columns.should == [:a]
-    p.converter.should == Array
-    p.typecaster.should == Hash
-    p.column_converters.should == [Array]
+    p.oid.must_equal 1
+    p.column_oids.must_equal [2]
+    p.columns.must_equal [:a]
+    p.converter.must_equal Array
+    p.typecaster.must_equal Hash
+    p.column_converters.must_equal [Array]
   end
 
   it "should reload registered row types when reseting conversion procs" do
@@ -142,7 +142,7 @@ describe "pg_row extension" do
     db.sqls
     db.fetch = [[{:oid=>1, :typrelid=>2, :typarray=>3}], [{:attname=>'bar', :atttypid=>4}, {:attname=>'baz', :atttypid=>5}]]
     db.register_row_type(:foo)
-    db.sqls.should == ["SELECT pg_type.oid, typrelid, typarray FROM pg_type WHERE ((typtype = 'c') AND (typname = 'foo')) LIMIT 1",
+    db.sqls.must_equal ["SELECT pg_type.oid, typrelid, typarray FROM pg_type WHERE ((typtype = 'c') AND (typname = 'foo')) LIMIT 1",
       "SELECT attname, (CASE pg_type.typbasetype WHEN 0 THEN atttypid ELSE pg_type.typbasetype END) AS atttypid FROM pg_attribute INNER JOIN pg_type ON (pg_type.oid = pg_attribute.atttypid) WHERE ((attrelid = 2) AND (attnum > 0) AND NOT attisdropped) ORDER BY attnum"]
 
     begin
@@ -150,7 +150,7 @@ describe "pg_row extension" do
       Sequel::Postgres::PG_NAMED_TYPES.clear
       db.fetch = [[{:oid=>1, :typrelid=>2, :typarray=>3}], [{:attname=>'bar', :atttypid=>4}, {:attname=>'baz', :atttypid=>5}]]
       db.reset_conversion_procs
-      db.sqls.should == ["SELECT pg_type.oid, typrelid, typarray FROM pg_type WHERE ((typtype = 'c') AND (typname = 'foo')) LIMIT 1",
+      db.sqls.must_equal ["SELECT pg_type.oid, typrelid, typarray FROM pg_type WHERE ((typtype = 'c') AND (typname = 'foo')) LIMIT 1",
         "SELECT attname, (CASE pg_type.typbasetype WHEN 0 THEN atttypid ELSE pg_type.typbasetype END) AS atttypid FROM pg_attribute INNER JOIN pg_type ON (pg_type.oid = pg_attribute.atttypid) WHERE ((attrelid = 2) AND (attnum > 0) AND NOT attisdropped) ORDER BY attnum"]
     ensure
       Sequel::Postgres::PG_NAMED_TYPES.replace pgnt
@@ -158,22 +158,22 @@ describe "pg_row extension" do
   end
 
   it "should handle ArrayRows and HashRows in bound variables" do
-    @db.bound_variable_arg(1, nil).should == 1
-    @db.bound_variable_arg(@m::ArrayRow.call(["1", "abc\\'\","]), nil).should == '("1","abc\\\\\'\\",")'
-    @db.bound_variable_arg(@m::HashRow.subclass(nil, [:a, :b]).call(:a=>"1", :b=>"abc\\'\","), nil).should == '("1","abc\\\\\'\\",")'
+    @db.bound_variable_arg(1, nil).must_equal 1
+    @db.bound_variable_arg(@m::ArrayRow.call(["1", "abc\\'\","]), nil).must_equal '("1","abc\\\\\'\\",")'
+    @db.bound_variable_arg(@m::HashRow.subclass(nil, [:a, :b]).call(:a=>"1", :b=>"abc\\'\","), nil).must_equal '("1","abc\\\\\'\\",")'
   end
 
   it "should handle ArrayRows and HashRows in arrays in bound variables" do
-    @db.bound_variable_arg(1, nil).should == 1
-    @db.bound_variable_arg([@m::ArrayRow.call(["1", "abc\\'\","])], nil).should == '{"(\\"1\\",\\"abc\\\\\\\\\'\\\\\\",\\")"}'
-    @db.bound_variable_arg([@m::HashRow.subclass(nil, [:a, :b]).call(:a=>"1", :b=>"abc\\'\",")], nil).should == '{"(\\"1\\",\\"abc\\\\\\\\\'\\\\\\",\\")"}'
+    @db.bound_variable_arg(1, nil).must_equal 1
+    @db.bound_variable_arg([@m::ArrayRow.call(["1", "abc\\'\","])], nil).must_equal '{"(\\"1\\",\\"abc\\\\\\\\\'\\\\\\",\\")"}'
+    @db.bound_variable_arg([@m::HashRow.subclass(nil, [:a, :b]).call(:a=>"1", :b=>"abc\\'\",")], nil).must_equal '{"(\\"1\\",\\"abc\\\\\\\\\'\\\\\\",\\")"}'
   end
 
   it "should handle nils in bound variables" do
-    @db.bound_variable_arg(@m::ArrayRow.call([nil, nil]), nil).should == '(,)'
-    @db.bound_variable_arg(@m::HashRow.subclass(nil, [:a, :b]).call(:a=>nil, :b=>nil), nil).should == '(,)'
-    @db.bound_variable_arg([@m::ArrayRow.call([nil, nil])], nil).should == '{"(,)"}'
-    @db.bound_variable_arg([@m::HashRow.subclass(nil, [:a, :b]).call(:a=>nil, :b=>nil)], nil).should == '{"(,)"}'
+    @db.bound_variable_arg(@m::ArrayRow.call([nil, nil]), nil).must_equal '(,)'
+    @db.bound_variable_arg(@m::HashRow.subclass(nil, [:a, :b]).call(:a=>nil, :b=>nil), nil).must_equal '(,)'
+    @db.bound_variable_arg([@m::ArrayRow.call([nil, nil])], nil).must_equal '{"(,)"}'
+    @db.bound_variable_arg([@m::HashRow.subclass(nil, [:a, :b]).call(:a=>nil, :b=>nil)], nil).must_equal '{"(,)"}'
   end
   
   it "should allow registering row type parsers by introspecting system tables" do
@@ -181,27 +181,27 @@ describe "pg_row extension" do
     @db.conversion_procs[5] = p5 = proc{|s| s * 2}
     @db.fetch = [[{:oid=>1, :typrelid=>2, :typarray=>3}], [{:attname=>'bar', :atttypid=>4}, {:attname=>'baz', :atttypid=>5}]]
     @db.register_row_type(:foo)
-    @db.sqls.should == ["SELECT pg_type.oid, typrelid, typarray FROM pg_type WHERE ((typtype = 'c') AND (typname = 'foo')) LIMIT 1",
+    @db.sqls.must_equal ["SELECT pg_type.oid, typrelid, typarray FROM pg_type WHERE ((typtype = 'c') AND (typname = 'foo')) LIMIT 1",
       "SELECT attname, (CASE pg_type.typbasetype WHEN 0 THEN atttypid ELSE pg_type.typbasetype END) AS atttypid FROM pg_attribute INNER JOIN pg_type ON (pg_type.oid = pg_attribute.atttypid) WHERE ((attrelid = 2) AND (attnum > 0) AND NOT attisdropped) ORDER BY attnum"]
     p1 = @db.conversion_procs[1]
-    p1.columns.should == [:bar, :baz]
-    p1.column_oids.should == [4, 5]
-    p1.column_converters.should == [p4, p5]
-    p1.oid.should == 1
-    @db.send(:schema_column_type, 'foo').should == :pg_row_foo
-    @db.send(:schema_column_type, 'integer').should == :integer
+    p1.columns.must_equal [:bar, :baz]
+    p1.column_oids.must_equal [4, 5]
+    p1.column_converters.must_equal [p4, p5]
+    p1.oid.must_equal 1
+    @db.send(:schema_column_type, 'foo').must_equal :pg_row_foo
+    @db.send(:schema_column_type, 'integer').must_equal :integer
 
     c = p1.converter
-    c.superclass.should == @m::HashRow
-    c.columns.should == [:bar, :baz]
-    c.db_type.should == :foo
-    p1.typecaster.should == c
+    c.superclass.must_equal @m::HashRow
+    c.columns.must_equal [:bar, :baz]
+    c.db_type.must_equal :foo
+    p1.typecaster.must_equal c
 
-    p1.call('(1,b)').should == {:bar=>1, :baz=>'bb'}
-    @db.typecast_value(:pg_row_foo, %w'1 b').should be_a_kind_of(@m::HashRow)
-    @db.typecast_value(:pg_row_foo, %w'1 b').should == {:bar=>'1', :baz=>'b'}
-    @db.typecast_value(:pg_row_foo, :bar=>'1', :baz=>'b').should == {:bar=>'1', :baz=>'b'}
-    @db.literal(p1.call('(1,b)')).should == "ROW(1, 'bb')::foo"
+    p1.call('(1,b)').must_equal(:bar=>1, :baz=>'bb')
+    @db.typecast_value(:pg_row_foo, %w'1 b').class.must_be :<, @m::HashRow
+    @db.typecast_value(:pg_row_foo, %w'1 b').must_equal(:bar=>'1', :baz=>'b')
+    @db.typecast_value(:pg_row_foo, :bar=>'1', :baz=>'b').must_equal(:bar=>'1', :baz=>'b')
+    @db.literal(p1.call('(1,b)')).must_equal "ROW(1, 'bb')::foo"
   end
 
   it "should allow registering row type parsers for schema qualify types" do
@@ -209,24 +209,24 @@ describe "pg_row extension" do
     @db.conversion_procs[5] = p5 = proc{|s| s * 2}
     @db.fetch = [[{:oid=>1, :typrelid=>2, :typarray=>3}], [{:attname=>'bar', :atttypid=>4}, {:attname=>'baz', :atttypid=>5}]]
     @db.register_row_type(:foo__bar)
-    @db.sqls.should == ["SELECT pg_type.oid, typrelid, typarray FROM pg_type INNER JOIN pg_namespace ON ((pg_namespace.oid = pg_type.typnamespace) AND (pg_namespace.nspname = 'foo')) WHERE ((typtype = 'c') AND (typname = 'bar')) LIMIT 1",
+    @db.sqls.must_equal ["SELECT pg_type.oid, typrelid, typarray FROM pg_type INNER JOIN pg_namespace ON ((pg_namespace.oid = pg_type.typnamespace) AND (pg_namespace.nspname = 'foo')) WHERE ((typtype = 'c') AND (typname = 'bar')) LIMIT 1",
       "SELECT attname, (CASE pg_type.typbasetype WHEN 0 THEN atttypid ELSE pg_type.typbasetype END) AS atttypid FROM pg_attribute INNER JOIN pg_type ON (pg_type.oid = pg_attribute.atttypid) WHERE ((attrelid = 2) AND (attnum > 0) AND NOT attisdropped) ORDER BY attnum"]
     p1 = @db.conversion_procs[1]
-    p1.columns.should == [:bar, :baz]
-    p1.column_oids.should == [4, 5]
-    p1.column_converters.should == [p4, p5]
-    p1.oid.should == 1
+    p1.columns.must_equal [:bar, :baz]
+    p1.column_oids.must_equal [4, 5]
+    p1.column_converters.must_equal [p4, p5]
+    p1.oid.must_equal 1
 
     c = p1.converter
-    c.superclass.should == @m::HashRow
-    c.columns.should == [:bar, :baz]
-    c.db_type.should == :foo__bar
-    p1.typecaster.should == c
+    c.superclass.must_equal @m::HashRow
+    c.columns.must_equal [:bar, :baz]
+    c.db_type.must_equal :foo__bar
+    p1.typecaster.must_equal c
 
-    p1.call('(1,b)').should == {:bar=>1, :baz=>'bb'}
-    @db.typecast_value(:pg_row_foo__bar, %w'1 b').should == {:bar=>'1', :baz=>'b'}
-    @db.typecast_value(:pg_row_foo__bar, :bar=>'1', :baz=>'b').should == {:bar=>'1', :baz=>'b'}
-    @db.literal(p1.call('(1,b)')).should == "ROW(1, 'bb')::foo.bar"
+    p1.call('(1,b)').must_equal(:bar=>1, :baz=>'bb')
+    @db.typecast_value(:pg_row_foo__bar, %w'1 b').must_equal(:bar=>'1', :baz=>'b')
+    @db.typecast_value(:pg_row_foo__bar, :bar=>'1', :baz=>'b').must_equal(:bar=>'1', :baz=>'b')
+    @db.literal(p1.call('(1,b)')).must_equal "ROW(1, 'bb')::foo.bar"
   end
 
   it "should allow registering with a custom converter" do
@@ -236,8 +236,8 @@ describe "pg_row extension" do
     c = proc{|h| [h]}
     @db.register_row_type(:foo, :converter=>c)
     o = @db.conversion_procs[1].call('(1,b)')
-    o.should == [{:bar=>1, :baz=>'bb'}]
-    o.first.should be_a_kind_of(Hash)
+    o.must_equal [{:bar=>1, :baz=>'bb'}]
+    o.first.must_be_kind_of(Hash)
   end
 
   it "should allow registering with a custom typecaster" do
@@ -245,15 +245,15 @@ describe "pg_row extension" do
     @db.conversion_procs[5] = proc{|s| s * 2}
     @db.fetch = [[{:oid=>1, :typrelid=>2, :typarray=>3}], [{:attname=>'bar', :atttypid=>4}, {:attname=>'baz', :atttypid=>5}]]
     @db.register_row_type(:foo, :typecaster=>proc{|h| {:bar=>(h[:bar]||0).to_i, :baz=>(h[:baz] || 'a')*2}})
-    @db.typecast_value(:pg_row_foo, %w'1 b').should be_a_kind_of(Hash)
-    @db.typecast_value(:pg_row_foo, %w'1 b').should == {:bar=>1, :baz=>'bb'}
-    @db.typecast_value(:pg_row_foo, :bar=>'1', :baz=>'b').should == {:bar=>1, :baz=>'bb'}
-    @db.typecast_value(:pg_row_foo, 'bar'=>'1', 'baz'=>'b').should == {:bar=>0, :baz=>'aa'}
+    @db.typecast_value(:pg_row_foo, %w'1 b').must_be_kind_of(Hash)
+    @db.typecast_value(:pg_row_foo, %w'1 b').must_equal(:bar=>1, :baz=>'bb')
+    @db.typecast_value(:pg_row_foo, :bar=>'1', :baz=>'b').must_equal(:bar=>1, :baz=>'bb')
+    @db.typecast_value(:pg_row_foo, 'bar'=>'1', 'baz'=>'b').must_equal(:bar=>0, :baz=>'aa')
     @db.fetch = [[{:oid=>1, :typrelid=>2, :typarray=>3}], [{:attname=>'bar', :atttypid=>4}, {:attname=>'baz', :atttypid=>5}]]
     @db.register_row_type(:foo, :typecaster=>proc{|h| {:bar=>(h[:bar] || h['bar'] || 0).to_i, :baz=>(h[:baz] || h['baz'] || 'a')*2}})
-    @db.typecast_value(:pg_row_foo, %w'1 b').should == {:bar=>1, :baz=>'bb'}
-    @db.typecast_value(:pg_row_foo, :bar=>'1', :baz=>'b').should == {:bar=>1, :baz=>'bb'}
-    @db.typecast_value(:pg_row_foo, 'bar'=>'1', 'baz'=>'b').should == {:bar=>1, :baz=>'bb'}
+    @db.typecast_value(:pg_row_foo, %w'1 b').must_equal(:bar=>1, :baz=>'bb')
+    @db.typecast_value(:pg_row_foo, :bar=>'1', :baz=>'b').must_equal(:bar=>1, :baz=>'bb')
+    @db.typecast_value(:pg_row_foo, 'bar'=>'1', 'baz'=>'b').must_equal(:bar=>1, :baz=>'bb')
   end
 
   it "should handle conversion procs that aren't added until later" do
@@ -262,7 +262,7 @@ describe "pg_row extension" do
     c = proc{|h| [h]}
     @db.register_row_type(:foo, :converter=>c)
     @db.conversion_procs[4] = proc{|s| s.to_i}
-    @db.conversion_procs[1].call('(1,b)').should == [{:bar=>1, :baz=>'bb'}]
+    @db.conversion_procs[1].call('(1,b)').must_equal [{:bar=>1, :baz=>'bb'}]
   end
 
   it "should handle nil values when converting columns" do
@@ -271,8 +271,8 @@ describe "pg_row extension" do
     called = false
     @db.conversion_procs[4] = proc{|s| called = true; s}
     @db.register_row_type(:foo)
-    @db.conversion_procs[1].call('()').should == {:bar=>nil}
-    called.should == false
+    @db.conversion_procs[1].call('()').must_equal(:bar=>nil)
+    called.must_equal false
   end
 
   it "should registering array type for row type if type has an array oid" do
@@ -282,13 +282,13 @@ describe "pg_row extension" do
     @db.register_row_type(:foo, :typecaster=>proc{|h| {:bar=>(h[:bar]||0).to_i, :baz=>(h[:baz] || 'a')*2}})
     p3 = @db.conversion_procs[3]
 
-    p3.call('{"(1,b)"}').should == [{:bar=>1, :baz=>'bb'}]
-    @db.literal(p3.call('{"(1,b)"}')).should == "ARRAY[ROW(1, 'bb')::foo]::foo[]"
-    @db.typecast_value(:foo_array, [{:bar=>'1', :baz=>'b'}]).should == [{:bar=>1, :baz=>'bb'}]
+    p3.call('{"(1,b)"}').must_equal [{:bar=>1, :baz=>'bb'}]
+    @db.literal(p3.call('{"(1,b)"}')).must_equal "ARRAY[ROW(1, 'bb')::foo]::foo[]"
+    @db.typecast_value(:foo_array, [{:bar=>'1', :baz=>'b'}]).must_equal [{:bar=>1, :baz=>'bb'}]
   end
 
   it "should allow creating unregisted row types via Database#row_type" do
-    @db.literal(@db.row_type(:foo, [1, 2])).should == 'ROW(1, 2)::foo'
+    @db.literal(@db.row_type(:foo, [1, 2])).must_equal 'ROW(1, 2)::foo'
   end
 
   it "should allow typecasting of registered row types via Database#row_type" do
@@ -296,8 +296,8 @@ describe "pg_row extension" do
     @db.conversion_procs[5] = proc{|s| s * 2}
     @db.fetch = [[{:oid=>1, :typrelid=>2, :typarray=>3}], [{:attname=>'bar', :atttypid=>4}, {:attname=>'baz', :atttypid=>5}]]
     @db.register_row_type(:foo, :typecaster=>proc{|h| @m::HashRow.subclass(:foo, [:bar, :baz]).new({:bar=>(h[:bar]||0).to_i, :baz=>(h[:baz] || 'a')*2})})
-    @db.literal(@db.row_type(:foo, ['1', 'b'])).should == "ROW(1, 'bb')::foo"
-    @db.literal(@db.row_type(:foo, {:bar=>'1', :baz=>'b'})).should == "ROW(1, 'bb')::foo"
+    @db.literal(@db.row_type(:foo, ['1', 'b'])).must_equal "ROW(1, 'bb')::foo"
+    @db.literal(@db.row_type(:foo, {:bar=>'1', :baz=>'b'})).must_equal "ROW(1, 'bb')::foo"
   end
 
   it "should allow parsing when typecasting registered row types via Database#row_type" do
@@ -305,48 +305,48 @@ describe "pg_row extension" do
     @db.conversion_procs[5] = proc{|s| s * 2}
     @db.fetch = [[{:oid=>1, :typrelid=>2, :typarray=>3}], [{:attname=>'bar', :atttypid=>4}, {:attname=>'baz', :atttypid=>5}]]
     @db.register_row_type(:foo, :typecaster=>proc{|h| @m::HashRow.subclass(:foo, [:bar, :baz]).new(:bar=>(h[:bar]||0).to_i, :baz=>(h[:baz] || 'a')*2)})
-    @db.literal(@db.row_type(:foo, ['1', 'b'])).should == "ROW(1, 'bb')::foo"
+    @db.literal(@db.row_type(:foo, ['1', 'b'])).must_equal "ROW(1, 'bb')::foo"
   end
 
   it "should raise an error if attempt to use Database#row_type with an unregistered type and hash" do
-    proc{@db.literal(@db.row_type(:foo, {:bar=>'1', :baz=>'b'}))}.should raise_error(Sequel::Error)
+    proc{@db.literal(@db.row_type(:foo, {:bar=>'1', :baz=>'b'}))}.must_raise(Sequel::InvalidValue)
   end
 
   it "should raise an error if attempt to use Database#row_type with an unhandled type" do
-    proc{@db.literal(@db.row_type(:foo, 1))}.should raise_error(Sequel::Error)
+    proc{@db.literal(@db.row_type(:foo, 1))}.must_raise(Sequel::InvalidValue)
   end
 
   it "should return ArrayRow and HashRow values as-is" do
     h = @m::HashRow.call(:a=>1)
     a = @m::ArrayRow.call([1])
-    @db.row_type(:foo, h).should equal(h)
-    @db.row_type(:foo, a).should equal(a)
+    @db.row_type(:foo, h).object_id.must_equal(h.object_id)
+    @db.row_type(:foo, a).object_id.must_equal(a.object_id)
   end
 
   it "should have Sequel.pg_row return a plain ArrayRow" do
-    @db.literal(Sequel.pg_row([1, 2, 3])).should == 'ROW(1, 2, 3)'
+    @db.literal(Sequel.pg_row([1, 2, 3])).must_equal 'ROW(1, 2, 3)'
   end
 
   it "should raise an error if attempting to typecast a hash for a parser without columns" do
-    proc{@m::Parser.new.typecast(:a=>1)}.should raise_error(Sequel::Error)
+    proc{@m::Parser.new.typecast(:a=>1)}.must_raise(Sequel::Error)
   end
 
   it "should raise an error if attempting to typecast a unhandled value for a parser" do
-    proc{@m::Parser.new.typecast(1)}.should raise_error(Sequel::Error)
+    proc{@m::Parser.new.typecast(1)}.must_raise(Sequel::Error)
   end
 
   it "should handle typecasting for a parser without a typecaster" do
-    @m::Parser.new.typecast([1]).should == [1]
+    @m::Parser.new.typecast([1]).must_equal [1]
   end
 
   it "should raise an error if no columns are returned when registering a custom row type" do
     @db.fetch = [[{:oid=>1, :typrelid=>2, :typarray=>3}]]
-    proc{@db.register_row_type(:foo)}.should raise_error(Sequel::Error)
+    proc{@db.register_row_type(:foo)}.must_raise(Sequel::Error)
   end
 
   it "should raise an error when registering a custom row type if the type is found found" do
     @db.fetch = []
-    proc{@db.register_row_type(:foo)}.should raise_error(Sequel::Error)
+    proc{@db.register_row_type(:foo)}.must_raise(Sequel::Error)
   end
 
   it "should return correct results for Database#schema_type_class" do
@@ -354,7 +354,7 @@ describe "pg_row extension" do
     @db.conversion_procs[5] = proc{|s| s * 2}
     @db.fetch = [[{:oid=>1, :typrelid=>2, :typarray=>3}], [{:attname=>'bar', :atttypid=>4}, {:attname=>'baz', :atttypid=>5}]]
     @db.register_row_type(:foo, :typecaster=>proc{|h| {:bar=>(h[:bar]||0).to_i, :baz=>(h[:baz] || 'a')*2}})
-    @db.schema_type_class(:pg_row_foo).should == [Sequel::Postgres::PGRow::HashRow, Sequel::Postgres::PGRow::ArrayRow]
-    @db.schema_type_class(:integer).should == Integer
+    @db.schema_type_class(:pg_row_foo).must_equal [Sequel::Postgres::PGRow::HashRow, Sequel::Postgres::PGRow::ArrayRow]
+    @db.schema_type_class(:integer).must_equal Integer
   end
 end