sequel 3.21.0 → 3.41.0

data/spec/extensions/pg_hstore_ops_spec.rb

@@ -0,0 +1,140 @@
+require File.join(File.dirname(File.expand_path(__FILE__)), "spec_helper")
+
+describe "Sequel::Postgres::HStoreOp" do
+  before do
+    @ds = Sequel.connect('mock://postgres', :quote_identifiers=>false).dataset
+    @h = Sequel.hstore_op(:h)
+  end
+
+  it "#- should use the - operator" do
+    @ds.literal(@h - 'a').should == "(h - 'a')"
+  end
+
+  it "#- should return an HStoreOp" do
+    @ds.literal((@h - 'a')['a']).should == "((h - 'a') -> 'a')"
+  end
+
+  it "#[] should use the -> operator" do
+    @ds.literal(@h['a']).should == "(h -> 'a')"
+  end
+
+  it "#[] should return a string expression" do
+    @ds.literal(@h['a'] + 'b').should == "((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)"
+  end
+
+  it "#concat should return an HStoreOp" do
+    @ds.literal(@h.concat(:h1)['a']).should == "((h || h1) -> 'a')"
+  end
+
+  it "#contain_all should use the ?& operator" do
+    @ds.literal(@h.contain_all(:h1)).should == "(h ?& h1)"
+  end
+
+  it "#contain_any should use the ?| operator" do
+    @ds.literal(@h.contain_any(:h1)).should == "(h ?| h1)"
+  end
+
+  it "#contains should use the @> operator" do
+    @ds.literal(@h.contains(:h1)).should == "(h @> h1)"
+  end
+
+  it "#contained_by should use the <@ operator" do
+    @ds.literal(@h.contained_by(:h1)).should == "(h <@ h1)"
+  end
+
+  it "#defined should use the defined function" do
+    @ds.literal(@h.defined('a')).should == "defined(h, 'a')"
+  end
+
+  it "#delete should use the delete function" do
+    @ds.literal(@h.delete('a')).should == "delete(h, 'a')"
+  end
+
+  it "#delete should return an HStoreOp" do
+    @ds.literal(@h.delete('a')['a']).should == "(delete(h, 'a') -> 'a')"
+  end
+
+  it "#each should use the each function" do
+    @ds.literal(@h.each).should == "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')"
+  end
+
+  it "#hstore should return the receiver" do
+    @h.hstore.should equal(@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)"
+  end
+
+  it "#populate should use the populate_record function" do
+    @ds.literal(@h.populate(:a)).should == "populate_record(a, h)"
+  end
+
+  it "#record_set should use the #= operator" do
+    @ds.literal(@h.record_set(:a)).should == "(a #= h)"
+  end
+
+  it "#skeys should use the skeys function" do
+    @ds.literal(@h.skeys).should == "skeys(h)"
+  end
+
+  it "#slice should should use the slice function" do
+    @ds.literal(@h.slice(:a)).should == "slice(h, a)"
+  end
+
+  it "#slice should return an HStoreOp" do
+    @ds.literal(@h.slice(:a)['a']).should == "(slice(h, a) -> 'a')"
+  end
+
+  it "#svals should use the svals function" do
+    @ds.literal(@h.svals).should == "svals(h)"
+  end
+
+  it "#to_array should use the hstore_to_array function" do
+    @ds.literal(@h.to_array).should == "hstore_to_array(h)"
+  end
+
+  it "#to_matrix should use the hstore_to_matrix function" do
+    @ds.literal(@h.to_matrix).should == "hstore_to_matrix(h)"
+  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)"
+  end
+
+  it "should have Sequel.hstore_op return HStoreOp instances as-is" do
+    Sequel.hstore_op(@h).should equal(@h)
+  end
+
+  it "should have Sequel.hstore return HStoreOp instances" do
+    Sequel.hstore(:h).should == @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')"
+  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')"
+  end
+
+  it "should allow transforming HStore instances into HStoreOp instances" do
+    @ds.literal(Sequel.hstore('a'=>'b').op['a']).should == "('\"a\"=>\"b\"'::hstore -> 'a')"
+  end
+end

data/spec/extensions/pg_hstore_spec.rb

@@ -0,0 +1,200 @@
+require File.join(File.dirname(File.expand_path(__FILE__)), "spec_helper")
+
+describe "pg_hstore extension" do
+  before do
+    @db = Sequel.connect('mock://postgres', :quote_identifiers=>false)
+    @m = Sequel::Postgres
+    @c = @m::HStore
+    @db.extension :pg_hstore
+  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'=>'\ "\'=>'}
+  end
+
+  it "should cache parse results" do
+    r = @c::Parser.new('')
+    o = r.parse
+    o.should == {}
+    r.parse.should equal(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")))
+  end
+
+  it "should have Sequel.hstore method for creating HStore instances" do
+    Sequel.hstore({}).should be_a_kind_of(@c)
+  end
+
+  it "should have Sequel.hstore return HStores as-is" do
+    a = Sequel.hstore({})
+    Sequel.hstore(a).should equal(a)
+  end
+
+  it "should HStore#to_hash method for getting underlying hash" do
+    Sequel.hstore({}).to_hash.should be_a_kind_of(Hash)
+  end
+
+  it "should convert keys and values to strings on creation" do
+    Sequel.hstore(1=>2).to_hash.should == {"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.store(:'1', 3)
+    v.to_hash.should == {"1"=>"3"}
+  end
+
+  it "should not convert nil values to strings on creation" do
+    Sequel.hstore(:foo=>nil).to_hash.should == {"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}
+  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').fetch(:foo).should == 'bar'
+    Sequel.hstore('foo'=>'bar').fetch(:foo2, 2).should == 2
+    k = nil
+    Sequel.hstore('foo2'=>'bar').fetch(:foo){|key| k = key }.should == 'foo'
+    k.should == 'foo'
+    
+    Sequel.hstore('foo'=>'bar').has_key?(:foo).should be_true
+    Sequel.hstore('foo'=>'bar').has_key?(:bar).should be_false
+    Sequel.hstore('foo'=>'bar').key?(:foo).should be_true
+    Sequel.hstore('foo'=>'bar').key?(:bar).should be_false
+    Sequel.hstore('foo'=>'bar').member?(:foo).should be_true
+    Sequel.hstore('foo'=>'bar').member?(:bar).should be_false
+    Sequel.hstore('foo'=>'bar').include?(:foo).should be_true
+    Sequel.hstore('foo'=>'bar').include?(:bar).should be_false
+
+    Sequel.hstore('foo'=>'bar', '1'=>'2').values_at(:foo3, :foo, :foo2, 1).should == [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
+    end
+  end
+
+  it "should convert has_value?/value? lookups to string" do
+    Sequel.hstore('foo'=>'bar').has_value?(:bar).should be_true
+    Sequel.hstore('foo'=>'bar').has_value?(:foo).should be_false
+    Sequel.hstore('foo'=>'bar').value?(:bar).should be_true
+    Sequel.hstore('foo'=>'bar').value?(:foo).should be_false
+  end
+
+  it "should handle nil values in has_value?/value? lookups" do
+    Sequel.hstore('foo'=>'').has_value?('').should be_true
+    Sequel.hstore('foo'=>'').has_value?(nil).should be_false
+    Sequel.hstore('foo'=>nil).has_value?(nil).should be_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'
+  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
+    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'
+    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
+    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]
+    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 == {}
+  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'
+  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'}
+  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 = Sequel.hstore('foo'=>'bar')
+    v.update(:bar=>1)
+    v.should be_a_kind_of(@c)
+    v.should == {'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))
+  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]
+  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)
+  end
+
+  it "should be serializable" do 
+    v = Sequel.hstore('foo'=>'bar')
+    dump = Marshal.dump(v) 
+    Marshal.load(dump).should == v    
+  end 
+end

data/spec/extensions/pg_inet_spec.rb

@@ -0,0 +1,47 @@
+require File.join(File.dirname(File.expand_path(__FILE__)), "spec_helper")
+
+describe "pg_inet extension" do
+  ipv6_broken = (IPAddr.new('::1'); false) rescue true
+  before do
+    @db = Sequel.connect('mock://postgres', :quote_identifiers=>false)
+    @db.extension(:pg_array, :pg_inet)
+  end
+
+  it "should literalize IPAddr v4 instances to strings correctly" do
+    @db.literal(IPAddr.new('127.0.0.1')).should == "'127.0.0.1/32'"
+    @db.literal(IPAddr.new('127.0.0.0/8')).should == "'127.0.0.0/8'"
+  end
+
+  it "should literalize IPAddr v6 instances to strings correctly" do
+    @db.literal(IPAddr.new('2001:4f8:3:ba::/64')).should == "'2001:4f8:3:ba::/64'"
+    @db.literal(IPAddr.new('2001:4f8:3:ba:2e0:81ff:fe22:d1f1')).should == "'2001:4f8:3:ba:2e0:81ff:fe22:d1f1/128'"
+  end unless ipv6_broken
+
+  it "should not affect literalization of custom objects" do
+    o = Object.new
+    def o.sql_literal(ds) 'v' end
+    @db.literal(o).should == 'v'
+  end
+
+  it "should support using IPAddr as bound variables" do
+    @db.bound_variable_arg(1, nil).should == 1
+    @db.bound_variable_arg(IPAddr.new('127.0.0.1'), nil).should == '127.0.0.1/32'
+  end
+
+  it "should support using IPAddr instances in array types in bound variables" do
+    @db.bound_variable_arg(Sequel.pg_array([IPAddr.new('127.0.0.1')]), nil).should == '{"127.0.0.1/32"}'
+  end
+
+  it "should parse inet/cidr type from the schema correctly" do
+    @db.fetch = [{:name=>'id', :db_type=>'integer'}, {:name=>'i', :db_type=>'inet'}, {:name=>'c', :db_type=>'cidr'}]
+    @db.schema(:items).map{|e| e[1][:type]}.should == [:integer, :ipaddr, :ipaddr]
+  end
+
+  it "should support typecasting for the ipaddr type" do
+    ip = IPAddr.new('127.0.0.1')
+    @db.typecast_value(:ipaddr, ip).should equal(ip)
+    @db.typecast_value(:ipaddr, ip.to_s).should == ip
+    proc{@db.typecast_value(:ipaddr, '')}.should raise_error(Sequel::InvalidValue)
+    proc{@db.typecast_value(:ipaddr, 1)}.should raise_error(Sequel::InvalidValue)
+  end
+end

data/spec/extensions/pg_interval_spec.rb

@@ -0,0 +1,72 @@
+require File.join(File.dirname(File.expand_path(__FILE__)), "spec_helper")
+
+begin
+  require 'active_support/duration'
+rescue LoadError => e
+  skip_warn "pg_interval plugin: can't load active_support/duration (#{e.class}: #{e})"
+else
+describe "pg_interval extension" do
+  before do
+    @db = Sequel.connect('mock://postgres', :quote_identifiers=>false)
+    @db.extension(:pg_array, :pg_interval)
+  end
+
+  it "should literalize ActiveSupport::Duration instances to strings correctly" do
+    @db.literal(ActiveSupport::Duration.new(0, [])).should == "'0'::interval"
+    @db.literal(ActiveSupport::Duration.new(0, [[:seconds, 0]])).should == "'0'::interval"
+    @db.literal(ActiveSupport::Duration.new(0, [[:seconds, 10], [:minutes, 20], [:days, 3], [:months, 4], [:years, 6]])).should == "'6 years 4 months 3 days 20 minutes 10 seconds '::interval"
+    @db.literal(ActiveSupport::Duration.new(0, [[:seconds, -10.000001], [:minutes, -20], [:days, -3], [:months, -4], [:years, -6]])).should == "'-6 years -4 months -3 days -20 minutes -10.000001 seconds '::interval"
+  end
+
+  it "should literalize ActiveSupport::Duration instances with repeated parts correctly" do
+    @db.literal(ActiveSupport::Duration.new(0, [[:seconds, 2], [:seconds, 1]])).should == "'3 seconds '::interval"
+    @db.literal(ActiveSupport::Duration.new(0, [[:seconds, 2], [:seconds, 1], [:days, 1], [:days, 4]])).should == "'5 days 3 seconds '::interval"
+  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'
+  end
+
+  it "should support using ActiveSupport::Duration instances as bound variables" do
+    @db.bound_variable_arg(1, nil).should == 1
+    @db.bound_variable_arg(ActiveSupport::Duration.new(0, [[:seconds, 0]]), nil).should == '0'
+    @db.bound_variable_arg(ActiveSupport::Duration.new(0, [[:seconds, -10.000001], [:minutes, -20], [:days, -3], [:months, -4], [:years, -6]]), nil).should == '-6 years -4 months -3 days -20 minutes -10.000001 seconds '
+  end
+
+  it "should support using ActiveSupport::Duration instances in array types in bound variables" do
+    @db.bound_variable_arg(Sequel.pg_array([ActiveSupport::Duration.new(0, [[:seconds, 0]])]), nil).should == '{"0"}'
+    @db.bound_variable_arg(Sequel.pg_array([ActiveSupport::Duration.new(0, [[:seconds, -10.000001], [:minutes, -20], [:days, -3], [:months, -4], [:years, -6]])]), nil).should == '{"-6 years -4 months -3 days -20 minutes -10.000001 seconds "}'
+  end
+
+  it "should parse interval type from the schema correctly" do
+    @db.fetch = [{:name=>'id', :db_type=>'integer'}, {:name=>'i', :db_type=>'interval'}]
+    @db.schema(:items).map{|e| e[1][:type]}.should == [:integer, :interval]
+  end
+
+  it "should support typecasting for the interval type" do
+    ip = IPAddr.new('127.0.0.1')
+    d = ActiveSupport::Duration.new(31557600 + 2*86400*30 + 3*86400*7 + 4*86400 + 5*3600 + 6*60 + 7, [[:years, 1], [:months, 2], [:days, 25], [:seconds, 18367]])
+    @db.typecast_value(:interval, d).object_id.should == d.object_id
+
+    @db.typecast_value(:interval, "1 year 2 mons 25 days 05:06:07").is_a?(ActiveSupport::Duration).should be_true
+    @db.typecast_value(:interval, "1 year 2 mons 25 days 05:06:07").should == d
+    @db.typecast_value(:interval, "1 year 2 mons 25 days 05:06:07").parts.sort_by{|k,v| k.to_s}.should == d.parts.sort_by{|k,v| k.to_s}
+    @db.typecast_value(:interval, "1 year 2 mons 25 days 05:06:07.0").parts.sort_by{|k,v| k.to_s}.should == d.parts.sort_by{|k,v| k.to_s}
+
+    @db.typecast_value(:interval, "1 year 2 mons 25 days 5 hours 6 mins 7 secs").is_a?(ActiveSupport::Duration).should be_true
+    @db.typecast_value(:interval, "1 year 2 mons 25 days 5 hours 6 mins 7 secs").should == d
+    @db.typecast_value(:interval, "1 year 2 mons 25 days 5 hours 6 mins 7 secs").parts.sort_by{|k,v| k.to_s}.should == d.parts.sort_by{|k,v| k.to_s}
+    @db.typecast_value(:interval, "1 year 2 mons 25 days 5 hours 6 mins 7.0 secs").parts.sort_by{|k,v| k.to_s}.should == d.parts.sort_by{|k,v| k.to_s}
+
+    d2 = ActiveSupport::Duration.new(1, [[:seconds, 1]])
+    @db.typecast_value(:interval, 1).is_a?(ActiveSupport::Duration).should be_true
+    @db.typecast_value(:interval, 1).should == d2
+    @db.typecast_value(:interval, 1).parts.sort_by{|k,v| k.to_s}.should == d2.parts.sort_by{|k,v| k.to_s}
+
+    proc{@db.typecast_value(:interval, 'foo')}.should raise_error(Sequel::InvalidValue)
+    proc{@db.typecast_value(:interval, Object.new)}.should raise_error(Sequel::InvalidValue)
+  end
+end
+end

data/spec/extensions/pg_json_spec.rb

@@ -0,0 +1,99 @@
+require File.join(File.dirname(File.expand_path(__FILE__)), "spec_helper")
+
+describe "pg_json extension" do
+  before(:all) do
+    m = Sequel::Postgres
+    @m = m::JSONDatabaseMethods
+    @hc = m::JSONHash
+    @ac = m::JSONArray
+
+    # Create subclass in correct namespace for easily overriding methods
+    j = m::JSON = JSON.dup
+    j.instance_eval do
+      Parser = JSON::Parser
+      alias old_parse parse
+      def parse(s)
+        return 1 if s == '1'
+        old_parse(s) 
+      end
+    end
+  end
+  before do
+    @db = Sequel.connect('mock://postgres', :quote_identifiers=>false)
+    @db.extension(:pg_array, :pg_json)
+  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'}}
+  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)
+  end
+
+  it "should literalize HStores 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"
+  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)
+    a = Sequel.pg_json([])
+    Sequel.pg_json(a).should equal(a)
+  end
+
+  it "should have Sequel.pg_json raise an Error if called with a non-hash or array" do
+    proc{Sequel.pg_json(:a)}.should raise_error(Sequel::Error)
+  end
+
+  it "should have JSONHash#to_hash method for getting underlying hash" do
+    Sequel.pg_json({}).to_hash.should be_a_kind_of(Hash)
+  end
+
+  it "should have JSONArray#to_a method for getting underlying array" do
+    Sequel.pg_json([]).to_a.should be_a_kind_of(Array)
+  end
+
+  it "should support using JSONHash and JSONArray 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"}'
+  end
+
+  it "should support using json[] 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]}"}'
+  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]
+  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, 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, '[]').should == Sequel.pg_json([])
+    @db.typecast_value(:json, '{"a": "b"}').should == Sequel.pg_json("a"=>"b")
+    proc{@db.typecast_value(:json, '')}.should raise_error(Sequel::InvalidValue)
+    proc{@db.typecast_value(:json, 1)}.should raise_error(Sequel::InvalidValue)
+  end
+end

data/spec/extensions/pg_range_ops_spec.rb

@@ -0,0 +1,56 @@
+require File.join(File.dirname(File.expand_path(__FILE__)), "spec_helper")
+
+describe "Sequel::Postgres::RangeOp" do
+  before do
+    @ds = Sequel.connect('mock://postgres', :quote_identifiers=>false).dataset
+    @h = Sequel.pg_range_op(:h)
+  end
+
+  it "#pg_range should return self" do
+    @h.pg_range.should equal(@h)
+  end
+
+  it "Sequel.pg_range_op should return argument if already a RangeOp" do
+    Sequel.pg_range_op(@h).should equal(@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)"
+  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)"
+  end
+
+  it "PGRange#op should return a RangeOp" do
+    @ds.literal(Sequel.pg_range(1..2, :numrange).op.lower).should == "lower('[1,2]'::numrange)"
+  end
+
+  it "should define methods for all of the 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.starts_before(@h)).should == "(h &< h)"
+    @ds.literal(@h.ends_after(@h)).should == "(h &> h)"
+    @ds.literal(@h.adjacent_to(@h)).should == "(h -|- h)"
+  end
+
+  it "should define methods for all of the 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)"
+  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))"
+  end
+end