sequel 4.22.0 → 4.23.0

data/spec/extensions/pg_enum_spec.rb

@@ -17,51 +17,51 @@ describe "pg_enum extension" do
   end
 
   it "should include enum information in the schema entry" do
-    @db.schema(:a).should == [[:a, {:oid=>1, :ruby_default=>nil, :type=>:enum, :enum_values=>%w'a b c'}]]
+    @db.schema(:a).must_equal [[:a, {:oid=>1, :ruby_default=>nil, :type=>:enum, :enum_values=>%w'a b c'}]]
   end
 
   it "should typecast objects to string" do
-    @db.typecast_value(:enum, :a).should == 'a'
+    @db.typecast_value(:enum, :a).must_equal 'a'
   end
 
   it "should add array parsers for enum values" do
-    @db.conversion_procs[212389].call('{a,b,c}').should == %w'a b c'
+    @db.conversion_procs[212389].call('{a,b,c}').must_equal %w'a b c'
   end
 
   it "should support #create_enum method for adding a new enum" do
     @db.create_enum(:foo, [:a, :b, :c])
-    @db.sqls.first.should == "CREATE TYPE foo AS ENUM ('a', 'b', 'c')"
+    @db.sqls.first.must_equal "CREATE TYPE foo AS ENUM ('a', 'b', 'c')"
     @db.create_enum(:sch__foo, %w'a b c')
-    @db.sqls.first.should == "CREATE TYPE sch.foo AS ENUM ('a', 'b', 'c')"
+    @db.sqls.first.must_equal "CREATE TYPE sch.foo AS ENUM ('a', 'b', 'c')"
   end
 
   it "should support #drop_enum method for dropping an enum" do
     @db.drop_enum(:foo)
-    @db.sqls.first.should == "DROP TYPE foo"
+    @db.sqls.first.must_equal "DROP TYPE foo"
     @db.drop_enum(:sch__foo, :if_exists=>true)
-    @db.sqls.first.should == "DROP TYPE IF EXISTS sch.foo"
+    @db.sqls.first.must_equal "DROP TYPE IF EXISTS sch.foo"
     @db.drop_enum('foo', :cascade=>true)
-    @db.sqls.first.should == "DROP TYPE foo CASCADE"
+    @db.sqls.first.must_equal "DROP TYPE foo CASCADE"
   end
 
   it "should support #add_enum_value method for adding value to an existing enum" do
     @db.add_enum_value(:foo, :a)
-    @db.sqls.first.should == "ALTER TYPE foo ADD VALUE 'a'"
+    @db.sqls.first.must_equal "ALTER TYPE foo ADD VALUE 'a'"
   end
 
   it "should support :before option for #add_enum_value method for adding value before an existing enum value" do
     @db.add_enum_value('foo', :a, :before=>:b)
-    @db.sqls.first.should == "ALTER TYPE foo ADD VALUE 'a' BEFORE 'b'"
+    @db.sqls.first.must_equal "ALTER TYPE foo ADD VALUE 'a' BEFORE 'b'"
   end
 
   it "should support :after option for #add_enum_value method for adding value after an existing enum value" do
     @db.add_enum_value(:sch__foo, :a, :after=>:b)
-    @db.sqls.first.should == "ALTER TYPE sch.foo ADD VALUE 'a' AFTER 'b'"
+    @db.sqls.first.must_equal "ALTER TYPE sch.foo ADD VALUE 'a' AFTER 'b'"
   end
 
   it "should support :if_not_exists option for #add_enum_value method for not adding the value if it exists" do
     @db.add_enum_value(:foo, :a, :if_not_exists=>true)
-    @db.sqls.first.should == "ALTER TYPE foo ADD VALUE IF NOT EXISTS 'a'"
+    @db.sqls.first.must_equal "ALTER TYPE foo ADD VALUE IF NOT EXISTS 'a'"
   end
 
   it "should reverse a create_enum directive in a migration" do
@@ -84,7 +84,7 @@ describe "pg_enum extension" do
     Sequel.migration{change(&p)}.apply(db, :up)
     Sequel.migration{change(&p)}.apply(db, :down)
 
-    db.actions.should == [
+    db.actions.must_equal [
       [:create_enum, :type_name, ["value1", "value2", "value3"] ],
       [:drop_enum, :type_name]
     ]

data/spec/extensions/pg_hstore_ops_spec.rb

@@ -9,39 +9,39 @@ describe "Sequel::Postgres::HStoreOp" do
   end
 
   it "#- should use the - operator" do
-    @ds.literal(@h - :a).should == "(h - a)"
+    @ds.literal(@h - :a).must_equal "(h - a)"
   end
 
   it "#- should cast String argument to text when using - operator" do
-    @ds.literal(@h - 'a').should == "(h - CAST('a' AS text))"
+    @ds.literal(@h - 'a').must_equal "(h - CAST('a' AS text))"
   end
 
   it "#- should not cast LiteralString argument to text when using - operator" do
-    @ds.literal(@h - Sequel.lit('a')).should == "(h - a)"
+    @ds.literal(@h - Sequel.lit('a')).must_equal "(h - a)"
   end
 
   it "#- should handle arrays" do
-    @ds.literal(@h - %w'a').should == "(h - ARRAY['a'])"
+    @ds.literal(@h - %w'a').must_equal "(h - ARRAY['a'])"
   end
 
   it "#- should handle hashes" do
-    @ds.literal(@h - {'a'=>'b'}).should == "(h - '\"a\"=>\"b\"'::hstore)"
+    @ds.literal(@h - {'a'=>'b'}).must_equal "(h - '\"a\"=>\"b\"'::hstore)"
   end
 
   it "#- should return an HStoreOp" do
-    @ds.literal((@h - :a)['a']).should == "((h - a) -> 'a')"
+    @ds.literal((@h - :a)['a']).must_equal "((h - a) -> 'a')"
   end
 
   it "#[] should use the -> operator" do
-    @ds.literal(@h['a']).should == "(h -> 'a')"
+    @ds.literal(@h['a']).must_equal "(h -> 'a')"
   end
 
   it "#[] should handle arrays" do
-    @ds.literal(@h[%w'a']).should == "(h -> ARRAY['a'])"
+    @ds.literal(@h[%w'a']).must_equal "(h -> ARRAY['a'])"
   end
 
   it "#[] should return a PGArrayOp if given an array" do
-    @ds.literal(@h[%w'a'][0]).should == "(h -> ARRAY['a'])[0]"
+    @ds.literal(@h[%w'a'][0]).must_equal "(h -> ARRAY['a'])[0]"
   end
 
   it "#[] should not return a PGArrayOp if given an array but pg_array_op is not supported" do
@@ -49,188 +49,188 @@ describe "Sequel::Postgres::HStoreOp" do
       module Sequel::Postgres::HStoreOp::Sequel
         SQL = ::Sequel::SQL
       end
-      @ds.literal(@h[%w'a']).should_not be_a_kind_of(Sequel::Postgres::ArrayOp)
+      @ds.literal(@h[%w'a']).wont_be_kind_of(Sequel::Postgres::ArrayOp)
     ensure
       Sequel::Postgres::HStoreOp.send(:remove_const, :Sequel)
     end
   end
 
   it "#[] should return a PGArrayOp if given a PGArray" do
-    @ds.literal(@h[Sequel.pg_array(%w'a')][0]).should == "(h -> ARRAY['a'])[0]"
+    @ds.literal(@h[Sequel.pg_array(%w'a')][0]).must_equal "(h -> ARRAY['a'])[0]"
   end
 
   it "#[] should return a PGArrayOp if given a PGArrayOp" do
-    @ds.literal(@h[Sequel.pg_array_op(:a)][0]).should == "(h -> a)[0]"
+    @ds.literal(@h[Sequel.pg_array_op(:a)][0]).must_equal "(h -> a)[0]"
   end
 
   it "#[] should return a string expression" do
-    @ds.literal(@h['a'] + 'b').should == "((h -> 'a') || 'b')"
+    @ds.literal(@h['a'] + 'b').must_equal "((h -> 'a') || 'b')"
   end
 
   it "#concat and #merge should use the || operator" do
-    @ds.literal(@h.concat(:h1)).should == "(h || h1)"
-    @ds.literal(@h.merge(:h1)).should == "(h || h1)"
+    @ds.literal(@h.concat(:h1)).must_equal "(h || h1)"
+    @ds.literal(@h.merge(:h1)).must_equal "(h || h1)"
   end
 
   it "#concat and #merge should handle hashes" do
-    @ds.literal(@h.concat('a'=>'b')).should == "(h || '\"a\"=>\"b\"'::hstore)"
-    @ds.literal(@h.merge('a'=>'b')).should == "(h || '\"a\"=>\"b\"'::hstore)"
+    @ds.literal(@h.concat('a'=>'b')).must_equal "(h || '\"a\"=>\"b\"'::hstore)"
+    @ds.literal(@h.merge('a'=>'b')).must_equal "(h || '\"a\"=>\"b\"'::hstore)"
   end
 
   it "#concat should return an HStoreOp" do
-    @ds.literal(@h.concat(:h1)['a']).should == "((h || h1) -> 'a')"
+    @ds.literal(@h.concat(:h1)['a']).must_equal "((h || h1) -> 'a')"
   end
 
   it "#contain_all should use the ?& operator" do
-    @ds.literal(@h.contain_all(:h1)).should == "(h ?& h1)"
+    @ds.literal(@h.contain_all(:h1)).must_equal "(h ?& h1)"
   end
 
   it "#contain_all handle arrays" do
-    @ds.literal(@h.contain_all(%w'h1')).should == "(h ?& ARRAY['h1'])"
+    @ds.literal(@h.contain_all(%w'h1')).must_equal "(h ?& ARRAY['h1'])"
   end
 
   it "#contain_any should use the ?| operator" do
-    @ds.literal(@h.contain_any(:h1)).should == "(h ?| h1)"
+    @ds.literal(@h.contain_any(:h1)).must_equal "(h ?| h1)"
   end
 
   it "#contain_any should handle arrays" do
-    @ds.literal(@h.contain_any(%w'h1')).should == "(h ?| ARRAY['h1'])"
+    @ds.literal(@h.contain_any(%w'h1')).must_equal "(h ?| ARRAY['h1'])"
   end
 
   it "#contains should use the @> operator" do
-    @ds.literal(@h.contains(:h1)).should == "(h @> h1)"
+    @ds.literal(@h.contains(:h1)).must_equal "(h @> h1)"
   end
 
   it "#contains should handle hashes" do
-    @ds.literal(@h.contains('a'=>'b')).should == "(h @> '\"a\"=>\"b\"'::hstore)"
+    @ds.literal(@h.contains('a'=>'b')).must_equal "(h @> '\"a\"=>\"b\"'::hstore)"
   end
 
   it "#contained_by should use the <@ operator" do
-    @ds.literal(@h.contained_by(:h1)).should == "(h <@ h1)"
+    @ds.literal(@h.contained_by(:h1)).must_equal "(h <@ h1)"
   end
 
   it "#contained_by should handle hashes" do
-    @ds.literal(@h.contained_by('a'=>'b')).should == "(h <@ '\"a\"=>\"b\"'::hstore)"
+    @ds.literal(@h.contained_by('a'=>'b')).must_equal "(h <@ '\"a\"=>\"b\"'::hstore)"
   end
 
   it "#defined should use the defined function" do
-    @ds.literal(@h.defined('a')).should == "defined(h, 'a')"
+    @ds.literal(@h.defined('a')).must_equal "defined(h, 'a')"
   end
 
   it "#delete should use the delete function" do
-    @ds.literal(@h.delete('a')).should == "delete(h, 'a')"
+    @ds.literal(@h.delete('a')).must_equal "delete(h, 'a')"
   end
 
   it "#delete should handle arrays" do
-    @ds.literal(@h.delete(%w'a')).should == "delete(h, ARRAY['a'])"
+    @ds.literal(@h.delete(%w'a')).must_equal "delete(h, ARRAY['a'])"
   end
 
   it "#delete should handle hashes" do
-    @ds.literal(@h.delete('a'=>'b')).should == "delete(h, '\"a\"=>\"b\"'::hstore)"
+    @ds.literal(@h.delete('a'=>'b')).must_equal "delete(h, '\"a\"=>\"b\"'::hstore)"
   end
 
   it "#delete should return an HStoreOp" do
-    @ds.literal(@h.delete('a')['a']).should == "(delete(h, 'a') -> 'a')"
+    @ds.literal(@h.delete('a')['a']).must_equal "(delete(h, 'a') -> 'a')"
   end
 
   it "#each should use the each function" do
-    @ds.literal(@h.each).should == "each(h)"
+    @ds.literal(@h.each).must_equal "each(h)"
   end
 
   it "#has_key? and aliases should use the ? operator" do
-    @ds.literal(@h.has_key?('a')).should == "(h ? 'a')"
-    @ds.literal(@h.key?('a')).should == "(h ? 'a')"
-    @ds.literal(@h.member?('a')).should == "(h ? 'a')"
-    @ds.literal(@h.include?('a')).should == "(h ? 'a')"
-    @ds.literal(@h.exist?('a')).should == "(h ? 'a')"
+    @ds.literal(@h.has_key?('a')).must_equal "(h ? 'a')"
+    @ds.literal(@h.key?('a')).must_equal "(h ? 'a')"
+    @ds.literal(@h.member?('a')).must_equal "(h ? 'a')"
+    @ds.literal(@h.include?('a')).must_equal "(h ? 'a')"
+    @ds.literal(@h.exist?('a')).must_equal "(h ? 'a')"
   end
 
   it "#hstore should return the receiver" do
-    @h.hstore.should equal(@h)
+    @h.hstore.must_be_same_as(@h)
   end
 
   it "#keys and #akeys should use the akeys function" do
-    @ds.literal(@h.keys).should == "akeys(h)"
-    @ds.literal(@h.akeys).should == "akeys(h)"
+    @ds.literal(@h.keys).must_equal "akeys(h)"
+    @ds.literal(@h.akeys).must_equal "akeys(h)"
   end
 
   it "#keys and #akeys should return PGArrayOps" do
-    @ds.literal(@h.keys[0]).should == "akeys(h)[0]"
-    @ds.literal(@h.akeys[0]).should == "akeys(h)[0]"
+    @ds.literal(@h.keys[0]).must_equal "akeys(h)[0]"
+    @ds.literal(@h.akeys[0]).must_equal "akeys(h)[0]"
   end
 
   it "#populate should use the populate_record function" do
-    @ds.literal(@h.populate(:a)).should == "populate_record(a, h)"
+    @ds.literal(@h.populate(:a)).must_equal "populate_record(a, h)"
   end
 
   it "#record_set should use the #= operator" do
-    @ds.literal(@h.record_set(:a)).should == "(a #= h)"
+    @ds.literal(@h.record_set(:a)).must_equal "(a #= h)"
   end
 
   it "#skeys should use the skeys function" do
-    @ds.literal(@h.skeys).should == "skeys(h)"
+    @ds.literal(@h.skeys).must_equal "skeys(h)"
   end
 
   it "#slice should should use the slice function" do
-    @ds.literal(@h.slice(:a)).should == "slice(h, a)"
+    @ds.literal(@h.slice(:a)).must_equal "slice(h, a)"
   end
 
   it "#slice should handle arrays" do
-    @ds.literal(@h.slice(%w'a')).should == "slice(h, ARRAY['a'])"
+    @ds.literal(@h.slice(%w'a')).must_equal "slice(h, ARRAY['a'])"
   end
 
   it "#slice should return an HStoreOp" do
-    @ds.literal(@h.slice(:a)['a']).should == "(slice(h, a) -> 'a')"
+    @ds.literal(@h.slice(:a)['a']).must_equal "(slice(h, a) -> 'a')"
   end
 
   it "#svals should use the svals function" do
-    @ds.literal(@h.svals).should == "svals(h)"
+    @ds.literal(@h.svals).must_equal "svals(h)"
   end
 
   it "#to_array should use the hstore_to_array function" do
-    @ds.literal(@h.to_array).should == "hstore_to_array(h)"
+    @ds.literal(@h.to_array).must_equal "hstore_to_array(h)"
   end
 
   it "#to_array should return a PGArrayOp" do
-    @ds.literal(@h.to_array[0]).should == "hstore_to_array(h)[0]"
+    @ds.literal(@h.to_array[0]).must_equal "hstore_to_array(h)[0]"
   end
 
   it "#to_matrix should use the hstore_to_matrix function" do
-    @ds.literal(@h.to_matrix).should == "hstore_to_matrix(h)"
+    @ds.literal(@h.to_matrix).must_equal "hstore_to_matrix(h)"
   end
 
   it "#to_matrix should return a PGArrayOp" do
-    @ds.literal(@h.to_matrix[0]).should == "hstore_to_matrix(h)[0]"
+    @ds.literal(@h.to_matrix[0]).must_equal "hstore_to_matrix(h)[0]"
   end
 
   it "#values and #avals should use the avals function" do
-    @ds.literal(@h.values).should == "avals(h)"
-    @ds.literal(@h.avals).should == "avals(h)"
+    @ds.literal(@h.values).must_equal "avals(h)"
+    @ds.literal(@h.avals).must_equal "avals(h)"
   end
 
   it "#values and #avals should return PGArrayOps" do
-    @ds.literal(@h.values[0]).should == "avals(h)[0]"
-    @ds.literal(@h.avals[0]).should == "avals(h)[0]"
+    @ds.literal(@h.values[0]).must_equal "avals(h)[0]"
+    @ds.literal(@h.avals[0]).must_equal "avals(h)[0]"
   end
 
   it "should have Sequel.hstore_op return HStoreOp instances as-is" do
-    Sequel.hstore_op(@h).should equal(@h)
+    Sequel.hstore_op(@h).must_be_same_as(@h)
   end
 
   it "should have Sequel.hstore return HStoreOp instances" do
-    Sequel.hstore(:h).should == @h
+    Sequel.hstore(:h).must_equal @h
   end
 
   it "should be able to turn expressions into hstore ops using hstore" do
-    @ds.literal(Sequel.qualify(:b, :a).hstore['a']).should == "(b.a -> 'a')"
-    @ds.literal(Sequel.function(:a, :b).hstore['a']).should == "(a(b) -> 'a')"
+    @ds.literal(Sequel.qualify(:b, :a).hstore['a']).must_equal "(b.a -> 'a')"
+    @ds.literal(Sequel.function(:a, :b).hstore['a']).must_equal "(a(b) -> 'a')"
   end
 
   it "should be able to turn literal strings into hstore ops using hstore" do
-    @ds.literal(Sequel.lit('a').hstore['a']).should == "(a -> 'a')"
+    @ds.literal(Sequel.lit('a').hstore['a']).must_equal "(a -> 'a')"
   end
 
   it "should allow transforming HStore instances into HStoreOp instances" do
-    @ds.literal(Sequel.hstore('a'=>'b').op['a']).should == "('\"a\"=>\"b\"'::hstore -> 'a')"
+    @ds.literal(Sequel.hstore('a'=>'b').op['a']).must_equal "('\"a\"=>\"b\"'::hstore -> 'a')"
   end
 end

data/spec/extensions/pg_hstore_spec.rb

@@ -10,197 +10,197 @@ describe "pg_hstore extension" do
   end
 
   it "should parse hstore strings correctly" do
-    @c.parse('').to_hash.should == {}
-    @c.parse('"a"=>"b"').to_hash.should == {'a'=>'b'}
-    @c.parse('"a"=>"b", "c"=>NULL').to_hash.should == {'a'=>'b', 'c'=>nil}
-    @c.parse('"a"=>"b", "c"=>"NULL"').to_hash.should == {'a'=>'b', 'c'=>'NULL'}
-    @c.parse('"a"=>"b", "c"=>"\\\\ \\"\'=>"').to_hash.should == {'a'=>'b', 'c'=>'\ "\'=>'}
+    @c.parse('').to_hash.must_equal({})
+    @c.parse('"a"=>"b"').to_hash.must_equal('a'=>'b')
+    @c.parse('"a"=>"b", "c"=>NULL').to_hash.must_equal('a'=>'b', 'c'=>nil)
+    @c.parse('"a"=>"b", "c"=>"NULL"').to_hash.must_equal('a'=>'b', 'c'=>'NULL')
+    @c.parse('"a"=>"b", "c"=>"\\\\ \\"\'=>"').to_hash.must_equal('a'=>'b', 'c'=>'\ "\'=>')
   end
 
   it "should cache parse results" do
     r = @c::Parser.new('')
     o = r.parse
-    o.should == {}
-    r.parse.should equal(o)
+    o.must_equal({})
+    r.parse.must_be_same_as(o)
   end
 
   it "should literalize HStores to strings correctly" do
-    @db.literal(Sequel.hstore({})).should == '\'\'::hstore'
-    @db.literal(Sequel.hstore("a"=>"b")).should == '\'"a"=>"b"\'::hstore'
-    @db.literal(Sequel.hstore("c"=>nil)).should == '\'"c"=>NULL\'::hstore'
-    @db.literal(Sequel.hstore("c"=>'NULL')).should == '\'"c"=>"NULL"\'::hstore'
-    @db.literal(Sequel.hstore('c'=>'\ "\'=>')).should == '\'"c"=>"\\\\ \\"\'\'=>"\'::hstore'
-    ['\'"a"=>"b","c"=>"d"\'::hstore', '\'"c"=>"d","a"=>"b"\'::hstore'].should include(@db.literal(Sequel.hstore("a"=>"b","c"=>"d")))
+    @db.literal(Sequel.hstore({})).must_equal '\'\'::hstore'
+    @db.literal(Sequel.hstore("a"=>"b")).must_equal '\'"a"=>"b"\'::hstore'
+    @db.literal(Sequel.hstore("c"=>nil)).must_equal '\'"c"=>NULL\'::hstore'
+    @db.literal(Sequel.hstore("c"=>'NULL')).must_equal '\'"c"=>"NULL"\'::hstore'
+    @db.literal(Sequel.hstore('c'=>'\ "\'=>')).must_equal '\'"c"=>"\\\\ \\"\'\'=>"\'::hstore'
+    ['\'"a"=>"b","c"=>"d"\'::hstore', '\'"c"=>"d","a"=>"b"\'::hstore'].must_include(@db.literal(Sequel.hstore("a"=>"b","c"=>"d")))
   end
 
   it "should have Sequel.hstore method for creating HStore instances" do
-    Sequel.hstore({}).should be_a_kind_of(@c)
+    Sequel.hstore({}).class.must_equal(@c)
   end
 
   it "should have Sequel.hstore return HStores as-is" do
     a = Sequel.hstore({})
-    Sequel.hstore(a).should equal(a)
+    Sequel.hstore(a).object_id.must_equal(a.object_id)
   end
 
   it "should HStore#to_hash method for getting underlying hash" do
-    Sequel.hstore({}).to_hash.should be_a_kind_of(Hash)
+    Sequel.hstore({}).to_hash.must_be_kind_of(Hash)
   end
 
   it "should convert keys and values to strings on creation" do
-    Sequel.hstore(1=>2).to_hash.should == {"1"=>"2"}
+    Sequel.hstore(1=>2).to_hash.must_equal("1"=>"2")
   end
 
   it "should convert keys and values to strings on assignment" do
     v = Sequel.hstore({})
     v[1] = 2
-    v.to_hash.should == {"1"=>"2"}
+    v.to_hash.must_equal("1"=>"2")
     v.store(:'1', 3)
-    v.to_hash.should == {"1"=>"3"}
+    v.to_hash.must_equal("1"=>"3")
   end
 
   it "should not convert nil values to strings on creation" do
-    Sequel.hstore(:foo=>nil).to_hash.should == {"foo"=>nil}
+    Sequel.hstore(:foo=>nil).to_hash.must_equal("foo"=>nil)
   end
 
   it "should not convert nil values to strings on assignment" do
     v = Sequel.hstore({})
     v[:foo] = nil
-    v.to_hash.should == {"foo"=>nil}
+    v.to_hash.must_equal("foo"=>nil)
   end
 
   it "should convert lookups by key to string" do
-    Sequel.hstore('foo'=>'bar')[:foo].should == 'bar'
-    Sequel.hstore('1'=>'bar')[1].should == 'bar'
+    Sequel.hstore('foo'=>'bar')[:foo].must_equal 'bar'
+    Sequel.hstore('1'=>'bar')[1].must_equal 'bar'
 
-    Sequel.hstore('foo'=>'bar').fetch(:foo).should == 'bar'
-    Sequel.hstore('foo'=>'bar').fetch(:foo2, 2).should == 2
+    Sequel.hstore('foo'=>'bar').fetch(:foo).must_equal 'bar'
+    Sequel.hstore('foo'=>'bar').fetch(:foo2, 2).must_equal 2
     k = nil
-    Sequel.hstore('foo2'=>'bar').fetch(:foo){|key| k = key }.should == 'foo'
-    k.should == 'foo'
+    Sequel.hstore('foo2'=>'bar').fetch(:foo){|key| k = key }.must_equal 'foo'
+    k.must_equal 'foo'
     
-    Sequel.hstore('foo'=>'bar').has_key?(:foo).should == true
-    Sequel.hstore('foo'=>'bar').has_key?(:bar).should == false
-    Sequel.hstore('foo'=>'bar').key?(:foo).should == true
-    Sequel.hstore('foo'=>'bar').key?(:bar).should == false
-    Sequel.hstore('foo'=>'bar').member?(:foo).should == true
-    Sequel.hstore('foo'=>'bar').member?(:bar).should == false
-    Sequel.hstore('foo'=>'bar').include?(:foo).should == true
-    Sequel.hstore('foo'=>'bar').include?(:bar).should == false
+    Sequel.hstore('foo'=>'bar').has_key?(:foo).must_equal true
+    Sequel.hstore('foo'=>'bar').has_key?(:bar).must_equal false
+    Sequel.hstore('foo'=>'bar').key?(:foo).must_equal true
+    Sequel.hstore('foo'=>'bar').key?(:bar).must_equal false
+    Sequel.hstore('foo'=>'bar').member?(:foo).must_equal true
+    Sequel.hstore('foo'=>'bar').member?(:bar).must_equal false
+    Sequel.hstore('foo'=>'bar').include?(:foo).must_equal true
+    Sequel.hstore('foo'=>'bar').include?(:bar).must_equal false
 
-    Sequel.hstore('foo'=>'bar', '1'=>'2').values_at(:foo3, :foo, :foo2, 1).should == [nil, 'bar', nil, '2']
+    Sequel.hstore('foo'=>'bar', '1'=>'2').values_at(:foo3, :foo, :foo2, 1).must_equal [nil, 'bar', nil, '2']
 
     if RUBY_VERSION >= '1.9.0'
-      Sequel.hstore('foo'=>'bar').assoc(:foo).should == ['foo', 'bar']
-      Sequel.hstore('foo'=>'bar').assoc(:foo2).should == nil
+      Sequel.hstore('foo'=>'bar').assoc(:foo).must_equal ['foo', 'bar']
+      Sequel.hstore('foo'=>'bar').assoc(:foo2).must_equal nil
     end
   end
 
   it "should convert has_value?/value? lookups to string" do
-    Sequel.hstore('foo'=>'bar').has_value?(:bar).should == true
-    Sequel.hstore('foo'=>'bar').has_value?(:foo).should == false
-    Sequel.hstore('foo'=>'bar').value?(:bar).should == true
-    Sequel.hstore('foo'=>'bar').value?(:foo).should == false
+    Sequel.hstore('foo'=>'bar').has_value?(:bar).must_equal true
+    Sequel.hstore('foo'=>'bar').has_value?(:foo).must_equal false
+    Sequel.hstore('foo'=>'bar').value?(:bar).must_equal true
+    Sequel.hstore('foo'=>'bar').value?(:foo).must_equal false
   end
 
   it "should handle nil values in has_value?/value? lookups" do
-    Sequel.hstore('foo'=>'').has_value?('').should == true
-    Sequel.hstore('foo'=>'').has_value?(nil).should == false
-    Sequel.hstore('foo'=>nil).has_value?(nil).should == true
+    Sequel.hstore('foo'=>'').has_value?('').must_equal true
+    Sequel.hstore('foo'=>'').has_value?(nil).must_equal false
+    Sequel.hstore('foo'=>nil).has_value?(nil).must_equal true
   end
 
   it "should have underlying hash convert lookups by key to string" do
-    Sequel.hstore('foo'=>'bar').to_hash[:foo].should == 'bar'
-    Sequel.hstore('1'=>'bar').to_hash[1].should == 'bar'
+    Sequel.hstore('foo'=>'bar').to_hash[:foo].must_equal 'bar'
+    Sequel.hstore('1'=>'bar').to_hash[1].must_equal 'bar'
   end
 
   if RUBY_VERSION >= '1.9.0'
     it "should convert key lookups to string" do
-      Sequel.hstore('foo'=>'bar').key(:bar).should == 'foo'
-      Sequel.hstore('foo'=>'bar').key(:bar2).should be_nil
+      Sequel.hstore('foo'=>'bar').key(:bar).must_equal 'foo'
+      Sequel.hstore('foo'=>'bar').key(:bar2).must_equal nil
     end
 
     it "should handle nil values in key lookups" do
-      Sequel.hstore('foo'=>'').key('').should == 'foo'
-      Sequel.hstore('foo'=>'').key(nil).should == nil
-      Sequel.hstore('foo'=>nil).key(nil).should == 'foo'
+      Sequel.hstore('foo'=>'').key('').must_equal 'foo'
+      Sequel.hstore('foo'=>'').key(nil).must_equal nil
+      Sequel.hstore('foo'=>nil).key(nil).must_equal 'foo'
     end
 
     it "should convert rassoc lookups to string" do
-      Sequel.hstore('foo'=>'bar').rassoc(:bar).should == ['foo', 'bar']
-      Sequel.hstore('foo'=>'bar').rassoc(:bar2).should be_nil
+      Sequel.hstore('foo'=>'bar').rassoc(:bar).must_equal ['foo', 'bar']
+      Sequel.hstore('foo'=>'bar').rassoc(:bar2).must_equal nil
     end
 
     it "should handle nil values in rassoc lookups" do
-      Sequel.hstore('foo'=>'').rassoc('').should == ['foo', '']
-      Sequel.hstore('foo'=>'').rassoc(nil).should == nil
-      Sequel.hstore('foo'=>nil).rassoc(nil).should == ['foo', nil]
+      Sequel.hstore('foo'=>'').rassoc('').must_equal ['foo', '']
+      Sequel.hstore('foo'=>'').rassoc(nil).must_equal nil
+      Sequel.hstore('foo'=>nil).rassoc(nil).must_equal ['foo', nil]
     end
   end
 
   it "should have delete convert key to string" do
     v = Sequel.hstore('foo'=>'bar')
-    v.delete(:foo).should == 'bar'
-    v.to_hash.should == {}
+    v.delete(:foo).must_equal 'bar'
+    v.to_hash.must_equal({})
   end
 
   it "should handle #replace with hashes that do not use strings" do
     v = Sequel.hstore('foo'=>'bar')
     v.replace(:bar=>1)
-    v.should be_a_kind_of(@c)
-    v.should == {'bar'=>'1'}
-    v.to_hash[:bar].should == '1'
+    v.class.must_equal(@c)
+    v.must_equal('bar'=>'1')
+    v.to_hash[:bar].must_equal '1'
   end
 
   it "should handle #merge with hashes that do not use strings" do
     v = Sequel.hstore('foo'=>'bar').merge(:bar=>1)
-    v.should be_a_kind_of(@c)
-    v.should == {'foo'=>'bar', 'bar'=>'1'}
+    v.class.must_equal(@c)
+    v.must_equal('foo'=>'bar', 'bar'=>'1')
   end
 
   it "should handle #merge/#update with hashes that do not use strings" do
     v = Sequel.hstore('foo'=>'bar')
     v.merge!(:bar=>1)
-    v.should be_a_kind_of(@c)
-    v.should == {'foo'=>'bar', 'bar'=>'1'}
+    v.class.must_equal(@c)
+    v.must_equal('foo'=>'bar', 'bar'=>'1')
 
     v = Sequel.hstore('foo'=>'bar')
     v.update(:bar=>1)
-    v.should be_a_kind_of(@c)
-    v.should == {'foo'=>'bar', 'bar'=>'1'}
+    v.class.must_equal(@c)
+    v.must_equal('foo'=>'bar', 'bar'=>'1')
   end
 
   it "should support using hstores as bound variables" do
-    @db.bound_variable_arg(1, nil).should == 1
-    @db.bound_variable_arg({'1'=>'2'}, nil).should == '"1"=>"2"'
-    @db.bound_variable_arg(Sequel.hstore('1'=>'2'), nil).should == '"1"=>"2"'
-    @db.bound_variable_arg(Sequel.hstore('1'=>nil), nil).should == '"1"=>NULL'
-    @db.bound_variable_arg(Sequel.hstore('1'=>"NULL"), nil).should == '"1"=>"NULL"'
-    @db.bound_variable_arg(Sequel.hstore('1'=>"'\\ \"=>"), nil).should == '"1"=>"\'\\\\ \\"=>"'
-    ['"a"=>"b","c"=>"d"', '"c"=>"d","a"=>"b"'].should include(@db.bound_variable_arg(Sequel.hstore("a"=>"b","c"=>"d"), nil))
+    @db.bound_variable_arg(1, nil).must_equal 1
+    @db.bound_variable_arg({'1'=>'2'}, nil).must_equal '"1"=>"2"'
+    @db.bound_variable_arg(Sequel.hstore('1'=>'2'), nil).must_equal '"1"=>"2"'
+    @db.bound_variable_arg(Sequel.hstore('1'=>nil), nil).must_equal '"1"=>NULL'
+    @db.bound_variable_arg(Sequel.hstore('1'=>"NULL"), nil).must_equal '"1"=>"NULL"'
+    @db.bound_variable_arg(Sequel.hstore('1'=>"'\\ \"=>"), nil).must_equal '"1"=>"\'\\\\ \\"=>"'
+    ['"a"=>"b","c"=>"d"', '"c"=>"d","a"=>"b"'].must_include(@db.bound_variable_arg(Sequel.hstore("a"=>"b","c"=>"d"), nil))
   end
 
   it "should parse hstore type from the schema correctly" do
     @db.fetch = [{:name=>'id', :db_type=>'integer'}, {:name=>'i', :db_type=>'hstore'}]
-    @db.schema(:items).map{|e| e[1][:type]}.should == [:integer, :hstore]
+    @db.schema(:items).map{|e| e[1][:type]}.must_equal [:integer, :hstore]
   end
 
   it "should support typecasting for the hstore type" do
     h = Sequel.hstore(1=>2)
-    @db.typecast_value(:hstore, h).should equal(h)
-    @db.typecast_value(:hstore, {}).should be_a_kind_of(@c)
-    @db.typecast_value(:hstore, {}).should == Sequel.hstore({})
-    @db.typecast_value(:hstore, {'a'=>'b'}).should == Sequel.hstore("a"=>"b")
-    proc{@db.typecast_value(:hstore, [])}.should raise_error(Sequel::InvalidValue)
+    @db.typecast_value(:hstore, h).object_id.must_equal(h.object_id)
+    @db.typecast_value(:hstore, {}).class.must_equal(@c)
+    @db.typecast_value(:hstore, {}).must_equal Sequel.hstore({})
+    @db.typecast_value(:hstore, {'a'=>'b'}).must_equal Sequel.hstore("a"=>"b")
+    proc{@db.typecast_value(:hstore, [])}.must_raise(Sequel::InvalidValue)
   end
 
   it "should be serializable" do 
     v = Sequel.hstore('foo'=>'bar')
     dump = Marshal.dump(v) 
-    Marshal.load(dump).should == v    
+    Marshal.load(dump).must_equal v    
   end 
 
   it "should return correct results for Database#schema_type_class" do
-    @db.schema_type_class(:hstore).should == Sequel::Postgres::HStore
-    @db.schema_type_class(:integer).should == Integer
+    @db.schema_type_class(:hstore).must_equal Sequel::Postgres::HStore
+    @db.schema_type_class(:integer).must_equal Integer
   end
 end