sequel 5.28.0 → 5.33.0

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

data/spec/extensions/pg_json_ops_spec.rb

@@ -1,356 +0,0 @@
-require_relative "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')
-    @db.extend_datasets{def quote_identifiers?; false end}
-    @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 "#insert should use the jsonb_insert function" do
-    @l[@jb.insert(:a, :h)].must_equal "jsonb_insert(j, a, h, false)"
-    @l[@jb.insert(:a, :h, true)].must_equal "jsonb_insert(j, a, h, true)"
-  end
-
-  it "#insert should handle hashes" do
-    @l[@jb.insert(:a, 'a'=>'b')].must_equal "jsonb_insert(j, a, '{\"a\":\"b\"}'::jsonb, false)"
-  end
-
-  it "#insert should handle arrays" do
-    @l[@jb.insert(%w'a b', [1, 2])].must_equal "jsonb_insert(j, ARRAY['a','b'], '[1,2]'::jsonb, false)"
-  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
-
-  it "#path_exists should use the @? operator" do
-    @l[@jb.path_exists('$')].must_equal "(j @? '$')"
-  end
-
-  it "#path_exists result should be a boolean expression" do
-    @jb.path_exists('$').must_be_kind_of Sequel::SQL::BooleanExpression
-  end
-
-  it "#path_match should use the @@ operator" do
-    @l[@jb.path_match('$')].must_equal "(j @@ '$')"
-  end
-
-  it "#path_match result should be a boolean expression" do
-    @jb.path_match('$').must_be_kind_of Sequel::SQL::BooleanExpression
-  end
-
-  it "#path_exists! should use the jsonb_path_exists function" do
-    @l[@jb.path_exists!('$')].must_equal "jsonb_path_exists(j, '$')"
-    @l[@jb.path_exists!('$', '{"x":2}')].must_equal "jsonb_path_exists(j, '$', '{\"x\":2}')"
-    @l[@jb.path_exists!('$', x: 2)].must_equal "jsonb_path_exists(j, '$', '{\"x\":2}')"
-    @l[@jb.path_exists!('$', {x: 2}, true)].must_equal "jsonb_path_exists(j, '$', '{\"x\":2}', true)"
-  end
-
-  it "#path_exists! result should be a boolean expression" do
-    @jb.path_exists!('$').must_be_kind_of Sequel::SQL::BooleanExpression
-  end
-
-  it "#path_match! should use the jsonb_path_match function" do
-    @l[@jb.path_match!('$')].must_equal "jsonb_path_match(j, '$')"
-    @l[@jb.path_match!('$', '{"x":2}')].must_equal "jsonb_path_match(j, '$', '{\"x\":2}')"
-    @l[@jb.path_match!('$', x: 2)].must_equal "jsonb_path_match(j, '$', '{\"x\":2}')"
-    @l[@jb.path_match!('$', {x: 2}, true)].must_equal "jsonb_path_match(j, '$', '{\"x\":2}', true)"
-  end
-
-  it "#path_match! result should be a boolean expression" do
-    @jb.path_match!('$').must_be_kind_of Sequel::SQL::BooleanExpression
-  end
-
-  it "#path_query should use the jsonb_path_query function" do
-    @l[@jb.path_query('$')].must_equal "jsonb_path_query(j, '$')"
-    @l[@jb.path_query('$', '{"x":2}')].must_equal "jsonb_path_query(j, '$', '{\"x\":2}')"
-    @l[@jb.path_query('$', x: 2)].must_equal "jsonb_path_query(j, '$', '{\"x\":2}')"
-    @l[@jb.path_query('$', {x: 2}, true)].must_equal "jsonb_path_query(j, '$', '{\"x\":2}', true)"
-  end
-
-  it "#path_query_array should use the jsonb_path_query_array function" do
-    @l[@jb.path_query_array('$')].must_equal "jsonb_path_query_array(j, '$')"
-    @l[@jb.path_query_array('$', '{"x":2}')].must_equal "jsonb_path_query_array(j, '$', '{\"x\":2}')"
-    @l[@jb.path_query_array('$', x: 2)].must_equal "jsonb_path_query_array(j, '$', '{\"x\":2}')"
-    @l[@jb.path_query_array('$', {x: 2}, true)].must_equal "jsonb_path_query_array(j, '$', '{\"x\":2}', true)"
-  end
-
-  it "#path_query_array result should be a JSONBOp" do
-    @l[@jb.path_query_array('$').path_query_array('$')].must_equal "jsonb_path_query_array(jsonb_path_query_array(j, '$'), '$')"
-  end
-
-  it "#path_query_first should use the jsonb_path_query_first function" do
-    @l[@jb.path_query_first('$')].must_equal "jsonb_path_query_first(j, '$')"
-    @l[@jb.path_query_first('$', '{"x":2}')].must_equal "jsonb_path_query_first(j, '$', '{\"x\":2}')"
-    @l[@jb.path_query_first('$', x: 2)].must_equal "jsonb_path_query_first(j, '$', '{\"x\":2}')"
-    @l[@jb.path_query_first('$', {x: 2}, true)].must_equal "jsonb_path_query_first(j, '$', '{\"x\":2}', true)"
-  end
-
-  it "#path_query_first result should be a JSONBOp" do
-    @l[@jb.path_query_first('$').path_query_first('$')].must_equal "jsonb_path_query_first(jsonb_path_query_first(j, '$'), '$')"
-  end
-end