sequel 4.36.0 → 5.61.0

data/spec/extensions/pg_json_ops_spec.rb

@@ -1,275 +0,0 @@
-require File.join(File.dirname(File.expand_path(__FILE__)), "spec_helper")
-
-Sequel.extension :pg_array, :pg_array_ops, :pg_json, :pg_json_ops
-
-describe "Sequel::Postgres::JSONOp" do
-  before do
-    @db = Sequel.connect('mock://postgres', :quote_identifiers=>false)
-    @j = Sequel.pg_json_op(:j)
-    @jb = Sequel.pg_jsonb_op(:j)
-    @l = proc{|o| @db.literal(o)}
-  end
-
-  it "should have #[] get the element" do
-    @l[@j[1]].must_equal "(j -> 1)"
-    @l[@j['a']].must_equal "(j -> 'a')"
-  end
-
-  it "should have #[] accept an array" do
-    @l[@j[%w'a b']].must_equal "(j #> ARRAY['a','b'])"
-    @l[@j[Sequel.pg_array(%w'a b')]].must_equal "(j #> ARRAY['a','b'])"
-    @l[@j[Sequel.pg_array(:a)]].must_equal "(j #> a)"
-  end
-
-  it "should have #[] return an object of the same class" do
-    @l[@j[1].to_recordset].must_equal "json_to_recordset((j -> 1))"
-    @l[@j[%w'a b'][2]].must_equal "((j #> ARRAY['a','b']) -> 2)"
-    @l[@jb[1].to_recordset].must_equal "jsonb_to_recordset((j -> 1))"
-    @l[@jb[%w'a b'][2]].must_equal "((j #> ARRAY['a','b']) -> 2)"
-  end
-
-  it "should have #get be an alias to #[]" do
-    @l[@j.get(1)].must_equal "(j -> 1)"
-    @l[@j.get(%w'a b')].must_equal "(j #> ARRAY['a','b'])"
-  end
-
-  it "should have #get_text get the element as text" do
-    @l[@j.get_text(1)].must_equal "(j ->> 1)"
-    @l[@j.get_text('a')].must_equal "(j ->> 'a')"
-  end
-
-  it "should have #get_text accept an array" do
-    @l[@j.get_text(%w'a b')].must_equal "(j #>> ARRAY['a','b'])"
-    @l[@j.get_text(Sequel.pg_array(%w'a b'))].must_equal "(j #>> ARRAY['a','b'])"
-    @l[@j.get_text(Sequel.pg_array(:a))].must_equal "(j #>> a)"
-  end
-
-  it "should have #get_text return an SQL::StringExpression" do
-    @l[@j.get_text(1) + 'a'].must_equal "((j ->> 1) || 'a')"
-    @l[@j.get_text(%w'a b') + 'a'].must_equal "((j #>> ARRAY['a','b']) || 'a')"
-  end
-
-  it "should have #array_length use the json_array_length function" do
-    @l[@j.array_length].must_equal "json_array_length(j)"
-    @l[@jb.array_length].must_equal "jsonb_array_length(j)"
-  end
-
-  it "should have #array_length return a numeric expression" do
-    @l[@j.array_length & 1].must_equal "(json_array_length(j) & 1)"
-    @l[@jb.array_length & 1].must_equal "(jsonb_array_length(j) & 1)"
-  end
-
-  it "should have #each use the json_each function" do
-    @l[@j.each].must_equal "json_each(j)"
-    @l[@jb.each].must_equal "jsonb_each(j)"
-  end
-
-  it "should have #each_text use the json_each_text function" do
-    @l[@j.each_text].must_equal "json_each_text(j)"
-    @l[@jb.each_text].must_equal "jsonb_each_text(j)"
-  end
-
-  it "should have #extract use the json_extract_path function" do
-    @l[@j.extract('a')].must_equal "json_extract_path(j, 'a')"
-    @l[@j.extract('a', 'b')].must_equal "json_extract_path(j, 'a', 'b')"
-    @l[@jb.extract('a')].must_equal "jsonb_extract_path(j, 'a')"
-    @l[@jb.extract('a', 'b')].must_equal "jsonb_extract_path(j, 'a', 'b')"
-  end
-
-  it "should have #extract return a JSONOp" do
-    @l[@j.extract('a')[1]].must_equal "(json_extract_path(j, 'a') -> 1)"
-    @l[@jb.extract('a')[1]].must_equal "(jsonb_extract_path(j, 'a') -> 1)"
-  end
-
-  it "should have #extract_text use the json_extract_path_text function" do
-    @l[@j.extract_text('a')].must_equal "json_extract_path_text(j, 'a')"
-    @l[@j.extract_text('a', 'b')].must_equal "json_extract_path_text(j, 'a', 'b')"
-    @l[@jb.extract_text('a')].must_equal "jsonb_extract_path_text(j, 'a')"
-    @l[@jb.extract_text('a', 'b')].must_equal "jsonb_extract_path_text(j, 'a', 'b')"
-  end
-
-  it "should have #extract_text return an SQL::StringExpression" do
-    @l[@j.extract_text('a') + 'a'].must_equal "(json_extract_path_text(j, 'a') || 'a')"
-    @l[@jb.extract_text('a') + 'a'].must_equal "(jsonb_extract_path_text(j, 'a') || 'a')"
-  end
-
-  it "should have #keys use the json_object_keys function" do
-    @l[@j.keys].must_equal "json_object_keys(j)"
-    @l[@jb.keys].must_equal "jsonb_object_keys(j)"
-  end
-
-  it "should have #array_elements use the json_array_elements function" do
-    @l[@j.array_elements].must_equal "json_array_elements(j)"
-    @l[@jb.array_elements].must_equal "jsonb_array_elements(j)"
-  end
-
-  it "should have #array_elements use the json_array_elements_text function" do
-    @l[@j.array_elements_text].must_equal "json_array_elements_text(j)"
-    @l[@jb.array_elements_text].must_equal "jsonb_array_elements_text(j)"
-  end
-
-  it "should have #strip_nulls use the json_strip_nulls function" do
-    @l[@j.strip_nulls].must_equal "json_strip_nulls(j)"
-    @l[@jb.strip_nulls].must_equal "jsonb_strip_nulls(j)"
-  end
-
-  it "should have #typeof use the json_typeof function" do
-    @l[@j.typeof].must_equal "json_typeof(j)"
-    @l[@jb.typeof].must_equal "jsonb_typeof(j)"
-  end
-
-  it "should have #to_record use the json_to_record function" do
-    @l[@j.to_record].must_equal "json_to_record(j)"
-    @l[@jb.to_record].must_equal "jsonb_to_record(j)"
-  end
-
-  it "should have #to_recordset use the json_to_recordsetfunction" do
-    @l[@j.to_recordset].must_equal "json_to_recordset(j)"
-    @l[@jb.to_recordset].must_equal "jsonb_to_recordset(j)"
-  end
-
-  it "should have #populate use the json_populate_record function" do
-    @l[@j.populate(:a)].must_equal "json_populate_record(a, j)"
-    @l[@jb.populate(:a)].must_equal "jsonb_populate_record(a, j)"
-  end
-
-  it "should have #populate_set use the json_populate_record function" do
-    @l[@j.populate_set(:a)].must_equal "json_populate_recordset(a, j)"
-    @l[@jb.populate_set(:a)].must_equal "jsonb_populate_recordset(a, j)"
-  end
-
-  it "#contain_all should use the ?& operator" do
-    @l[@jb.contain_all(:h1)].must_equal "(j ?& h1)"
-  end
-
-  it "#contain_all handle arrays" do
-    @l[@jb.contain_all(%w'h1')].must_equal "(j ?& ARRAY['h1'])"
-  end
-
-  it "#contain_any should use the ?| operator" do
-    @l[@jb.contain_any(:h1)].must_equal "(j ?| h1)"
-  end
-
-  it "#contain_any should handle arrays" do
-    @l[@jb.contain_any(%w'h1')].must_equal "(j ?| ARRAY['h1'])"
-  end
-
-  it "#contains should use the @> operator" do
-    @l[@jb.contains(:h1)].must_equal "(j @> h1)"
-  end
-
-  it "#contains should handle hashes" do
-    @l[@jb.contains('a'=>'b')].must_equal "(j @> '{\"a\":\"b\"}'::jsonb)"
-  end
-
-  it "#contains should handle arrays" do
-    @l[@jb.contains([1, 2])].must_equal "(j @> '[1,2]'::jsonb)"
-  end
-
-  it "#contained_by should use the <@ operator" do
-    @l[@jb.contained_by(:h1)].must_equal "(j <@ h1)"
-  end
-
-  it "#contained_by should handle hashes" do
-    @l[@jb.contained_by('a'=>'b')].must_equal "(j <@ '{\"a\":\"b\"}'::jsonb)"
-  end
-
-  it "#contained_by should handle arrays" do
-    @l[@jb.contained_by([1, 2])].must_equal "(j <@ '[1,2]'::jsonb)"
-  end
-
-  it "#concat should use the || operator" do
-    @l[@jb.concat(:h1)].must_equal "(j || h1)"
-  end
-
-  it "#concat should handle hashes" do
-    @l[@jb.concat('a'=>'b')].must_equal "(j || '{\"a\":\"b\"}'::jsonb)"
-  end
-
-  it "#concat should handle arrays" do
-    @l[@jb.concat([1, 2])].must_equal "(j || '[1,2]'::jsonb)"
-  end
-
-  it "#set should use the jsonb_set function" do
-    @l[@jb.set(:a, :h)].must_equal "jsonb_set(j, a, h, true)"
-    @l[@jb.set(:a, :h, false)].must_equal "jsonb_set(j, a, h, false)"
-  end
-
-  it "#set should handle hashes" do
-    @l[@jb.set(:a, 'a'=>'b')].must_equal "jsonb_set(j, a, '{\"a\":\"b\"}'::jsonb, true)"
-  end
-
-  it "#set should handle arrays" do
-    @l[@jb.set(%w'a b', [1, 2])].must_equal "jsonb_set(j, ARRAY['a','b'], '[1,2]'::jsonb, true)"
-  end
-
-  it "#pretty should use the jsonb_pretty function" do
-    @l[@jb.pretty].must_equal "jsonb_pretty(j)"
-  end
-
-  it "#- should use the - operator" do
-    @l[@jb - 1].must_equal "(j - 1)"
-  end
-
-  it "#delete_path should use the #- operator" do
-    @l[@jb.delete_path(:a)].must_equal "(j #- a)"
-  end
-
-  it "#delete_path should handle arrays" do
-    @l[@jb.delete_path(['a'])].must_equal "(j #- ARRAY['a'])"
-  end
-
-  it "#has_key? and aliases should use the ? operator" do
-    @l[@jb.has_key?('a')].must_equal "(j ? 'a')"
-    @l[@jb.include?('a')].must_equal "(j ? 'a')"
-  end
-
-  it "#pg_json should return self" do
-    @j.pg_json.must_be_same_as(@j)
-    @jb.pg_jsonb.must_be_same_as(@jb)
-  end
-
-  it "Sequel.pg_json_op should return arg for JSONOp" do
-    Sequel.pg_json_op(@j).must_be_same_as(@j)
-    Sequel.pg_jsonb_op(@jb).must_be_same_as(@jb)
-  end
-
-  it "should be able to turn expressions into json ops using pg_json" do
-    @db.literal(Sequel.qualify(:b, :a).pg_json[1]).must_equal "(b.a -> 1)"
-    @db.literal(Sequel.function(:a, :b).pg_json[1]).must_equal "(a(b) -> 1)"
-    @db.literal(Sequel.qualify(:b, :a).pg_jsonb[1]).must_equal "(b.a -> 1)"
-    @db.literal(Sequel.function(:a, :b).pg_jsonb[1]).must_equal "(a(b) -> 1)"
-  end
-
-  it "should be able to turn literal strings into json ops using pg_json" do
-    @db.literal(Sequel.lit('a').pg_json[1]).must_equal "(a -> 1)"
-    @db.literal(Sequel.lit('a').pg_jsonb[1]).must_equal "(a -> 1)"
-  end
-
-  it "should be able to turn symbols into json ops using Sequel.pg_json_op" do
-    @db.literal(Sequel.pg_json_op(:a)[1]).must_equal "(a -> 1)"
-    @db.literal(Sequel.pg_jsonb_op(:a)[1]).must_equal "(a -> 1)"
-  end
-
-  it "should be able to turn symbols into json ops using Sequel.pg_json" do
-    @db.literal(Sequel.pg_json(:a)[1]).must_equal "(a -> 1)"
-    @db.literal(Sequel.pg_jsonb(:a)[1]).must_equal "(a -> 1)"
-    @db.literal(Sequel.pg_jsonb(:a).contains('a'=>1)).must_equal "(a @> '{\"a\":1}'::jsonb)"
-  end
-
-  it "should allow transforming JSONArray instances into ArrayOp instances" do
-    @db.literal(Sequel.pg_json([1,2]).op[1]).must_equal "('[1,2]'::json -> 1)"
-  end
-
-  it "should allow transforming JSONHash instances into ArrayOp instances" do
-    @db.literal(Sequel.pg_json('a'=>1).op['a']).must_equal "('{\"a\":1}'::json -> 'a')"
-  end
-
-  it "should allow transforming JSONBArray instances into ArrayOp instances" do
-    @db.literal(Sequel.pg_jsonb([1,2]).op[1]).must_equal "('[1,2]'::jsonb -> 1)"
-  end
-
-  it "should allow transforming JSONBHash instances into ArrayOp instances" do
-    @db.literal(Sequel.pg_jsonb('a'=>1).op['a']).must_equal "('{\"a\":1}'::jsonb -> 'a')"
-  end
-end

data/spec/extensions/pg_json_spec.rb

@@ -1,218 +0,0 @@
-require File.join(File.dirname(File.expand_path(__FILE__)), "spec_helper")
-
-Sequel.extension :pg_array, :pg_json
-
-describe "pg_json extension" do
-  before(:all) do
-    m = Sequel::Postgres
-    @m = m::JSONDatabaseMethods
-    @hc = m::JSONHash
-    @ac = m::JSONArray
-    @bhc = m::JSONBHash
-    @bac = m::JSONBArray
-  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('[]').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.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.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('')}.must_raise(Sequel::InvalidValue)
-    proc{@m.parse_json('1')}.must_raise(Sequel::InvalidValue)
-
-    begin
-      Sequel.instance_eval do
-        alias pj parse_json
-        def parse_json(v)
-          {'1'=>1, "'a'"=>'a', 'true'=>true, 'false'=>false, 'null'=>nil, 'o'=>Object.new}.fetch(v){pj(v)}
-        end
-      end
-      @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
-      end
-    end
-  end
-
-  it "should literalize JSONHash and JSONArray to strings correctly" do
-    @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([])).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).object_id.must_equal(a.object_id)
-    a = Sequel.pg_json([])
-    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.must_be_same_as(a)
-    v.class.must_equal(@hc)
-
-    a = []
-    v = Sequel.pg_json(Sequel.pg_jsonb(a))
-    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).object_id.must_equal(a.object_id)
-    a = Sequel.pg_jsonb([])
-    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.must_be_same_as(a)
-    v.class.must_equal(@bhc)
-
-    a = []
-    v = Sequel.pg_jsonb(Sequel.pg_json(a))
-    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.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)).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)).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.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).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).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]}.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]}.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).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).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).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

@@ -1,17 +0,0 @@
-require File.join(File.dirname(File.expand_path(__FILE__)), "spec_helper")
-
-describe "pg_loose_count extension" do
-  before do
-    @db = Sequel.mock(:host=>'postgres', :fetch=>{:v=>1}).extension(:pg_loose_count)
-  end
-
-  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
-
-  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

@@ -1,58 +0,0 @@
-require File.join(File.dirname(File.expand_path(__FILE__)), "spec_helper")
-
-Sequel.extension :pg_array, :pg_range, :pg_range_ops
-
-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.must_be_same_as(@h)
-  end
-
-  it "Sequel.pg_range_op should return argument if already a RangeOp" do
-    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).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).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).must_equal "lower(numrange(1,2,'[]'))"
-  end
-
-  it "should define methods for all of the PostgreSQL range operators" do
-    @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).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).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