sequel 5.8.0 → 5.38.0

data/spec/extensions/pg_hstore_spec.rb

@@ -1,219 +0,0 @@
-require_relative "spec_helper"
-
-describe "pg_hstore extension" do
-  before do
-    Sequel.extension :pg_array, :pg_hstore
-    @db = Sequel.connect('mock://postgres')
-    @db.extend_datasets{def quote_identifiers?; false end}
-    @m = Sequel::Postgres
-    @c = @m::HStore
-    @db.fetch = {:oid=>9999, :typname=>'hstore'}
-    @db.extension :pg_hstore
-  end
-
-  it "should parse hstore strings correctly" do
-    @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.must_equal({})
-    r.parse.must_be_same_as(o)
-  end
-
-  it "should literalize HStores to strings correctly" do
-    @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'
-    @db.literal(Sequel.hstore("a"=>"b","c"=>"d")).must_equal '\'"a"=>"b","c"=>"d"\'::hstore'
-  end
-
-  it "should register conversion proc correctly" do
-    @db.conversion_procs[9999].call('"a"=>"b"').must_equal('a'=>'b')
-  end
-
-  it "should have Sequel.hstore method for creating HStore instances" do
-    Sequel.hstore({}).class.must_equal(@c)
-  end
-
-  it "should have Sequel.hstore return HStores as-is" do
-    a = Sequel.hstore({})
-    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.must_be_kind_of(Hash)
-  end
-
-  it "should convert keys and values to strings on creation" do
-    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.must_equal("1"=>"2")
-    v.store(:'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.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.must_equal("foo"=>nil)
-  end
-
-  it "should convert lookups by key to string" do
-    Sequel.hstore('foo'=>'bar')[:foo].must_equal 'bar'
-    Sequel.hstore('1'=>'bar')[1].must_equal 'bar'
-
-    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 }.must_equal 'foo'
-    k.must_equal 'foo'
-    
-    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).must_equal [nil, 'bar', nil, '2']
-
-    Sequel.hstore('foo'=>'bar').assoc(:foo).must_equal ['foo', 'bar']
-    Sequel.hstore('foo'=>'bar').assoc(:foo2).must_be_nil
-  end
-
-  it "should convert has_value?/value? lookups to string" do
-    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?('').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].must_equal 'bar'
-    Sequel.hstore('1'=>'bar').to_hash[1].must_equal 'bar'
-  end
-
-  it "should convert key lookups to string" do
-    Sequel.hstore('foo'=>'bar').key(:bar).must_equal 'foo'
-    Sequel.hstore('foo'=>'bar').key(:bar2).must_be_nil
-  end
-
-  it "should handle nil values in key lookups" do
-    Sequel.hstore('foo'=>'').key('').must_equal 'foo'
-    Sequel.hstore('foo'=>'').key(nil).must_be_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).must_equal ['foo', 'bar']
-    Sequel.hstore('foo'=>'bar').rassoc(:bar2).must_be_nil
-  end
-
-  it "should handle nil values in rassoc lookups" do
-    Sequel.hstore('foo'=>'').rassoc('').must_equal ['foo', '']
-    Sequel.hstore('foo'=>'').rassoc(nil).must_be_nil
-    Sequel.hstore('foo'=>nil).rassoc(nil).must_equal ['foo', nil]
-  end
-
-  it "should have delete convert key to string" do
-    v = Sequel.hstore('foo'=>'bar')
-    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.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.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.class.must_equal(@c)
-    v.must_equal('foo'=>'bar', 'bar'=>'1')
-
-    v = Sequel.hstore('foo'=>'bar')
-    v.update(: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).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"=>"\'\\\\ \\"=>"'
-    @db.bound_variable_arg(Sequel.hstore("a"=>"b","c"=>"d"), nil).must_equal '"a"=>"b","c"=>"d"'
-  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]}.must_equal [:integer, :hstore]
-  end
-
-  it "should set :callable_default schema entries if default value is recognized" do
-    @db.fetch = [{:name=>'id', :db_type=>'integer', :default=>'1'}, {:name=>'t', :db_type=>'hstore', :default=>"''::hstore"}]
-    s = @db.schema(:items)
-    s[0][1][:callable_default].must_be_nil
-    v = s[1][1][:callable_default].call
-    Sequel::Postgres::HStore.===(v).must_equal true
-    @db.literal(v).must_equal "''::hstore"
-    v['a'] = 'b'
-    @db.literal(v).must_equal "'\"a\"=>\"b\"'::hstore"
-  end
-
-  it "should support typecasting for the hstore type" do
-    h = Sequel.hstore(1=>2)
-    @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).must_equal v    
-  end 
-
-  it "should return correct results for Database#schema_type_class" do
-    @db.schema_type_class(:hstore).must_equal Sequel::Postgres::HStore
-    @db.schema_type_class(:integer).must_equal Integer
-  end
-end

data/spec/extensions/pg_inet_ops_spec.rb

@@ -1,102 +0,0 @@
-require_relative "spec_helper"
-
-Sequel.extension :pg_inet_ops
-
-describe "Sequel::Postgres::InetOp" do
-  before do
-    db = Sequel.connect('mock://postgres')
-    db.extend_datasets{def quote_identifiers?; false end}
-    db.extension :pg_inet
-    @ds = db.dataset
-    @h = Sequel.pg_inet_op(:h)
-  end
-
-  it "#pg_inet should return self" do
-    @h.pg_inet.must_be_same_as(@h)
-  end
-
-  it "Sequel.pg_inet_op should return argument if already an InetOp" do
-    Sequel.pg_inet_op(@h).must_be_same_as(@h)
-  end
-
-  it "#pg_inet should return a InetOp for literal strings, and expressions" do
-    @ds.literal(Sequel.function(:b, :h).pg_inet.abbrev).must_equal "abbrev(b(h))"
-    @ds.literal(Sequel.lit('h').pg_inet.abbrev).must_equal "abbrev(h)"
-  end
-
-  it "should define methods for all of the PostgreSQL inet operators" do
-    @ds.literal(@h + @h).must_equal "(h + h)"
-    @ds.literal(@h - @h).must_equal "(h - h)"
-    @ds.literal(@h << @h).must_equal "(h << h)"
-    @ds.literal(@h >> @h).must_equal "(h >> h)"
-    @ds.literal(@h & @h).must_equal "(h & h)"
-    @ds.literal(@h | @h).must_equal "(h | h)"
-    @ds.literal(~@h).must_equal "~h"
-
-    @ds.literal(@h.contained_by(@h)).must_equal "(h << h)"
-    @ds.literal(@h.contained_by_or_equals(@h)).must_equal "(h <<= h)"
-    @ds.literal(@h.contains(@h)).must_equal "(h >> h)"
-    @ds.literal(@h.contains_or_equals(@h)).must_equal "(h >>= h)"
-    @ds.literal(@h.contains_or_contained_by(@h)).must_equal "(h && h)"
-  end
-
-  it "should define methods for all of the PostgreSQL inet functions" do
-    @ds.literal(@h.abbrev).must_equal "abbrev(h)"
-    @ds.literal(@h.broadcast).must_equal "broadcast(h)"
-    @ds.literal(@h.family).must_equal "family(h)"
-    @ds.literal(@h.host).must_equal "host(h)"
-    @ds.literal(@h.hostmask).must_equal "hostmask(h)"
-    @ds.literal(@h.masklen).must_equal "masklen(h)"
-    @ds.literal(@h.netmask).must_equal "netmask(h)"
-    @ds.literal(@h.network).must_equal "network(h)"
-    @ds.literal(@h.set_masklen(16)).must_equal "set_masklen(h, 16)"
-    @ds.literal(@h.text).must_equal "text(h)"
-  end
-
-  it "should have operators that return booleans return boolean expressions" do
-    @ds.literal((@h << @h) & :b).must_equal "((h << h) AND b)"
-    @ds.literal((@h >> @h) & :b).must_equal "((h >> h) AND b)"
-
-    @ds.literal(@h.contained_by(@h) & :b).must_equal "((h << h) AND b)"
-    @ds.literal(@h.contained_by_or_equals(@h) & :b).must_equal "((h <<= h) AND b)"
-    @ds.literal(@h.contains(@h) & :b).must_equal "((h >> h) AND b)"
-    @ds.literal(@h.contains_or_equals(@h) & :b).must_equal "((h >>= h) AND b)"
-    @ds.literal(@h.contains_or_contained_by(@h) & :b).must_equal "((h && h) AND b)"
-  end
-
-  it "should have operators that return inet return InetOp" do
-    @ds.literal((@h & @h).contains(:b)).must_equal "((h & h) >> b)"
-    @ds.literal((@h | @h).contains(:b)).must_equal "((h | h) >> b)"
-    @ds.literal((@h + @h).contains(:b)).must_equal "((h + h) >> b)"
-    @ds.literal((@h - 3).contains(:b)).must_equal "((h - 3) >> b)"
-    @ds.literal((~@h).contains(:b)).must_equal "(~h >> b)"
-  end
-
-  it "should have - operator with inet op return numeric expression" do
-    @ds.literal((@h - @h) / :b).must_equal "((h - h) / b)"
-  end
-
-  it "should have function methods returning int return numeric expressions" do
-    @ds.literal(@h.family / 2).must_equal "(family(h) / 2)"
-    @ds.literal(@h.masklen / 2).must_equal "(masklen(h) / 2)"
-  end
-
-  it "should have function methods returning text return string expressions" do
-    @ds.literal(@h.abbrev + :a).must_equal "(abbrev(h) || a)"
-    @ds.literal(@h.host + :a).must_equal "(host(h) || a)"
-    @ds.literal(@h.text + :a).must_equal "(text(h) || a)"
-  end
-
-  it "should have function methods returning inet return InetOp" do
-    @ds.literal(@h.broadcast.contains(:a)).must_equal "(broadcast(h) >> a)"
-    @ds.literal(@h.hostmask.contains(:a)).must_equal "(hostmask(h) >> a)"
-    @ds.literal(@h.netmask.contains(:a)).must_equal "(netmask(h) >> a)"
-    @ds.literal(@h.network.contains(:a)).must_equal "(network(h) >> a)"
-    @ds.literal(@h.set_masklen(16).contains(:a)).must_equal "(set_masklen(h, 16) >> a)"
-  end
-
-  it "should string and IPAddr instances in a cast to inet" do
-    @ds.literal(Sequel.pg_inet_op('1.2.3.4').contains(:a)).must_equal "(CAST('1.2.3.4' AS inet) >> a)"
-    @ds.literal(Sequel.pg_inet_op(IPAddr.new('1.2.3.4')).contains(:a)).must_equal "(CAST('1.2.3.4/32' AS inet) >> a)"
-  end
-end

data/spec/extensions/pg_inet_spec.rb

@@ -1,72 +0,0 @@
-require_relative "spec_helper"
-
-describe "pg_inet extension" do
-  ipv6_broken = (IPAddr.new('::1'); false) rescue true
-  before do
-    @db = Sequel.connect('mock://postgres')
-    @db.extend_datasets{def quote_identifiers?; false end}
-    @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')).must_equal "'127.0.0.1/32'"
-    @db.literal(IPAddr.new('127.0.0.0/8')).must_equal "'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')).must_equal "'2001:4f8:3:ba::/64'"
-    @db.literal(IPAddr.new('2001:4f8:3:ba:2e0:81ff:fe22:d1f1')).must_equal "'2001:4f8:3:ba:2e0:81ff:fe22:d1f1/128'"
-  end unless ipv6_broken
-
-  it "should set up conversion procs correctly" do
-    cp = @db.conversion_procs
-    cp[869].call("127.0.0.1").must_equal IPAddr.new('127.0.0.1')
-    cp[650].call("127.0.0.1").must_equal IPAddr.new('127.0.0.1')
-  end
-
-  it "should set up conversion procs for arrays correctly" do
-    cp = @db.conversion_procs
-    cp[1041].call("{127.0.0.1}").must_equal [IPAddr.new('127.0.0.1')]
-    cp[651].call("{127.0.0.1}").must_equal [IPAddr.new('127.0.0.1')]
-    cp[1040].call("{127.0.0.1}").must_equal ['127.0.0.1']
-  end
-
-  it "should not affect literalization of custom objects" do
-    o = Object.new
-    def o.sql_literal(ds) 'v' end
-    @db.literal(o).must_equal 'v'
-  end
-
-  it "should support using IPAddr as bound variables" do
-    @db.bound_variable_arg(1, nil).must_equal 1
-    @db.bound_variable_arg(IPAddr.new('127.0.0.1'), nil).must_equal '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).must_equal '{"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]}.must_equal [:integer, :ipaddr, :ipaddr]
-  end
-
-  it "should set :ruby_default schema entries if default value is recognized" do
-    @db.fetch = [{:name=>'id', :db_type=>'integer', :default=>'1'}, {:name=>'t', :db_type=>'inet', :default=>"'127.0.0.1'::inet"}]
-    s = @db.schema(:items)
-    s[1][1][:ruby_default].must_equal IPAddr.new('127.0.0.1')
-  end
-
-  it "should support typecasting for the ipaddr type" do
-    ip = IPAddr.new('127.0.0.1')
-    @db.typecast_value(:ipaddr, ip).must_be_same_as(ip)
-    @db.typecast_value(:ipaddr, ip.to_s).must_equal ip
-    proc{@db.typecast_value(:ipaddr, '')}.must_raise(Sequel::InvalidValue)
-    proc{@db.typecast_value(:ipaddr, 1)}.must_raise(Sequel::InvalidValue)
-  end
-
-  it "should return correct results for Database#schema_type_class" do
-    @db.schema_type_class(:ipaddr).must_equal IPAddr
-    @db.schema_type_class(:integer).must_equal Integer
-  end
-end

data/spec/extensions/pg_interval_spec.rb

@@ -1,103 +0,0 @@
-require_relative "spec_helper"
-
-begin
-  require 'active_support/duration'
-  begin
-    require 'active_support/gem_version'
-  rescue LoadError
-  end
-rescue LoadError
-  warn "Skipping test of pg_interval plugin: can't load active_support/duration"
-else
-describe "pg_interval extension" do
-  before do
-    @db = Sequel.connect('mock://postgres')
-    @db.extend_datasets{def quote_identifiers?; false end}
-    @db.extension(:pg_array, :pg_interval)
-  end
-
-  it "should literalize ActiveSupport::Duration instances to strings correctly" do
-    @db.literal(ActiveSupport::Duration.new(0, [])).must_equal "'0'::interval"
-    @db.literal(ActiveSupport::Duration.new(0, [[:seconds, 0]])).must_equal "'0'::interval"
-    @db.literal(ActiveSupport::Duration.new(0, [[:seconds, 10], [:minutes, 20], [:days, 3], [:months, 4], [:years, 6]])).must_equal "'6 years 4 months 3 days 20 minutes 10 seconds '::interval"
-    @db.literal(ActiveSupport::Duration.new(0, [[:seconds, 10], [:minutes, 20], [:hours, 8], [:days, 3], [:weeks, 2], [:months, 4], [:years, 6]])).must_equal "'6 years 4 months 2 weeks 3 days 8 hours 20 minutes 10 seconds '::interval"
-    @db.literal(ActiveSupport::Duration.new(0, [[:seconds, -10.000001], [:minutes, -20], [:days, -3], [:months, -4], [:years, -6]])).must_equal "'-6 years -4 months -3 days -20 minutes -10.000001 seconds '::interval"
-  end
-
-  it "should literalize ActiveSupport::Duration instances with repeated parts correctly" do
-    if defined?(ActiveSupport::VERSION::STRING) && ActiveSupport::VERSION::STRING >= '5.1'
-      @db.literal(ActiveSupport::Duration.new(0, [[:seconds, 2], [:seconds, 1]])).must_equal "'1 seconds '::interval"
-      @db.literal(ActiveSupport::Duration.new(0, [[:seconds, 2], [:seconds, 1], [:days, 1], [:days, 4]])).must_equal "'4 days 1 seconds '::interval"
-    else
-      @db.literal(ActiveSupport::Duration.new(0, [[:seconds, 2], [:seconds, 1]])).must_equal "'3 seconds '::interval"
-      @db.literal(ActiveSupport::Duration.new(0, [[:seconds, 2], [:seconds, 1], [:days, 1], [:days, 4]])).must_equal "'5 days 3 seconds '::interval"
-    end
-  end
-
-  it "should set up conversion procs correctly" do
-    cp = @db.conversion_procs
-    cp[1186].call("1 sec").must_equal ActiveSupport::Duration.new(1, [[:seconds, 1]])
-  end
-
-  it "should set up conversion procs for arrays correctly" do
-    cp = @db.conversion_procs
-    cp[1187].call("{1 sec}").must_equal [ActiveSupport::Duration.new(1, [[:seconds, 1]])]
-  end
-
-  it "should not affect literalization of custom objects" do
-    o = Object.new
-    def o.sql_literal(ds) 'v' end
-    @db.literal(o).must_equal 'v'
-  end
-
-  it "should support using ActiveSupport::Duration instances as bound variables" do
-    @db.bound_variable_arg(1, nil).must_equal 1
-    @db.bound_variable_arg(ActiveSupport::Duration.new(0, [[:seconds, 0]]), nil).must_equal '0'
-    @db.bound_variable_arg(ActiveSupport::Duration.new(0, [[:seconds, -10.000001], [:minutes, -20], [:days, -3], [:months, -4], [:years, -6]]), nil).must_equal '-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).must_equal '{"0"}'
-    @db.bound_variable_arg(Sequel.pg_array([ActiveSupport::Duration.new(0, [[:seconds, -10.000001], [:minutes, -20], [:days, -3], [:months, -4], [:years, -6]])]), nil).must_equal '{"-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]}.must_equal [:integer, :interval]
-  end
-
-  it "should set :ruby_default schema entries if default value is recognized" do
-    @db.fetch = [{:name=>'id', :db_type=>'integer', :default=>'1'}, {:name=>'t', :db_type=>'interval', :default=>"'3 days'::interval"}]
-    s = @db.schema(:items)
-    s[1][1][:ruby_default].must_equal ActiveSupport::Duration.new(3*86400, :days=>3)
-  end
-
-  it "should support typecasting for the interval type" do
-    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.must_equal d.object_id
-
-    @db.typecast_value(:interval, "1 year 2 mons 25 days 05:06:07").is_a?(ActiveSupport::Duration).must_equal true
-    @db.typecast_value(:interval, "1 year 2 mons 25 days 05:06:07").must_equal d
-    @db.typecast_value(:interval, "1 year 2 mons 25 days 05:06:07").parts.sort_by{|k,v| k.to_s}.must_equal 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}.must_equal 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).must_equal true
-    @db.typecast_value(:interval, "1 year 2 mons 25 days 5 hours 6 mins 7 secs").must_equal 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}.must_equal 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}.must_equal 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).must_equal true
-    @db.typecast_value(:interval, 1).must_equal d2
-    @db.typecast_value(:interval, 1).parts.sort_by{|k,v| k.to_s}.must_equal d2.parts.sort_by{|k,v| k.to_s}
-
-    proc{@db.typecast_value(:interval, 'foo')}.must_raise(Sequel::InvalidValue)
-    proc{@db.typecast_value(:interval, Object.new)}.must_raise(Sequel::InvalidValue)
-  end
-
-  it "should return correct results for Database#schema_type_class" do
-    @db.schema_type_class(:interval).must_equal ActiveSupport::Duration
-    @db.schema_type_class(:integer).must_equal Integer
-  end
-end
-end