sequel 4.22.0 → 4.23.0

data/spec/extensions/pg_json_spec.rb

@@ -17,37 +17,37 @@ describe "pg_json extension" do
   end
 
   it "should parse json strings correctly" do
-    @m.parse_json('[]').should be_a_kind_of(@ac)
-    @m.parse_json('[]').to_a.should == []
-    @m.parse_json('[1]').to_a.should == [1]
-    @m.parse_json('[1, 2]').to_a.should == [1, 2]
-    @m.parse_json('[1, [2], {"a": "b"}]').to_a.should == [1, [2], {'a'=>'b'}]
-    @m.parse_json('{}').should be_a_kind_of(@hc)
-    @m.parse_json('{}').to_hash.should == {}
-    @m.parse_json('{"a": "b"}').to_hash.should == {'a'=>'b'}
-    @m.parse_json('{"a": "b", "c": [1, 2, 3]}').to_hash.should == {'a'=>'b', 'c'=>[1, 2, 3]}
-    @m.parse_json('{"a": "b", "c": {"d": "e"}}').to_hash.should == {'a'=>'b', 'c'=>{'d'=>'e'}}
+    @m.parse_json('[]').class.must_equal(@ac)
+    @m.parse_json('[]').to_a.must_equal []
+    @m.parse_json('[1]').to_a.must_equal [1]
+    @m.parse_json('[1, 2]').to_a.must_equal [1, 2]
+    @m.parse_json('[1, [2], {"a": "b"}]').to_a.must_equal [1, [2], {'a'=>'b'}]
+    @m.parse_json('{}').class.must_equal(@hc)
+    @m.parse_json('{}').to_hash.must_equal({})
+    @m.parse_json('{"a": "b"}').to_hash.must_equal('a'=>'b')
+    @m.parse_json('{"a": "b", "c": [1, 2, 3]}').to_hash.must_equal('a'=>'b', 'c'=>[1, 2, 3])
+    @m.parse_json('{"a": "b", "c": {"d": "e"}}').to_hash.must_equal('a'=>'b', 'c'=>{'d'=>'e'})
   end
 
   it "should parse json and non-json plain strings, integers, and floats correctly in db_parse_json" do
-    @m.db_parse_json('{"a": "b", "c": {"d": "e"}}').to_hash.should == {'a'=>'b', 'c'=>{'d'=>'e'}}
-    @m.db_parse_json('[1, [2], {"a": "b"}]').to_a.should == [1, [2], {'a'=>'b'}]
-    @m.db_parse_json('1').should == 1
-    @m.db_parse_json('"b"').should == 'b'
-    @m.db_parse_json('1.1').should == 1.1
+    @m.db_parse_json('{"a": "b", "c": {"d": "e"}}').to_hash.must_equal('a'=>'b', 'c'=>{'d'=>'e'})
+    @m.db_parse_json('[1, [2], {"a": "b"}]').to_a.must_equal [1, [2], {'a'=>'b'}]
+    @m.db_parse_json('1').must_equal 1
+    @m.db_parse_json('"b"').must_equal 'b'
+    @m.db_parse_json('1.1').must_equal 1.1
   end
 
   it "should parse json and non-json plain strings, integers, and floats correctly in db_parse_jsonb" do
-    @m.db_parse_jsonb('{"a": "b", "c": {"d": "e"}}').to_hash.should == {'a'=>'b', 'c'=>{'d'=>'e'}}
-    @m.db_parse_jsonb('[1, [2], {"a": "b"}]').to_a.should == [1, [2], {'a'=>'b'}]
-    @m.db_parse_jsonb('1').should == 1
-    @m.db_parse_jsonb('"b"').should == 'b'
-    @m.db_parse_jsonb('1.1').should == 1.1
+    @m.db_parse_jsonb('{"a": "b", "c": {"d": "e"}}').to_hash.must_equal('a'=>'b', 'c'=>{'d'=>'e'})
+    @m.db_parse_jsonb('[1, [2], {"a": "b"}]').to_a.must_equal [1, [2], {'a'=>'b'}]
+    @m.db_parse_jsonb('1').must_equal 1
+    @m.db_parse_jsonb('"b"').must_equal 'b'
+    @m.db_parse_jsonb('1.1').must_equal 1.1
   end
 
   it "should raise an error when attempting to parse invalid json" do
-    proc{@m.parse_json('')}.should raise_error(Sequel::InvalidValue)
-    proc{@m.parse_json('1')}.should raise_error(Sequel::InvalidValue)
+    proc{@m.parse_json('')}.must_raise(Sequel::InvalidValue)
+    proc{@m.parse_json('1')}.must_raise(Sequel::InvalidValue)
 
     begin
       Sequel.instance_eval do
@@ -56,12 +56,12 @@ describe "pg_json extension" do
           {'1'=>1, "'a'"=>'a', 'true'=>true, 'false'=>false, 'null'=>nil, 'o'=>Object.new}.fetch(v){pj(v)}
         end
       end
-      @m.parse_json('1').should == 1
-      @m.parse_json("'a'").should == 'a'
-      @m.parse_json('true').should == true
-      @m.parse_json('false').should == false
-      @m.parse_json('null').should == nil
-      proc{@m.parse_json('o')}.should raise_error(Sequel::InvalidValue)
+      @m.parse_json('1').must_equal 1
+      @m.parse_json("'a'").must_equal 'a'
+      @m.parse_json('true').must_equal true
+      @m.parse_json('false').must_equal false
+      @m.parse_json('null').must_equal nil
+      proc{@m.parse_json('o')}.must_raise(Sequel::InvalidValue)
     ensure
       Sequel.instance_eval do
         alias parse_json pj
@@ -70,149 +70,149 @@ describe "pg_json extension" do
   end
 
   it "should literalize JSONHash and JSONArray to strings correctly" do
-    @db.literal(Sequel.pg_json([])).should == "'[]'::json"
-    @db.literal(Sequel.pg_json([1, [2], {'a'=>'b'}])).should == "'[1,[2],{\"a\":\"b\"}]'::json"
-    @db.literal(Sequel.pg_json({})).should == "'{}'::json"
-    @db.literal(Sequel.pg_json('a'=>'b')).should == "'{\"a\":\"b\"}'::json"
+    @db.literal(Sequel.pg_json([])).must_equal "'[]'::json"
+    @db.literal(Sequel.pg_json([1, [2], {'a'=>'b'}])).must_equal "'[1,[2],{\"a\":\"b\"}]'::json"
+    @db.literal(Sequel.pg_json({})).must_equal "'{}'::json"
+    @db.literal(Sequel.pg_json('a'=>'b')).must_equal "'{\"a\":\"b\"}'::json"
   end
 
   it "should literalize JSONHash and JSONArray to strings correctly" do
-    @db.literal(Sequel.pg_jsonb([])).should == "'[]'::jsonb"
-    @db.literal(Sequel.pg_jsonb([1, [2], {'a'=>'b'}])).should == "'[1,[2],{\"a\":\"b\"}]'::jsonb"
-    @db.literal(Sequel.pg_jsonb({})).should == "'{}'::jsonb"
-    @db.literal(Sequel.pg_jsonb('a'=>'b')).should == "'{\"a\":\"b\"}'::jsonb"
+    @db.literal(Sequel.pg_jsonb([])).must_equal "'[]'::jsonb"
+    @db.literal(Sequel.pg_jsonb([1, [2], {'a'=>'b'}])).must_equal "'[1,[2],{\"a\":\"b\"}]'::jsonb"
+    @db.literal(Sequel.pg_jsonb({})).must_equal "'{}'::jsonb"
+    @db.literal(Sequel.pg_jsonb('a'=>'b')).must_equal "'{\"a\":\"b\"}'::jsonb"
   end
 
   it "should have Sequel.pg_json return JSONHash and JSONArray as is" do
     a = Sequel.pg_json({})
-    Sequel.pg_json(a).should equal(a)
+    Sequel.pg_json(a).object_id.must_equal(a.object_id)
     a = Sequel.pg_json([])
-    Sequel.pg_json(a).should equal(a)
+    Sequel.pg_json(a).object_id.must_equal(a.object_id)
   end
 
   it "should have Sequel.pg_json convert jsonb values" do
     a = {}
     v = Sequel.pg_json(Sequel.pg_jsonb(a))
-    v.to_hash.should equal(a)
-    v.should be_a_kind_of(@hc)
+    v.to_hash.must_be_same_as(a)
+    v.class.must_equal(@hc)
 
     a = []
     v = Sequel.pg_json(Sequel.pg_jsonb(a))
-    v.to_a.should equal(a)
-    v.should be_a_kind_of(@ac)
+    v.to_a.must_be_same_as(a)
+    v.class.must_equal(@ac)
   end
 
   it "should have Sequel.pg_jsonb return JSONBHash and JSONBArray as is" do
     a = Sequel.pg_jsonb({})
-    Sequel.pg_jsonb(a).should equal(a)
+    Sequel.pg_jsonb(a).object_id.must_equal(a.object_id)
     a = Sequel.pg_jsonb([])
-    Sequel.pg_jsonb(a).should equal(a)
+    Sequel.pg_jsonb(a).object_id.must_equal(a.object_id)
   end
 
   it "should have Sequel.pg_jsonb convert json values" do
     a = {}
     v = Sequel.pg_jsonb(Sequel.pg_json(a))
-    v.to_hash.should equal(a)
-    v.should be_a_kind_of(@bhc)
+    v.to_hash.must_be_same_as(a)
+    v.class.must_equal(@bhc)
 
     a = []
     v = Sequel.pg_jsonb(Sequel.pg_json(a))
-    v.to_a.should equal(a)
-    v.should be_a_kind_of(@bac)
+    v.to_a.must_be_same_as(a)
+    v.class.must_equal(@bac)
   end
 
   it "should have JSONHashBase#to_hash method for getting underlying hash" do
-    Sequel.pg_json({}).to_hash.should be_a_kind_of(Hash)
-    Sequel.pg_jsonb({}).to_hash.should be_a_kind_of(Hash)
+    Sequel.pg_json({}).to_hash.must_be_kind_of(Hash)
+    Sequel.pg_jsonb({}).to_hash.must_be_kind_of(Hash)
   end
 
   it "should allow aliasing json objects" do
-    @db.literal(Sequel.pg_json({}).as(:a)).should == "'{}'::json AS a"
-    @db.literal(Sequel.pg_json([]).as(:a)).should == "'[]'::json AS a"
-    @db.literal(Sequel.pg_jsonb({}).as(:a)).should == "'{}'::jsonb AS a"
-    @db.literal(Sequel.pg_jsonb([]).as(:a)).should == "'[]'::jsonb AS a"
+    @db.literal(Sequel.pg_json({}).as(:a)).must_equal "'{}'::json AS a"
+    @db.literal(Sequel.pg_json([]).as(:a)).must_equal "'[]'::json AS a"
+    @db.literal(Sequel.pg_jsonb({}).as(:a)).must_equal "'{}'::jsonb AS a"
+    @db.literal(Sequel.pg_jsonb([]).as(:a)).must_equal "'[]'::jsonb AS a"
   end
 
   it "should allow casting json objects" do
-    @db.literal(Sequel.pg_json({}).cast(String)).should == "CAST('{}'::json AS text)"
-    @db.literal(Sequel.pg_json([]).cast(String)).should == "CAST('[]'::json AS text)"
-    @db.literal(Sequel.pg_jsonb({}).cast(String)).should == "CAST('{}'::jsonb AS text)"
-    @db.literal(Sequel.pg_jsonb([]).cast(String)).should == "CAST('[]'::jsonb AS text)"
+    @db.literal(Sequel.pg_json({}).cast(String)).must_equal "CAST('{}'::json AS text)"
+    @db.literal(Sequel.pg_json([]).cast(String)).must_equal "CAST('[]'::json AS text)"
+    @db.literal(Sequel.pg_jsonb({}).cast(String)).must_equal "CAST('{}'::jsonb AS text)"
+    @db.literal(Sequel.pg_jsonb([]).cast(String)).must_equal "CAST('[]'::jsonb AS text)"
   end
 
   it "should have JSONArrayBase#to_a method for getting underlying array" do
-    Sequel.pg_json([]).to_a.should be_a_kind_of(Array)
-    Sequel.pg_jsonb([]).to_a.should be_a_kind_of(Array)
+    Sequel.pg_json([]).to_a.must_be_kind_of(Array)
+    Sequel.pg_jsonb([]).to_a.must_be_kind_of(Array)
   end
 
   it "should support using JSONHashBase and JSONArrayBase as bound variables" do
-    @db.bound_variable_arg(1, nil).should == 1
-    @db.bound_variable_arg(Sequel.pg_json([1]), nil).should == '[1]'
-    @db.bound_variable_arg(Sequel.pg_json('a'=>'b'), nil).should == '{"a":"b"}'
-    @db.bound_variable_arg(Sequel.pg_jsonb([1]), nil).should == '[1]'
-    @db.bound_variable_arg(Sequel.pg_jsonb('a'=>'b'), nil).should == '{"a":"b"}'
+    @db.bound_variable_arg(1, nil).must_equal 1
+    @db.bound_variable_arg(Sequel.pg_json([1]), nil).must_equal '[1]'
+    @db.bound_variable_arg(Sequel.pg_json('a'=>'b'), nil).must_equal '{"a":"b"}'
+    @db.bound_variable_arg(Sequel.pg_jsonb([1]), nil).must_equal '[1]'
+    @db.bound_variable_arg(Sequel.pg_jsonb('a'=>'b'), nil).must_equal '{"a":"b"}'
   end
 
   it "should support using json[] and jsonb[] types in bound variables" do
-    @db.bound_variable_arg(Sequel.pg_array([Sequel.pg_json([{"a"=>1}]), Sequel.pg_json("b"=>[1, 2])]), nil).should == '{"[{\\"a\\":1}]","{\\"b\\":[1,2]}"}'
-    @db.bound_variable_arg(Sequel.pg_array([Sequel.pg_jsonb([{"a"=>1}]), Sequel.pg_jsonb("b"=>[1, 2])]), nil).should == '{"[{\\"a\\":1}]","{\\"b\\":[1,2]}"}'
+    @db.bound_variable_arg(Sequel.pg_array([Sequel.pg_json([{"a"=>1}]), Sequel.pg_json("b"=>[1, 2])]), nil).must_equal '{"[{\\"a\\":1}]","{\\"b\\":[1,2]}"}'
+    @db.bound_variable_arg(Sequel.pg_array([Sequel.pg_jsonb([{"a"=>1}]), Sequel.pg_jsonb("b"=>[1, 2])]), nil).must_equal '{"[{\\"a\\":1}]","{\\"b\\":[1,2]}"}'
   end
 
   it "should parse json type from the schema correctly" do
     @db.fetch = [{:name=>'id', :db_type=>'integer'}, {:name=>'i', :db_type=>'json'}]
-    @db.schema(:items).map{|e| e[1][:type]}.should == [:integer, :json]
+    @db.schema(:items).map{|e| e[1][:type]}.must_equal [:integer, :json]
   end
 
   it "should parse json type from the schema correctly" do
     @db.fetch = [{:name=>'id', :db_type=>'integer'}, {:name=>'i', :db_type=>'jsonb'}]
-    @db.schema(:items).map{|e| e[1][:type]}.should == [:integer, :jsonb]
+    @db.schema(:items).map{|e| e[1][:type]}.must_equal [:integer, :jsonb]
   end
 
   it "should support typecasting for the json type" do
     h = Sequel.pg_json(1=>2)
     a = Sequel.pg_json([1])
-    @db.typecast_value(:json, h).should equal(h)
-    @db.typecast_value(:json, h.to_hash).should == h
-    @db.typecast_value(:json, h.to_hash).should be_a_kind_of(@hc)
-    @db.typecast_value(:json, Sequel.pg_jsonb(h)).should == h
-    @db.typecast_value(:json, Sequel.pg_jsonb(h)).should be_a_kind_of(@hc)
-    @db.typecast_value(:json, a).should equal(a)
-    @db.typecast_value(:json, a.to_a).should == a
-    @db.typecast_value(:json, a.to_a).should be_a_kind_of(@ac)
-    @db.typecast_value(:json, Sequel.pg_jsonb(a)).should == a
-    @db.typecast_value(:json, Sequel.pg_jsonb(a)).should be_a_kind_of(@ac)
-    @db.typecast_value(:json, '[]').should == Sequel.pg_json([])
-    @db.typecast_value(:json, '[]').should be_a_kind_of(@ac)
-    @db.typecast_value(:json, '{"a": "b"}').should == Sequel.pg_json("a"=>"b")
-    @db.typecast_value(:json, '{"a": "b"}').should be_a_kind_of(@hc)
-    proc{@db.typecast_value(:json, '')}.should raise_error(Sequel::InvalidValue)
-    proc{@db.typecast_value(:json, 1)}.should raise_error(Sequel::InvalidValue)
+    @db.typecast_value(:json, h).object_id.must_equal(h.object_id)
+    @db.typecast_value(:json, h.to_hash).must_equal h
+    @db.typecast_value(:json, h.to_hash).class.must_equal(@hc)
+    @db.typecast_value(:json, Sequel.pg_jsonb(h)).must_equal h
+    @db.typecast_value(:json, Sequel.pg_jsonb(h)).class.must_equal(@hc)
+    @db.typecast_value(:json, a).object_id.must_equal(a.object_id)
+    @db.typecast_value(:json, a.to_a).must_equal a
+    @db.typecast_value(:json, a.to_a).class.must_equal(@ac)
+    @db.typecast_value(:json, Sequel.pg_jsonb(a)).must_equal a
+    @db.typecast_value(:json, Sequel.pg_jsonb(a)).class.must_equal(@ac)
+    @db.typecast_value(:json, '[]').must_equal Sequel.pg_json([])
+    @db.typecast_value(:json, '[]').class.must_equal(@ac)
+    @db.typecast_value(:json, '{"a": "b"}').must_equal Sequel.pg_json("a"=>"b")
+    @db.typecast_value(:json, '{"a": "b"}').class.must_equal(@hc)
+    proc{@db.typecast_value(:json, '')}.must_raise(Sequel::InvalidValue)
+    proc{@db.typecast_value(:json, 1)}.must_raise(Sequel::InvalidValue)
   end
 
   it "should support typecasting for the jsonb type" do
     h = Sequel.pg_jsonb(1=>2)
     a = Sequel.pg_jsonb([1])
-    @db.typecast_value(:jsonb, h).should equal(h)
-    @db.typecast_value(:jsonb, h.to_hash).should == h
-    @db.typecast_value(:jsonb, h.to_hash).should be_a_kind_of(@bhc)
-    @db.typecast_value(:jsonb, Sequel.pg_json(h)).should == h
-    @db.typecast_value(:jsonb, Sequel.pg_json(h)).should be_a_kind_of(@bhc)
-    @db.typecast_value(:jsonb, a).should equal(a)
-    @db.typecast_value(:jsonb, a.to_a).should == a
-    @db.typecast_value(:jsonb, a.to_a).should be_a_kind_of(@bac)
-    @db.typecast_value(:jsonb, Sequel.pg_json(a)).should == a
-    @db.typecast_value(:jsonb, Sequel.pg_json(a)).should be_a_kind_of(@bac)
-    @db.typecast_value(:jsonb, '[]').should == Sequel.pg_jsonb([])
-    @db.typecast_value(:jsonb, '[]').should be_a_kind_of(@bac)
-    @db.typecast_value(:jsonb, '{"a": "b"}').should == Sequel.pg_jsonb("a"=>"b")
-    @db.typecast_value(:jsonb, '{"a": "b"}').should be_a_kind_of(@bhc)
-    proc{@db.typecast_value(:jsonb, '')}.should raise_error(Sequel::InvalidValue)
-    proc{@db.typecast_value(:jsonb, 1)}.should raise_error(Sequel::InvalidValue)
+    @db.typecast_value(:jsonb, h).object_id.must_equal(h.object_id)
+    @db.typecast_value(:jsonb, h.to_hash).must_equal h
+    @db.typecast_value(:jsonb, h.to_hash).class.must_equal(@bhc)
+    @db.typecast_value(:jsonb, Sequel.pg_json(h)).must_equal h
+    @db.typecast_value(:jsonb, Sequel.pg_json(h)).class.must_equal(@bhc)
+    @db.typecast_value(:jsonb, a).object_id.must_equal(a.object_id)
+    @db.typecast_value(:jsonb, a.to_a).must_equal a
+    @db.typecast_value(:jsonb, a.to_a).class.must_equal(@bac)
+    @db.typecast_value(:jsonb, Sequel.pg_json(a)).must_equal a
+    @db.typecast_value(:jsonb, Sequel.pg_json(a)).class.must_equal(@bac)
+    @db.typecast_value(:jsonb, '[]').must_equal Sequel.pg_jsonb([])
+    @db.typecast_value(:jsonb, '[]').class.must_equal(@bac)
+    @db.typecast_value(:jsonb, '{"a": "b"}').must_equal Sequel.pg_jsonb("a"=>"b")
+    @db.typecast_value(:jsonb, '{"a": "b"}').class.must_equal(@bhc)
+    proc{@db.typecast_value(:jsonb, '')}.must_raise(Sequel::InvalidValue)
+    proc{@db.typecast_value(:jsonb, 1)}.must_raise(Sequel::InvalidValue)
   end
 
   it "should return correct results for Database#schema_type_class" do
-    @db.schema_type_class(:json).should == [Sequel::Postgres::JSONHash, Sequel::Postgres::JSONArray]
-    @db.schema_type_class(:jsonb).should == [Sequel::Postgres::JSONBHash, Sequel::Postgres::JSONBArray]
-    @db.schema_type_class(:integer).should == Integer
+    @db.schema_type_class(:json).must_equal [Sequel::Postgres::JSONHash, Sequel::Postgres::JSONArray]
+    @db.schema_type_class(:jsonb).must_equal [Sequel::Postgres::JSONBHash, Sequel::Postgres::JSONBArray]
+    @db.schema_type_class(:integer).must_equal Integer
   end
 end

data/spec/extensions/pg_loose_count_spec.rb

@@ -5,13 +5,13 @@ describe "pg_loose_count extension" do
     @db = Sequel.mock(:host=>'postgres', :fetch=>{:v=>1}).extension(:pg_loose_count)
   end
 
-  specify "should add loose_count method getting fast count for entire table using table statistics" do
-    @db.loose_count(:a).should == 1
-    @db.sqls.should == ["SELECT CAST(reltuples AS integer) AS v FROM pg_class WHERE (oid = CAST(CAST('a' AS regclass) AS oid)) LIMIT 1"]
+  it "should add loose_count method getting fast count for entire table using table statistics" do
+    @db.loose_count(:a).must_equal 1
+    @db.sqls.must_equal ["SELECT CAST(reltuples AS integer) AS v FROM pg_class WHERE (oid = CAST(CAST('a' AS regclass) AS oid)) LIMIT 1"]
   end
 
-  specify "should support schema qualified tables" do
-    @db.loose_count(:a__b).should == 1
-    @db.sqls.should == ["SELECT CAST(reltuples AS integer) AS v FROM pg_class WHERE (oid = CAST(CAST('a.b' AS regclass) AS oid)) LIMIT 1"]
+  it "should support schema qualified tables" do
+    @db.loose_count(:a__b).must_equal 1
+    @db.sqls.must_equal ["SELECT CAST(reltuples AS integer) AS v FROM pg_class WHERE (oid = CAST(CAST('a.b' AS regclass) AS oid)) LIMIT 1"]
   end
 end

data/spec/extensions/pg_range_ops_spec.rb

@@ -9,50 +9,50 @@ describe "Sequel::Postgres::RangeOp" do
   end
 
   it "#pg_range should return self" do
-    @h.pg_range.should equal(@h)
+    @h.pg_range.must_be_same_as(@h)
   end
 
   it "Sequel.pg_range_op should return argument if already a RangeOp" do
-    Sequel.pg_range_op(@h).should equal(@h)
+    Sequel.pg_range_op(@h).must_be_same_as(@h)
   end
 
   it "Sequel.pg_range should return a new RangeOp if not given a range" do
-    @ds.literal(Sequel.pg_range(:h).lower).should == "lower(h)"
+    @ds.literal(Sequel.pg_range(:h).lower).must_equal "lower(h)"
   end
 
   it "#pg_range should return a RangeOp for literal strings, and expressions" do
-    @ds.literal(Sequel.function(:b, :h).pg_range.lower).should == "lower(b(h))"
-    @ds.literal(Sequel.lit('h').pg_range.lower).should == "lower(h)"
+    @ds.literal(Sequel.function(:b, :h).pg_range.lower).must_equal "lower(b(h))"
+    @ds.literal(Sequel.lit('h').pg_range.lower).must_equal "lower(h)"
   end
 
   it "PGRange#op should return a RangeOp" do
-    @ds.literal(Sequel.pg_range(1..2, :numrange).op.lower).should == "lower('[1,2]'::numrange)"
+    @ds.literal(Sequel.pg_range(1..2, :numrange).op.lower).must_equal "lower('[1,2]'::numrange)"
   end
 
   it "should define methods for all of the PostgreSQL range operators" do
-    @ds.literal(@h.contains(@h)).should == "(h @> h)"
-    @ds.literal(@h.contained_by(@h)).should == "(h <@ h)"
-    @ds.literal(@h.overlaps(@h)).should == "(h && h)"
-    @ds.literal(@h.left_of(@h)).should == "(h << h)"
-    @ds.literal(@h.right_of(@h)).should == "(h >> h)"
-    @ds.literal(@h.ends_before(@h)).should == "(h &< h)"
-    @ds.literal(@h.starts_after(@h)).should == "(h &> h)"
-    @ds.literal(@h.adjacent_to(@h)).should == "(h -|- h)"
+    @ds.literal(@h.contains(@h)).must_equal "(h @> h)"
+    @ds.literal(@h.contained_by(@h)).must_equal "(h <@ h)"
+    @ds.literal(@h.overlaps(@h)).must_equal "(h && h)"
+    @ds.literal(@h.left_of(@h)).must_equal "(h << h)"
+    @ds.literal(@h.right_of(@h)).must_equal "(h >> h)"
+    @ds.literal(@h.ends_before(@h)).must_equal "(h &< h)"
+    @ds.literal(@h.starts_after(@h)).must_equal "(h &> h)"
+    @ds.literal(@h.adjacent_to(@h)).must_equal "(h -|- h)"
   end
 
   it "should define methods for all of the PostgreSQL range functions" do
-    @ds.literal(@h.lower).should == "lower(h)"
-    @ds.literal(@h.upper).should == "upper(h)"
-    @ds.literal(@h.isempty).should == "isempty(h)"
-    @ds.literal(@h.lower_inc).should == "lower_inc(h)"
-    @ds.literal(@h.upper_inc).should == "upper_inc(h)"
-    @ds.literal(@h.lower_inf).should == "lower_inf(h)"
-    @ds.literal(@h.upper_inf).should == "upper_inf(h)"
+    @ds.literal(@h.lower).must_equal "lower(h)"
+    @ds.literal(@h.upper).must_equal "upper(h)"
+    @ds.literal(@h.isempty).must_equal "isempty(h)"
+    @ds.literal(@h.lower_inc).must_equal "lower_inc(h)"
+    @ds.literal(@h.upper_inc).must_equal "upper_inc(h)"
+    @ds.literal(@h.lower_inf).must_equal "lower_inf(h)"
+    @ds.literal(@h.upper_inf).must_equal "upper_inf(h)"
   end
 
   it "+ - * operators should be defined and return a RangeOp" do
-    @ds.literal((@h + @h).lower).should == "lower((h + h))"
-    @ds.literal((@h * @h).lower).should == "lower((h * h))"
-    @ds.literal((@h - @h).lower).should == "lower((h - h))"
+    @ds.literal((@h + @h).lower).must_equal "lower((h + h))"
+    @ds.literal((@h * @h).lower).must_equal "lower((h * h))"
+    @ds.literal((@h - @h).lower).must_equal "lower((h - h))"
   end
 end

data/spec/extensions/pg_range_spec.rb

@@ -18,59 +18,59 @@ describe "pg_range extension" do
   end
 
   it "should literalize Range instances to strings correctly" do
-    @db.literal(Date.new(2011, 1, 2)...Date.new(2011, 3, 2)).should == "'[2011-01-02,2011-03-02)'"
-    @db.literal(Time.local(2011, 1, 2, 10, 20, 30)...Time.local(2011, 2, 3, 10, 20, 30)).should == "'[2011-01-02 10:20:30,2011-02-03 10:20:30)'"
-    @db.literal(DateTime.new(2011, 1, 2, 10, 20, 30)...DateTime.new(2011, 2, 3, 10, 20, 30)).should == "'[2011-01-02 10:20:30,2011-02-03 10:20:30)'"
-    @db.literal(DateTime.new(2011, 1, 2, 10, 20, 30)...DateTime.new(2011, 2, 3, 10, 20, 30)).should == "'[2011-01-02 10:20:30,2011-02-03 10:20:30)'"
-    @db.literal(1..2).should == "'[1,2]'"
-    @db.literal(1.0..2.0).should == "'[1.0,2.0]'"
-    @db.literal(BigDecimal.new('1.0')..BigDecimal.new('2.0')).should == "'[1.0,2.0]'"
-    @db.literal(Sequel.lit('a')..Sequel.lit('z')).should == "'[a,z]'"
-    @db.literal(''..'()[]",\\2').should == "'[\"\",\\(\\)\\[\\]\\\"\\,\\\\2]'"
+    @db.literal(Date.new(2011, 1, 2)...Date.new(2011, 3, 2)).must_equal "'[2011-01-02,2011-03-02)'"
+    @db.literal(Time.local(2011, 1, 2, 10, 20, 30)...Time.local(2011, 2, 3, 10, 20, 30)).must_equal "'[2011-01-02 10:20:30,2011-02-03 10:20:30)'"
+    @db.literal(DateTime.new(2011, 1, 2, 10, 20, 30)...DateTime.new(2011, 2, 3, 10, 20, 30)).must_equal "'[2011-01-02 10:20:30,2011-02-03 10:20:30)'"
+    @db.literal(DateTime.new(2011, 1, 2, 10, 20, 30)...DateTime.new(2011, 2, 3, 10, 20, 30)).must_equal "'[2011-01-02 10:20:30,2011-02-03 10:20:30)'"
+    @db.literal(1..2).must_equal "'[1,2]'"
+    @db.literal(1.0..2.0).must_equal "'[1.0,2.0]'"
+    @db.literal(BigDecimal.new('1.0')..BigDecimal.new('2.0')).must_equal "'[1.0,2.0]'"
+    @db.literal(Sequel.lit('a')..Sequel.lit('z')).must_equal "'[a,z]'"
+    @db.literal(''..'()[]",\\2').must_equal "'[\"\",\\(\\)\\[\\]\\\"\\,\\\\2]'"
   end
 
   it "should literalize PGRange instances to strings correctly" do
-    @db.literal(@R.new(1, 2)).should == "'[1,2]'"
-    @db.literal(@R.new(true, false)).should == "'[true,false]'"
-    @db.literal(@R.new(1, 2, :exclude_begin=>true)).should == "'(1,2]'"
-    @db.literal(@R.new(1, 2, :exclude_end=>true)).should == "'[1,2)'"
-    @db.literal(@R.new(nil, 2)).should == "'[,2]'"
-    @db.literal(@R.new(1, nil)).should == "'[1,]'"
-    @db.literal(@R.new(1, 2, :db_type=>'int8range')).should == "'[1,2]'::int8range"
-    @db.literal(@R.new(nil, nil, :empty=>true)).should == "'empty'"
-    @db.literal(@R.new("", 2)).should == "'[\"\",2]'"
+    @db.literal(@R.new(1, 2)).must_equal "'[1,2]'"
+    @db.literal(@R.new(true, false)).must_equal "'[true,false]'"
+    @db.literal(@R.new(1, 2, :exclude_begin=>true)).must_equal "'(1,2]'"
+    @db.literal(@R.new(1, 2, :exclude_end=>true)).must_equal "'[1,2)'"
+    @db.literal(@R.new(nil, 2)).must_equal "'[,2]'"
+    @db.literal(@R.new(1, nil)).must_equal "'[1,]'"
+    @db.literal(@R.new(1, 2, :db_type=>'int8range')).must_equal "'[1,2]'::int8range"
+    @db.literal(@R.new(nil, nil, :empty=>true)).must_equal "'empty'"
+    @db.literal(@R.new("", 2)).must_equal "'[\"\",2]'"
   end
 
   it "should not affect literalization of custom objects" do
     o = Object.new
     def o.sql_literal(ds) 'v' end
-    @db.literal(o).should == 'v'
+    @db.literal(o).must_equal 'v'
   end
 
   it "should support using Range instances as bound variables" do
-    @db.bound_variable_arg(1..2, nil).should == "[1,2]"
+    @db.bound_variable_arg(1..2, nil).must_equal "[1,2]"
   end
 
   it "should support using PGRange instances as bound variables" do
-    @db.bound_variable_arg(@R.new(1, 2), nil).should == "[1,2]"
+    @db.bound_variable_arg(@R.new(1, 2), nil).must_equal "[1,2]"
   end
 
   it "should support using arrays of Range instances as bound variables" do
-    @db.bound_variable_arg([1..2,2...3], nil).should == '{"[1,2]","[2,3)"}'
+    @db.bound_variable_arg([1..2,2...3], nil).must_equal '{"[1,2]","[2,3)"}'
   end
 
   it "should support using PGRange instances as bound variables" do
-    @db.bound_variable_arg([@R.new(1, 2),@R.new(2, 3)], nil).should == '{"[1,2]","[2,3]"}'
+    @db.bound_variable_arg([@R.new(1, 2),@R.new(2, 3)], nil).must_equal '{"[1,2]","[2,3]"}'
   end
 
   it "should parse range types from the schema correctly" do
     @db.fetch = [{:name=>'id', :db_type=>'integer'}, {:name=>'i4', :db_type=>'int4range'}, {:name=>'i8', :db_type=>'int8range'}, {:name=>'n', :db_type=>'numrange'}, {:name=>'d', :db_type=>'daterange'}, {:name=>'ts', :db_type=>'tsrange'}, {:name=>'tz', :db_type=>'tstzrange'}]
-    @db.schema(:items).map{|e| e[1][:type]}.should == [:integer, :int4range, :int8range, :numrange, :daterange, :tsrange, :tstzrange]
+    @db.schema(:items).map{|e| e[1][:type]}.must_equal [:integer, :int4range, :int8range, :numrange, :daterange, :tsrange, :tstzrange]
   end
 
   it "should parse arrays of range types from the schema correctly" do
     @db.fetch = [{:name=>'id', :db_type=>'integer'}, {:name=>'i4', :db_type=>'int4range[]'}, {:name=>'i8', :db_type=>'int8range[]'}, {:name=>'n', :db_type=>'numrange[]'}, {:name=>'d', :db_type=>'daterange[]'}, {:name=>'ts', :db_type=>'tsrange[]'}, {:name=>'tz', :db_type=>'tstzrange[]'}]
-    @db.schema(:items).map{|e| e[1][:type]}.should == [:integer, :int4range_array, :int8range_array, :numrange_array, :daterange_array, :tsrange_array, :tstzrange_array]
+    @db.schema(:items).map{|e| e[1][:type]}.must_equal [:integer, :int4range_array, :int8range_array, :numrange_array, :daterange_array, :tsrange_array, :tstzrange_array]
   end
 
   describe "database typecasting" do
@@ -83,91 +83,91 @@ describe "pg_range extension" do
     
     it "should handle multiple range types" do
       %w'int4 int8 num date ts tstz'.each do |i|
-        @db.typecast_value(:"#{i}range", @R.new(1, 2, :db_type=>"#{i}range")).should == @R.new(1, 2, :db_type=>"#{i}range")
+        @db.typecast_value(:"#{i}range", @R.new(1, 2, :db_type=>"#{i}range")).must_equal @R.new(1, 2, :db_type=>"#{i}range")
       end
     end
 
     it "should handle multiple array range types" do
       %w'int4 int8 num date ts tstz'.each do |i|
-        @db.typecast_value(:"#{i}range_array", [@R.new(1, 2, :db_type=>"#{i}range")]).should be_a_kind_of(Sequel::Postgres::PGArray)
-        @db.typecast_value(:"#{i}range_array", [@R.new(1, 2, :db_type=>"#{i}range")]).should == [@R.new(1, 2, :db_type=>"#{i}range")]
+        @db.typecast_value(:"#{i}range_array", [@R.new(1, 2, :db_type=>"#{i}range")]).class.must_equal(Sequel::Postgres::PGArray)
+        @db.typecast_value(:"#{i}range_array", [@R.new(1, 2, :db_type=>"#{i}range")]).must_equal [@R.new(1, 2, :db_type=>"#{i}range")]
       end
     end
 
     it "should return PGRange value as is if they have the same subtype" do
-      @db.typecast_value(:int4range, @o).should equal(@o)
+      @db.typecast_value(:int4range, @o).must_be_same_as(@o)
     end
 
     it "should return new PGRange value as is if they have a different subtype" do
-      @db.typecast_value(:int8range, @o).should_not equal(@o)
-      @db.typecast_value(:int8range, @o).should == @o2
+      @db.typecast_value(:int8range, @o).wont_be_same_as(@o)
+      @db.typecast_value(:int8range, @o).must_equal @o2
     end
 
     it "should return new PGRange value as is if they have a different subtype and value is empty" do
-      @db.typecast_value(:int8range, @eo).should == @eo2
+      @db.typecast_value(:int8range, @eo).must_equal @eo2
     end
 
     it "should return new PGRange value if given a Range" do
-      @db.typecast_value(:int4range, 1..2).should == @o
-      @db.typecast_value(:int4range, 1..2).should_not == @o2
-      @db.typecast_value(:int8range, 1..2).should == @o2
+      @db.typecast_value(:int4range, 1..2).must_equal @o
+      @db.typecast_value(:int4range, 1..2).wont_equal @o2
+      @db.typecast_value(:int8range, 1..2).must_equal @o2
     end
 
     it "should parse a string argument as the PostgreSQL output format" do
-      @db.typecast_value(:int4range, '[1,2]').should == @o
+      @db.typecast_value(:int4range, '[1,2]').must_equal @o
     end
 
     it "should raise errors for unparsable formats" do
-      proc{@db.typecast_value(:int8range, 'foo')}.should raise_error(Sequel::InvalidValue)
+      proc{@db.typecast_value(:int8range, 'foo')}.must_raise(Sequel::InvalidValue)
     end
 
     it "should raise errors for unhandled values" do
-      proc{@db.typecast_value(:int4range, 1)}.should raise_error(Sequel::InvalidValue)
+      proc{@db.typecast_value(:int4range, 1)}.must_raise(Sequel::InvalidValue)
     end
   end
 
   it "should support registering custom range types" do
     @R.register('foorange')
-    @db.typecast_value(:foorange, 1..2).should be_a_kind_of(@R)
+    @db.typecast_value(:foorange, 1..2).must_be_kind_of(@R)
     @db.fetch = [{:name=>'id', :db_type=>'foorange'}]
-    @db.schema(:items).map{|e| e[1][:type]}.should == [:foorange]
+    @db.schema(:items).map{|e| e[1][:type]}.must_equal [:foorange]
   end
 
   it "should support using a block as a custom conversion proc given as block" do
     @R.register('foo2range'){|s| (s*2).to_i}
-    @db.typecast_value(:foo2range, '[1,2]').should == (11..22)
+    @db.typecast_value(:foo2range, '[1,2]').must_be :==, (11..22)
   end
 
   it "should support using a block as a custom conversion proc given as :converter option" do
     @R.register('foo3range', :converter=>proc{|s| (s*2).to_i})
-    @db.typecast_value(:foo3range, '[1,2]').should == (11..22)
+    @db.typecast_value(:foo3range, '[1,2]').must_be :==, (11..22)
   end
 
   it "should support using an existing scaler conversion proc via the :subtype_oid option" do
     @R.register('foo4range', :subtype_oid=>16)
-    @db.typecast_value(:foo4range, '[t,f]').should == @R.new(true, false, :db_type=>'foo4range')
+    @db.typecast_value(:foo4range, '[t,f]').must_equal @R.new(true, false, :db_type=>'foo4range')
   end
 
   it "should raise an error if using :subtype_oid option with unexisting scalar conversion proc" do
-    proc{@R.register('fooirange', :subtype_oid=>0)}.should raise_error(Sequel::Error)
+    proc{@R.register('fooirange', :subtype_oid=>0)}.must_raise(Sequel::Error)
   end
 
   it "should raise an error if using :converter option and a block argument" do
-    proc{@R.register('fooirange', :converter=>proc{}){}}.should raise_error(Sequel::Error)
+    proc{@R.register('fooirange', :converter=>proc{}){}}.must_raise(Sequel::Error)
   end
 
   it "should raise an error if using :subtype_oid option and a block argument" do
-    proc{@R.register('fooirange', :subtype_oid=>16){}}.should raise_error(Sequel::Error)
+    proc{@R.register('fooirange', :subtype_oid=>16){}}.must_raise(Sequel::Error)
   end
 
   it "should support registering custom types with :oid option" do
     @R.register('foo5range', :oid=>331)
-    Sequel::Postgres::PG_TYPES[331].call('[1,3)').should be_a_kind_of(@R)
+    Sequel::Postgres::PG_TYPES[331].call('[1,3)').must_be_kind_of(@R)
   end
 
   it "should return correct results for Database#schema_type_class" do
-    @db.schema_type_class(:int4range).should == Sequel::Postgres::PGRange
-    @db.schema_type_class(:integer).should == Integer
+    @db.schema_type_class(:int4range).must_equal Sequel::Postgres::PGRange
+    @db.schema_type_class(:integer).must_equal Integer
   end
 
   describe "parser" do
@@ -177,56 +177,56 @@ describe "pg_range extension" do
     end
 
     it "should have db_type method to return the database type string" do
-      @p.db_type.should == 'int4range'
+      @p.db_type.must_equal 'int4range'
     end
 
     it "should have converter method which returns a callable used for conversion" do
-      @p.converter.call('1').should == 1
+      @p.converter.call('1').must_equal 1
     end
 
     it "should have call parse input string argument into PGRange instance" do
-      @p.call('[1,2]').should == @R.new(1, 2, :db_type=>'int4range')
+      @p.call('[1,2]').must_equal @R.new(1, 2, :db_type=>'int4range')
     end
 
     it "should handle empty ranges" do
-      @p.call('empty').should == @R.new(nil, nil, :empty=>true, :db_type=>'int4range')
+      @p.call('empty').must_equal @R.new(nil, nil, :empty=>true, :db_type=>'int4range')
     end
 
     it "should handle exclusive beginnings and endings" do
-      @p.call('(1,3]').should == @R.new(1, 3, :exclude_begin=>true, :db_type=>'int4range')
-      @p.call('[1,3)').should == @R.new(1, 3, :exclude_end=>true, :db_type=>'int4range')
-      @p.call('(1,3)').should == @R.new(1, 3, :exclude_begin=>true, :exclude_end=>true, :db_type=>'int4range')
+      @p.call('(1,3]').must_equal @R.new(1, 3, :exclude_begin=>true, :db_type=>'int4range')
+      @p.call('[1,3)').must_equal @R.new(1, 3, :exclude_end=>true, :db_type=>'int4range')
+      @p.call('(1,3)').must_equal @R.new(1, 3, :exclude_begin=>true, :exclude_end=>true, :db_type=>'int4range')
     end
 
     it "should handle unbounded beginnings and endings" do
-      @p.call('[,2]').should == @R.new(nil, 2, :db_type=>'int4range')
-      @p.call('[1,]').should == @R.new(1, nil, :db_type=>'int4range')
-      @p.call('[,]').should == @R.new(nil, nil, :db_type=>'int4range')
+      @p.call('[,2]').must_equal @R.new(nil, 2, :db_type=>'int4range')
+      @p.call('[1,]').must_equal @R.new(1, nil, :db_type=>'int4range')
+      @p.call('[,]').must_equal @R.new(nil, nil, :db_type=>'int4range')
     end
 
     it "should unescape quoted beginnings and endings" do
-      @sp.call('["\\\\ \\"","\\" \\\\"]').should == @R.new("\\ \"", "\" \\")
+      @sp.call('["\\\\ \\"","\\" \\\\"]').must_equal @R.new("\\ \"", "\" \\")
     end
 
     it "should treat empty quoted string not as unbounded" do
-      @sp.call('["","z"]').should == @R.new("", "z")
-      @sp.call('["a",""]').should == @R.new("a", "")
-      @sp.call('["",""]').should == @R.new("", "")
+      @sp.call('["","z"]').must_equal @R.new("", "z")
+      @sp.call('["a",""]').must_equal @R.new("a", "")
+      @sp.call('["",""]').must_equal @R.new("", "")
     end
   end
 
   it "should set appropriate timestamp range conversion procs when resetting conversion procs" do
     @db.reset_conversion_procs
     procs = @db.conversion_procs
-    procs[3908].call('[2011-10-20 11:12:13,2011-10-20 11:12:14]').should == (Time.local(2011, 10, 20, 11, 12, 13)..(Time.local(2011, 10, 20, 11, 12, 14)))
-    procs[3910].call('[2011-10-20 11:12:13,2011-10-20 11:12:14]').should == (Time.local(2011, 10, 20, 11, 12, 13)..(Time.local(2011, 10, 20, 11, 12, 14)))
+    procs[3908].call('[2011-10-20 11:12:13,2011-10-20 11:12:14]').must_be :==, (Time.local(2011, 10, 20, 11, 12, 13)..(Time.local(2011, 10, 20, 11, 12, 14)))
+    procs[3910].call('[2011-10-20 11:12:13,2011-10-20 11:12:14]').must_be :==, (Time.local(2011, 10, 20, 11, 12, 13)..(Time.local(2011, 10, 20, 11, 12, 14)))
   end
 
   it "should set appropriate timestamp range array conversion procs when resetting conversion procs" do
     @db.reset_conversion_procs
     procs = @db.conversion_procs
-    procs[3909].call('{"[2011-10-20 11:12:13,2011-10-20 11:12:14]"}').should == [Time.local(2011, 10, 20, 11, 12, 13)..Time.local(2011, 10, 20, 11, 12, 14)]
-    procs[3911].call('{"[2011-10-20 11:12:13,2011-10-20 11:12:14]"}').should == [Time.local(2011, 10, 20, 11, 12, 13)..Time.local(2011, 10, 20, 11, 12, 14)]
+    procs[3909].call('{"[2011-10-20 11:12:13,2011-10-20 11:12:14]"}').must_be :==, [Time.local(2011, 10, 20, 11, 12, 13)..Time.local(2011, 10, 20, 11, 12, 14)]
+    procs[3911].call('{"[2011-10-20 11:12:13,2011-10-20 11:12:14]"}').must_be :==, [Time.local(2011, 10, 20, 11, 12, 13)..Time.local(2011, 10, 20, 11, 12, 14)]
   end
 
   describe "a PGRange instance" do
@@ -237,168 +237,168 @@ describe "pg_range extension" do
     end
 
     it "should have #begin return the beginning of the range" do
-      @r1.begin.should == 1
-      @r2.begin.should == 3
-      @r3.begin.should == nil
+      @r1.begin.must_equal 1
+      @r2.begin.must_equal 3
+      @r3.begin.must_equal nil
     end
 
     it "should have #end return the end of the range" do
-      @r1.end.should == 2
-      @r2.end.should == nil
-      @r3.end.should == 4
+      @r1.end.must_equal 2
+      @r2.end.must_equal nil
+      @r3.end.must_equal 4
     end
 
     it "should have #db_type return the range's database type" do
-      @r1.db_type.should == nil
-      @r2.db_type.should == 'int4range'
-      @r3.db_type.should == 'int8range'
+      @r1.db_type.must_equal nil
+      @r2.db_type.must_equal 'int4range'
+      @r3.db_type.must_equal 'int8range'
     end
 
     it "should be able to be created by Sequel.pg_range" do
-      Sequel.pg_range(1..2).should == @r1
+      Sequel.pg_range(1..2).must_equal @r1
     end
 
     it "should have Sequel.pg_range be able to take a database type" do
-      Sequel.pg_range(1..2, :int4range).should == @R.new(1, 2, :db_type=>:int4range)
+      Sequel.pg_range(1..2, :int4range).must_equal @R.new(1, 2, :db_type=>:int4range)
     end
 
     it "should have Sequel.pg_range return a PGRange as is" do
       a = Sequel.pg_range(1..2)
-      Sequel.pg_range(a).should equal(a)
+      Sequel.pg_range(a).must_be_same_as(a)
     end
 
     it "should have Sequel.pg_range return a new PGRange if the database type differs" do
       a = Sequel.pg_range(1..2, :int4range)
       b = Sequel.pg_range(a, :int8range)
-      a.to_range.should == b.to_range
-      a.should_not equal(b)
-      a.db_type.should == :int4range
-      b.db_type.should == :int8range
+      a.to_range.must_equal b.to_range
+      a.wont_be_same_as(b)
+      a.db_type.must_equal :int4range
+      b.db_type.must_equal :int8range
     end
 
     it "should have #initialize raise if requesting an empty range with beginning or ending" do
-      proc{@R.new(1, nil, :empty=>true)}.should raise_error(Sequel::Error)
-      proc{@R.new(nil, 2, :empty=>true)}.should raise_error(Sequel::Error)
-      proc{@R.new(nil, nil, :empty=>true, :exclude_begin=>true)}.should raise_error(Sequel::Error)
-      proc{@R.new(nil, nil, :empty=>true, :exclude_end=>true)}.should raise_error(Sequel::Error)
+      proc{@R.new(1, nil, :empty=>true)}.must_raise(Sequel::Error)
+      proc{@R.new(nil, 2, :empty=>true)}.must_raise(Sequel::Error)
+      proc{@R.new(nil, nil, :empty=>true, :exclude_begin=>true)}.must_raise(Sequel::Error)
+      proc{@R.new(nil, nil, :empty=>true, :exclude_end=>true)}.must_raise(Sequel::Error)
     end
 
     it "should quack like a range" do
       if RUBY_VERSION >= '1.9'
-        @r1.cover?(1.5).should == true
-        @r1.cover?(2.5).should == false
-        @r1.first(1).should == [1]
-        @r1.last(1).should == [2]
+        @r1.cover?(1.5).must_equal true
+        @r1.cover?(2.5).must_equal false
+        @r1.first(1).must_equal [1]
+        @r1.last(1).must_equal [2]
       end
-      @r1.to_a.should == [1, 2]
-      @r1.first.should == 1
-      @r1.last.should == 2
+      @r1.to_a.must_equal [1, 2]
+      @r1.first.must_equal 1
+      @r1.last.must_equal 2
       a = []
       @r1.step{|x| a << x}
-      a.should == [1, 2]
+      a.must_equal [1, 2]
     end
 
     it "should only consider PGRanges equal if they have the same db_type" do
-      @R.new(1, 2, :db_type=>'int4range').should == @R.new(1, 2, :db_type=>'int4range')
-      @R.new(1, 2, :db_type=>'int8range').should_not == @R.new(1, 2, :db_type=>'int4range')
+      @R.new(1, 2, :db_type=>'int4range').must_equal @R.new(1, 2, :db_type=>'int4range')
+      @R.new(1, 2, :db_type=>'int8range').wont_equal @R.new(1, 2, :db_type=>'int4range')
     end
 
     it "should only consider empty PGRanges equal with other empty PGRanges" do
-      @R.new(nil, nil, :empty=>true).should == @R.new(nil, nil, :empty=>true)
-      @R.new(nil, nil, :empty=>true).should_not == @R.new(nil, nil)
-      @R.new(nil, nil).should_not == @R.new(nil, nil, :empty=>true)
+      @R.new(nil, nil, :empty=>true).must_equal @R.new(nil, nil, :empty=>true)
+      @R.new(nil, nil, :empty=>true).wont_equal @R.new(nil, nil)
+      @R.new(nil, nil).wont_equal @R.new(nil, nil, :empty=>true)
     end
 
     it "should only consider empty PGRanges equal if they have the same bounds" do
-      @R.new(1, 2).should == @R.new(1, 2)
-      @R.new(1, 2).should_not == @R.new(1, 3)
+      @R.new(1, 2).must_equal @R.new(1, 2)
+      @R.new(1, 2).wont_equal @R.new(1, 3)
     end
 
     it "should only consider empty PGRanges equal if they have the same bound exclusions" do
-      @R.new(1, 2, :exclude_begin=>true).should == @R.new(1, 2, :exclude_begin=>true)
-      @R.new(1, 2, :exclude_end=>true).should == @R.new(1, 2, :exclude_end=>true)
-      @R.new(1, 2, :exclude_begin=>true).should_not == @R.new(1, 2, :exclude_end=>true)
-      @R.new(1, 2, :exclude_end=>true).should_not == @R.new(1, 2, :exclude_begin=>true)
+      @R.new(1, 2, :exclude_begin=>true).must_equal @R.new(1, 2, :exclude_begin=>true)
+      @R.new(1, 2, :exclude_end=>true).must_equal @R.new(1, 2, :exclude_end=>true)
+      @R.new(1, 2, :exclude_begin=>true).wont_equal @R.new(1, 2, :exclude_end=>true)
+      @R.new(1, 2, :exclude_end=>true).wont_equal @R.new(1, 2, :exclude_begin=>true)
     end
 
     it "should consider PGRanges equal with a Range they represent" do
-      @R.new(1, 2).should == (1..2)
-      @R.new(1, 2, :exclude_end=>true).should == (1...2)
-      @R.new(1, 3).should_not == (1..2)
-      @R.new(1, 2, :exclude_end=>true).should_not == (1..2)
+      @R.new(1, 2).must_be :==, (1..2)
+      @R.new(1, 2, :exclude_end=>true).must_be :==, (1...2)
+      @R.new(1, 3).wont_be :==, (1..2)
+      @R.new(1, 2, :exclude_end=>true).wont_be :==, (1..2)
     end
 
     it "should not consider a PGRange equal with a Range if it can't be expressed as a range" do
-      @R.new(nil, nil).should_not == (1..2)
+      @R.new(nil, nil).wont_be :==, (1..2)
     end
 
     it "should not consider a PGRange equal to other objects" do
-      @R.new(nil, nil).should_not == 1
+      @R.new(nil, nil).wont_equal 1
     end
 
     it "should have #=== be true if given an equal PGRange" do
-      @R.new(1, 2).should === @R.new(1, 2)
-      @R.new(1, 2).should_not === @R.new(1, 3)
+      @R.new(1, 2).must_be :===, @R.new(1, 2)
+      @R.new(1, 2).wont_be :===, @R.new(1, 3)
 
     end
 
     it "should have #=== be true if it would be true for the Range represented by the PGRange" do
-      @R.new(1, 2).should === 1.5
-      @R.new(1, 2).should_not === 2.5
+      @R.new(1, 2).must_be :===, 1.5
+      @R.new(1, 2).wont_be :===, 2.5
     end
 
     it "should have #=== be false if the PGRange cannot be represented by a Range" do
-      @R.new(nil, nil).should_not === 1.5
+      @R.new(nil, nil).wont_be :===, 1.5
     end
 
     it "should have #empty? indicate whether the range is empty" do
-      @R.empty.should be_empty
-      @R.new(1, 2).should_not be_empty
+      @R.empty.must_be :empty?
+      @R.new(1, 2).wont_be :empty?
     end
 
     it "should have #exclude_begin? and #exclude_end indicate whether the beginning or ending of the range is excluded" do
-      @r1.exclude_begin?.should == false
-      @r1.exclude_end?.should == false
-      @r2.exclude_begin?.should == true
-      @r2.exclude_end?.should == false
-      @r3.exclude_begin?.should == false
-      @r3.exclude_end?.should == true
+      @r1.exclude_begin?.must_equal false
+      @r1.exclude_end?.must_equal false
+      @r2.exclude_begin?.must_equal true
+      @r2.exclude_end?.must_equal false
+      @r3.exclude_begin?.must_equal false
+      @r3.exclude_end?.must_equal true
     end
 
     it "should have #to_range raise an exception if the PGRange cannot be represented by a Range" do
-      proc{@R.new(nil, 1).to_range}.should raise_error(Sequel::Error)
-      proc{@R.new(1, nil).to_range}.should raise_error(Sequel::Error)
-      proc{@R.new(0, 1, :exclude_begin=>true).to_range}.should raise_error(Sequel::Error)
-      proc{@R.empty.to_range}.should raise_error(Sequel::Error)
+      proc{@R.new(nil, 1).to_range}.must_raise(Sequel::Error)
+      proc{@R.new(1, nil).to_range}.must_raise(Sequel::Error)
+      proc{@R.new(0, 1, :exclude_begin=>true).to_range}.must_raise(Sequel::Error)
+      proc{@R.empty.to_range}.must_raise(Sequel::Error)
     end
 
     it "should have #to_range return the represented range" do
-      @r1.to_range.should == (1..2)
+      @r1.to_range.must_be :==, (1..2)
     end
 
     it "should have #to_range cache the returned value" do
-      @r1.to_range.should equal(@r1.to_range)
+      @r1.to_range.must_be_same_as(@r1.to_range)
     end
 
     it "should have #unbounded_begin? and #unbounded_end indicate whether the beginning or ending of the range is unbounded" do
-      @r1.unbounded_begin?.should == false
-      @r1.unbounded_end?.should == false
-      @r2.unbounded_begin?.should == false
-      @r2.unbounded_end?.should == true
-      @r3.unbounded_begin?.should == true
-      @r3.unbounded_end?.should == false
+      @r1.unbounded_begin?.must_equal false
+      @r1.unbounded_end?.must_equal false
+      @r2.unbounded_begin?.must_equal false
+      @r2.unbounded_end?.must_equal true
+      @r3.unbounded_begin?.must_equal true
+      @r3.unbounded_end?.must_equal false
     end
 
     it "should have #valid_ruby_range? return true if the PGRange can be represented as a Range" do
-      @r1.valid_ruby_range?.should == true
-      @R.new(1, 2, :exclude_end=>true).valid_ruby_range?.should == true
+      @r1.valid_ruby_range?.must_equal true
+      @R.new(1, 2, :exclude_end=>true).valid_ruby_range?.must_equal true
     end
 
     it "should have #valid_ruby_range? return false if the PGRange cannot be represented as a Range" do
-      @R.new(nil, 1).valid_ruby_range?.should == false
-      @R.new(1, nil).valid_ruby_range?.should == false
-      @R.new(0, 1, :exclude_begin=>true).valid_ruby_range?.should == false
-      @R.empty.valid_ruby_range?.should == false
+      @R.new(nil, 1).valid_ruby_range?.must_equal false
+      @R.new(1, nil).valid_ruby_range?.must_equal false
+      @R.new(0, 1, :exclude_begin=>true).valid_ruby_range?.must_equal false
+      @R.empty.valid_ruby_range?.must_equal false
     end
   end
 end