sequel 5.20.0 → 5.49.0

data/spec/extensions/pg_auto_constraint_validations_spec.rb

@@ -1,172 +0,0 @@
-require_relative "spec_helper"
-
-describe "pg_auto_constraint_validations plugin" do
-  def create_model(ds)
-    @ds = ds
-    @ds.send(:columns=, [:id, :i])
-    @db.fetch = @metadata_results.dup
-    c = Sequel::Model(@ds)
-    c.plugin :pg_auto_constraint_validations
-    c
-  end
-
-  before do
-    info = @info = {:schema=>'public', :table=>'items'}
-    @db = Sequel.mock(:host=>'postgres')
-    def @db.schema(*) [[:i, {}], [:id, {}]] end
-    @set_error = lambda{|ec, ei| @db.fetch = @db.autoid = @db.numrows = ec; info.merge!(ei)}
-    @db.define_singleton_method(:error_info){|e| info}
-    @metadata_results = [
-     [{:constraint=>'items_i_check', :column=>'i', :definition=>'CHECK i'}, {:constraint=>'items_i_id_check', :column=>'i', :definition=>'CHECK i + id < 20'}, {:constraint=>'items_i_id_check', :column=>'id', :definition=>'CHECK i + id < 20'}],
-     [{:name=>'items_i_uidx', :unique=>true, :column=>'i', :deferrable=>false}, {:name=>'items_i2_idx', :unique=>false, :column=>'i', :deferrable=>false}],
-     [{:name=>'items_i_fk', :column=>'i', :on_update=>'a', :on_delete=>'a', :table=>'items2', :refcolumn=>'id', :schema=>'public'}],
-     [{:name=>'items2_i_fk', :column=>'id', :on_update=>'a', :on_delete=>'a', :table=>'items2', :refcolumn=>'i', :schema=>'public'}],
-     [{:nspname=>'public', :relname=>'items'}]
-    ]
-    @c = create_model(@db[:items])
-  end
-
-  it "should handle check constraint failures as validation errors when creating" do
-    o = @c.new(:i=>12)
-    @set_error[Sequel::CheckConstraintViolation, :constraint=>'items_i_check']
-    proc{o.save}.must_raise Sequel::ValidationFailed
-    o.errors.must_equal(:i=>['is invalid'])
-  end
-
-  it "should handle check constraint failures as validation errors when updating" do
-    o = @c.load(:i=>3)
-    @set_error[Sequel::CheckConstraintViolation, :constraint=>'items_i_check']
-    proc{o.update(:i=>12)}.must_raise Sequel::ValidationFailed
-    o.errors.must_equal(:i=>['is invalid'])
-  end
-
-  it "should handle unique constraint failures as validation errors when creating" do
-    o = @c.new(:i=>2)
-    @set_error[Sequel::UniqueConstraintViolation, :constraint=>'items_i_uidx']
-    proc{o.save}.must_raise Sequel::ValidationFailed
-    o.errors.must_equal(:i=>['is already taken'])
-  end
-
-  it "should handle unique constraint failures as validation errors when updating" do
-    o = @c.load(:id=>5, :i=>3)
-    @set_error[Sequel::UniqueConstraintViolation, :constraint=>'items_i_uidx']
-    proc{o.update(:i=>2)}.must_raise Sequel::ValidationFailed
-    o.errors.must_equal(:i=>['is already taken'])
-  end
-
-  it "should handle not null constraint failures as validation errors when creating" do
-    o = @c.new(:i=>5)
-    @set_error[Sequel::NotNullConstraintViolation, :column=>'i']
-    proc{o.save}.must_raise Sequel::ValidationFailed
-    o.errors.must_equal(:i=>['is not present'])
-  end
-
-  it "should handle not null constraint failures as validation errors when updating" do
-    o = @c.load(:i=>3)
-    @set_error[Sequel::NotNullConstraintViolation, :column=>'i']
-    proc{o.update(:i=>nil)}.must_raise Sequel::ValidationFailed
-    o.errors.must_equal(:i=>['is not present'])
-  end
-
-  it "should handle foreign key constraint failures as validation errors when creating" do
-    o = @c.new(:i=>3)
-    @set_error[Sequel::ForeignKeyConstraintViolation, :constraint=>'items_i_fk', :message_primary=>'insert or']
-    proc{o.save}.must_raise Sequel::ValidationFailed
-    o.errors.must_equal(:i=>['is invalid'])
-  end
-
-  it "should handle foreign key constraint failures as validation errors when updating" do
-    o = @c.load(:i=>1)
-    @set_error[Sequel::ForeignKeyConstraintViolation, :constraint=>'items_i_fk', :message_primary=>'insert or']
-    proc{o.update(:i=>3)}.must_raise Sequel::ValidationFailed
-    o.errors.must_equal(:i=>['is invalid'])
-  end
-
-  it "should handle foreign key constraint failures in other tables as validation errors when updating" do
-    o = @c.load(:i=>1)
-    @set_error[Sequel::ForeignKeyConstraintViolation, :constraint=>'items2_i_fk', :message_primary=>'update or', :schema=>'public', :table=>'items2']
-    proc{o.update(:i=>3)}.must_raise Sequel::ValidationFailed
-    o.errors.must_equal(:i=>['cannot be changed currently'])
-  end
-
-  it "should handle symbol, string, and identifier table names" do
-    [@db[:items], @db.from('items'), @db.from{items}, @db.from{public[:items]}].each do |ds|
-      c = create_model(ds)
-      @set_error[Sequel::CheckConstraintViolation, :constraint=>'items_i_check']
-      o = c.new(:i=>3)
-      proc{o.save}.must_raise Sequel::ValidationFailed
-      o.errors.must_equal(:i=>['is invalid'])
-    end
-  end
-
-  it "should skip handling of other table types such as subqueries and functions" do
-    [@db.from{foo(:bar)}, @db[:a, :b]].each do |ds|
-      @db.fetch = @metadata_results.dup
-      @c.dataset = ds
-      o = @c.new(:i=>3)
-      @set_error[Sequel::CheckConstraintViolation, :constraint=>'items_i_check']
-      proc{o.save}.must_raise Sequel::CheckConstraintViolation
-    end
-  end
-
-  it "should skip handling if the error_info method is not supported" do
-    @db.singleton_class.send(:remove_method, :error_info)
-    c = create_model(@db[:items])
-    @set_error[Sequel::CheckConstraintViolation, :constraint=>'items_i_check']
-    o = c.new(:i=>3)
-    proc{o.save}.must_raise Sequel::CheckConstraintViolation
-  end
-
-  it "should not handle constraint failures if they can't be converted" do
-    o = @c.new(:i=>12)
-    @set_error[Sequel::NotNullConstraintViolation, {}]
-    proc{o.save}.must_raise Sequel::NotNullConstraintViolation
-  end
-
-  it "should reraise original exception if there is an error" do
-    o = @c.new(:i=>12)
-    def o.add_pg_constraint_validation_error; end
-    @set_error[Sequel::NotNullConstraintViolation, :column=>'i']
-    proc{o.save}.must_raise Sequel::NotNullConstraintViolation
-  end
-
-  it "should not handle constraint failures if schema or table do not match" do
-    o = @c.new(:i=>12)
-    @set_error[Sequel::CheckConstraintViolation, :constraint=>'items_i_check', :schema=>'x']
-    proc{o.save}.must_raise Sequel::CheckConstraintViolation
-    @set_error[Sequel::CheckConstraintViolation, :constraint=>'items_i_check', :schema=>'public', :table=>'x']
-    proc{o.save}.must_raise Sequel::CheckConstraintViolation
-  end
-
-  it "should handle constraint failures when disabling insert returning" do
-    c = create_model(@db[:items].disable_insert_returning)
-    o = c.new(:i=>12)
-    o.id = 1
-    @set_error[Sequel::CheckConstraintViolation, :constraint=>'items_i_check']
-    proc{o.save}.must_raise Sequel::ValidationFailed
-    o.errors.must_equal(:i=>['is invalid'])
-  end
-
-  it "should handle multi-column constraint failures as validation errors" do
-    o = @c.new(:i=>12)
-    @set_error[Sequel::CheckConstraintViolation, :constraint=>'items_i_id_check']
-    proc{o.save}.must_raise Sequel::ValidationFailed
-    o.errors.must_equal([:i, :id]=>['is invalid'])
-  end
-
-  it "should handle multi-column constraint failures as validation errors when using the error_splitter plugin" do
-    @c.plugin :error_splitter
-    o = @c.new(:i=>12)
-    @set_error[Sequel::CheckConstraintViolation, :constraint=>'items_i_id_check']
-    proc{o.save}.must_raise Sequel::ValidationFailed
-    o.errors.must_equal(:i=>['is invalid'], :id=>['is invalid'])
-  end
-
-  it "should handle overridden constraint failures as validation errors when updating" do
-    o = @c.load(:i=>3)
-    @c.pg_auto_constraint_validation_override(:items_i_ocheck, :i, "foo bar")
-    @set_error[Sequel::CheckConstraintViolation, :constraint=>'items_i_ocheck']
-    proc{o.update(:i=>12)}.must_raise Sequel::ValidationFailed
-    o.errors.must_equal(:i=>['foo bar'])
-  end
-end

data/spec/extensions/pg_enum_spec.rb

@@ -1,118 +0,0 @@
-require_relative "spec_helper"
-
-Sequel.extension :migration
-
-describe "pg_enum extension" do
-  before do
-    @db = Sequel.connect('mock://postgres')
-    @db.extend_datasets{def quote_identifiers?; false end}
-    @db.extend(Module.new do
-      def schema_parse_table(*)
-        [[:a, {:oid=>1}]]
-      end
-      def _metadata_dataset
-        super.with_fetch([[{:v=>1, :enumlabel=>'a'}, {:v=>1, :enumlabel=>'b'}, {:v=>1, :enumlabel=>'c'}], [{:typname=>'enum1', :v=>212389}]])
-      end
-    end)
-    @db.extension(:pg_array, :pg_enum)
-    @db.sqls
-  end
-
-  it "should include enum information in the schema entry" do
-    @db.schema(:a).must_equal [[:a, {:oid=>1, :ruby_default=>nil, :type=>:enum, :enum_values=>%w'a b c'}]]
-  end
-
-  it "should typecast objects to string" do
-    @db.typecast_value(:enum, :a).must_equal 'a'
-  end
-
-  it "should add array parsers for enum values" do
-    @db.conversion_procs[212389].call('{a,b,c}').must_equal %w'a b c'
-  end
-
-  it "should support #create_enum method for adding a new enum" do
-    @db.create_enum(:foo, [:a, :b, :c])
-    @db.sqls.first.must_equal "CREATE TYPE foo AS ENUM ('a', 'b', 'c')"
-    @db.create_enum(Sequel[:sch][:foo], %w'a b c')
-    @db.sqls.first.must_equal "CREATE TYPE sch.foo AS ENUM ('a', 'b', 'c')"
-  end
-
-  with_symbol_splitting "should support #create_enum method for adding a new enum with qualified symbol" do
-    @db.create_enum(:sch__foo, %w'a b c')
-    @db.sqls.first.must_equal "CREATE TYPE sch.foo AS ENUM ('a', 'b', 'c')"
-  end
-
-  it "should support #rename_enum method for renameing an enum" do
-    @db.rename_enum(:foo, :bar)
-    @db.sqls.first.must_equal "ALTER TYPE foo RENAME TO bar"
-    @db.rename_enum(Sequel[:sch][:foo], Sequel[:sch][:bar])
-    @db.sqls.first.must_equal "ALTER TYPE sch.foo RENAME TO sch.bar"
-  end
-
-  it "should support #rename_enum_value method for renameing an enum value" do
-    @db.rename_enum_value(:foo, :b, :x)
-    @db.sqls.first.must_equal "ALTER TYPE foo RENAME VALUE 'b' TO 'x'"
-  end
-
-  it "should support #drop_enum method for dropping an enum" do
-    @db.drop_enum(:foo)
-    @db.sqls.first.must_equal "DROP TYPE foo"
-    @db.drop_enum(Sequel[:sch][:foo], :if_exists=>true)
-    @db.sqls.first.must_equal "DROP TYPE IF EXISTS sch.foo"
-    @db.drop_enum('foo', :cascade=>true)
-    @db.sqls.first.must_equal "DROP TYPE foo CASCADE"
-  end
-
-  with_symbol_splitting "should support #drop_enum method for dropping an enum with a splittable symbol" do
-    @db.drop_enum(:sch__foo, :if_exists=>true)
-    @db.sqls.first.must_equal "DROP TYPE IF EXISTS sch.foo"
-  end
-
-  it "should support #add_enum_value method for adding value to an existing enum" do
-    @db.add_enum_value(:foo, :a)
-    @db.sqls.first.must_equal "ALTER TYPE foo ADD VALUE 'a'"
-  end
-
-  it "should support :before option for #add_enum_value method for adding value before an existing enum value" do
-    @db.add_enum_value('foo', :a, :before=>:b)
-    @db.sqls.first.must_equal "ALTER TYPE foo ADD VALUE 'a' BEFORE 'b'"
-  end
-
-  it "should support :after option for #add_enum_value method for adding value after an existing enum value" do
-    @db.add_enum_value(Sequel[:sch][:foo], :a, :after=>:b)
-    @db.sqls.first.must_equal "ALTER TYPE sch.foo ADD VALUE 'a' AFTER 'b'"
-  end
-
-  with_symbol_splitting "should support :after option for #add_enum_value method for adding value after an existing enum value with splittable symbol" do
-    @db.add_enum_value(:sch__foo, :a, :after=>:b)
-    @db.sqls.first.must_equal "ALTER TYPE sch.foo ADD VALUE 'a' AFTER 'b'"
-  end
-
-  it "should support :if_not_exists option for #add_enum_value method for not adding the value if it exists" do
-    @db.add_enum_value(:foo, :a, :if_not_exists=>true)
-    @db.sqls.first.must_equal "ALTER TYPE foo ADD VALUE IF NOT EXISTS 'a'"
-  end
-
-  it "should reverse a create_enum directive in a migration" do
-    m = Sequel.migration{change{create_enum(:type_name, %w'value1 value2 value3')}}
-    m.apply(@db, :up)
-    @db.sqls.must_equal ["CREATE TYPE type_name AS ENUM ('value1', 'value2', 'value3')",
-      "SELECT CAST(enumtypid AS integer) AS v, enumlabel FROM pg_enum ORDER BY enumtypid, enumsortorder",
-      "SELECT typname, CAST(typarray AS integer) AS v FROM pg_type WHERE ((1 = 0) AND (typarray != 0))"]
-    m.apply(@db, :down)
-    @db.sqls.must_equal ["DROP TYPE type_name", "SELECT CAST(enumtypid AS integer) AS v, enumlabel FROM pg_enum ORDER BY enumtypid, enumsortorder",
-      "SELECT typname, CAST(typarray AS integer) AS v FROM pg_type WHERE ((1 = 0) AND (typarray != 0))"]
-  end
-
-  it "should reverse a rename_enum directive in a migration" do
-    m = Sequel.migration{change{rename_enum(:old_type_name, :new_type_name)}}
-    m.apply(@db, :up)
-    @db.sqls.must_equal ["ALTER TYPE old_type_name RENAME TO new_type_name",
-      "SELECT CAST(enumtypid AS integer) AS v, enumlabel FROM pg_enum ORDER BY enumtypid, enumsortorder",
-      "SELECT typname, CAST(typarray AS integer) AS v FROM pg_type WHERE ((1 = 0) AND (typarray != 0))"]
-    m.apply(@db, :down)
-    @db.sqls.must_equal ["ALTER TYPE new_type_name RENAME TO old_type_name",
-      "SELECT CAST(enumtypid AS integer) AS v, enumlabel FROM pg_enum ORDER BY enumtypid, enumsortorder",
-      "SELECT typname, CAST(typarray AS integer) AS v FROM pg_type WHERE ((1 = 0) AND (typarray != 0))"]
-  end
-end

data/spec/extensions/pg_extended_date_support_spec.rb

@@ -1,126 +0,0 @@
-require_relative "spec_helper"
-
-describe "pg_extended_date_support extension" do
-  before do
-    @db = Sequel.mock(:host=>'postgres', :fetch=>{:v=>1}).extension(:pg_extended_date_support)
-    @db.extend_datasets{def quote_identifiers?; false end}
-  end
-  after do
-    Sequel.datetime_class = Time
-    Sequel.default_timezone = nil
-  end
-
-  it "should convert infinite timestamps and dates as configured" do
-    cp = @db.conversion_procs
-    d = lambda{|v| cp[1082].call(v)}
-    t = lambda{|v| cp[1114].call(v)}
-    pi = 'infinity'
-    ni = '-infinity'
-    today = Date.today
-    now = Time.now
-
-    d.(today.to_s).must_equal today
-    t.(now.strftime("%Y-%m-%d %H:%M:%S.%N")).must_equal now
-    proc{@db.typecast_value(:date, pi)}.must_raise Sequel::InvalidValue
-    proc{@db.typecast_value(:datetime, pi)}.must_raise Sequel::InvalidValue
-
-    [:nil, 'nil'].each do |v|
-      @db.convert_infinite_timestamps = v
-      d.(pi).must_be_nil
-      t.(pi).must_be_nil
-      d.(ni).must_be_nil
-      t.(ni).must_be_nil
-      @db.typecast_value(:date, pi).must_equal pi
-      @db.typecast_value(:datetime, pi).must_equal pi
-      @db.typecast_value(:date, ni).must_equal ni
-      @db.typecast_value(:datetime, ni).must_equal ni
-    end
-
-    d.(today.to_s).must_equal today
-    t.(now.strftime("%Y-%m-%d %H:%M:%S.%N")).must_equal now
-    @db.typecast_value(:date, today.to_s).must_equal today
-    @db.typecast_value(:datetime, now.strftime("%Y-%m-%d %H:%M:%S.%N")).must_equal now
-
-    [:string, 'string'].each do |v|
-      @db.convert_infinite_timestamps = v
-      d.(pi).must_equal pi
-      t.(pi).must_equal pi
-      d.(ni).must_equal ni
-      t.(ni).must_equal ni
-    end
-
-    [:date, 'date'].each do |v|
-      @db.convert_infinite_timestamps = v
-      d.(pi).must_equal Date::Infinity.new
-      t.(pi).must_equal Date::Infinity.new
-      d.(ni).must_equal(-Date::Infinity.new)
-      t.(ni).must_equal(-Date::Infinity.new)
-    end
-
-    [:float, 'float', 't', true].each do |v|
-      @db.convert_infinite_timestamps = v
-      d.(pi).must_equal 1.0/0.0
-      t.(pi).must_equal 1.0/0.0
-      d.(ni).must_equal(-1.0/0.0)
-      t.(ni).must_equal(-1.0/0.0)
-    end
-
-    ['f', false].each do |v|
-      @db.convert_infinite_timestamps = v
-      proc{d.(pi)}.must_raise ArgumentError, Sequel::InvalidValue
-      proc{t.(pi)}.must_raise ArgumentError, Sequel::InvalidValue
-      proc{d.(ni)}.must_raise ArgumentError, Sequel::InvalidValue
-      proc{t.(ni)}.must_raise ArgumentError, Sequel::InvalidValue
-    end
-  end
-
-  it "should handle parsing BC dates" do
-    @db.conversion_procs[1082].call("1092-10-20 BC").must_equal Date.new(-1091, 10, 20)
-  end
-
-  it "should handle parsing BC timestamps as Time values" do
-    @db.conversion_procs[1114].call("1200-02-15 14:13:20-00:00 BC").must_equal Time.at(-100000000000).utc
-    @db.conversion_procs[1114].call("1200-02-15 14:13:20-00:00:00 BC").must_equal Time.at(-100000000000).utc
-    Sequel.default_timezone = :utc
-    @db.conversion_procs[1114].call("1200-02-15 14:13:20 BC").must_equal Time.at(-100000000000).utc
-    Sequel.default_timezone = nil
-  end
-
-  it "should handle parsing BC timestamps as DateTime values" do
-    Sequel.datetime_class = DateTime
-    @db.conversion_procs[1114].call("1200-02-15 14:13:20-00:00 BC").must_equal DateTime.new(-1199, 2, 15, 14, 13, 20)
-    @db.conversion_procs[1114].call("1200-02-15 14:13:20-00:00:00 BC").must_equal DateTime.new(-1199, 2, 15, 14, 13, 20)
-    Sequel.default_timezone = :utc
-    @db.conversion_procs[1114].call("1200-02-15 14:13:20 BC").must_equal DateTime.new(-1199, 2, 15, 14, 13, 20)
-  end
-
-  it "should handle parsing AD timestamps with offset seconds" do
-    @db.conversion_procs[1114].call("1200-02-15 14:13:20-00:00:00").must_equal DateTime.new(1200, 2, 15, 14, 13, 20).to_time
-    Sequel.datetime_class = DateTime
-    @db.conversion_procs[1114].call("1200-02-15 14:13:20-00:00:00").must_equal DateTime.new(1200, 2, 15, 14, 13, 20)
-  end
-
-  it "should format Date::Infinity values" do
-    @db.literal(Date::Infinity.new).must_equal "'infinity'"
-    @db.literal(-Date::Infinity.new).must_equal "'-infinity'"
-  end
-
-  it "should raise errors for literalizing random Objects" do
-    proc{@db.literal(Object.new)}.must_raise Sequel::Error
-  end
-
-  it "should format BC dates" do
-    @db.literal(Date.new(-1091, 10, 20)).must_equal "'1092-10-20 BC'"
-    @db.literal(Date.new(1092, 10, 20)).must_equal "'1092-10-20'"
-  end
-
-  it "should format BC datetimes" do
-    @db.literal(DateTime.new(-1199, 2, 15, 14, 13, 20)).must_equal "'1200-02-15 14:13:20.000000000+0000 BC'"
-    @db.literal(DateTime.new(1200, 2, 15, 14, 13, 20)).must_equal "'1200-02-15 14:13:20.000000+0000'"
-  end
-
-  it "should format BC times" do
-    @db.literal(Time.at(-100000000000).utc).must_equal "'1200-02-15 14:13:20.000000000+0000 BC'"
-    @db.literal(Time.at(100000000000).utc).must_equal "'5138-11-16 09:46:40.000000+0000'"
-  end
-end

data/spec/extensions/pg_hstore_ops_spec.rb

@@ -1,238 +0,0 @@
-require_relative "spec_helper"
-
-Sequel.extension :pg_array, :pg_array_ops, :pg_hstore, :pg_hstore_ops
-
-describe "Sequel::Postgres::HStoreOp" do
-  before do
-    @db = Sequel.connect('mock://postgres')
-    @db.extend_datasets{def quote_identifiers?; false end}
-    @ds = @db.dataset
-    @h = Sequel.hstore_op(:h)
-  end
-
-  it "#- should use the - operator" do
-    @ds.literal(@h - :a).must_equal "(h - a)"
-  end
-
-  it "#- should cast String argument to text when using - operator" do
-    @ds.literal(@h - 'a').must_equal "(h - CAST('a' AS text))"
-  end
-
-  it "#- should not cast LiteralString argument to text when using - operator" do
-    @ds.literal(@h - Sequel.lit('a')).must_equal "(h - a)"
-  end
-
-  it "#- should handle arrays" do
-    @ds.literal(@h - %w'a').must_equal "(h - ARRAY['a'])"
-  end
-
-  it "#- should handle hashes" do
-    @ds.literal(@h - {'a'=>'b'}).must_equal "(h - '\"a\"=>\"b\"'::hstore)"
-  end
-
-  it "#- should return an HStoreOp" do
-    @ds.literal((@h - :a)['a']).must_equal "((h - a) -> 'a')"
-  end
-
-  it "#[] should use the -> operator" do
-    @ds.literal(@h['a']).must_equal "(h -> 'a')"
-  end
-
-  it "#[] should handle arrays" do
-    @ds.literal(@h[%w'a']).must_equal "(h -> ARRAY['a'])"
-  end
-
-  it "#[] should return a PGArrayOp if given an array" do
-    @ds.literal(@h[%w'a'][0]).must_equal "((h -> ARRAY['a']))[0]"
-  end
-
-  it "#[] should not return a PGArrayOp if given an array but pg_array_op is not supported" do
-    begin
-      module Sequel::Postgres::HStoreOp::Sequel
-        SQL = ::Sequel::SQL
-      end
-      @ds.literal(@h[%w'a']).wont_be_kind_of(Sequel::Postgres::ArrayOp)
-    ensure
-      Sequel::Postgres::HStoreOp.send(:remove_const, :Sequel)
-    end
-  end
-
-  it "#[] should return a PGArrayOp if given a PGArray" do
-    @ds.literal(@h[Sequel.pg_array(%w'a')][0]).must_equal "((h -> ARRAY['a']))[0]"
-  end
-
-  it "#[] should return a PGArrayOp if given a PGArrayOp" do
-    @ds.literal(@h[Sequel.pg_array_op(:a)][0]).must_equal "((h -> a))[0]"
-  end
-
-  it "#[] should return a string expression" do
-    @ds.literal(@h['a'] + 'b').must_equal "((h -> 'a') || 'b')"
-  end
-
-  it "#concat and #merge should use the || operator" do
-    @ds.literal(@h.concat(:h1)).must_equal "(h || h1)"
-    @ds.literal(@h.merge(:h1)).must_equal "(h || h1)"
-  end
-
-  it "#concat and #merge should handle hashes" do
-    @ds.literal(@h.concat('a'=>'b')).must_equal "(h || '\"a\"=>\"b\"'::hstore)"
-    @ds.literal(@h.merge('a'=>'b')).must_equal "(h || '\"a\"=>\"b\"'::hstore)"
-  end
-
-  it "#concat should return an HStoreOp" do
-    @ds.literal(@h.concat(:h1)['a']).must_equal "((h || h1) -> 'a')"
-  end
-
-  it "#contain_all should use the ?& operator" do
-    @ds.literal(@h.contain_all(:h1)).must_equal "(h ?& h1)"
-  end
-
-  it "#contain_all handle arrays" do
-    @ds.literal(@h.contain_all(%w'h1')).must_equal "(h ?& ARRAY['h1'])"
-  end
-
-  it "#contain_any should use the ?| operator" do
-    @ds.literal(@h.contain_any(:h1)).must_equal "(h ?| h1)"
-  end
-
-  it "#contain_any should handle arrays" do
-    @ds.literal(@h.contain_any(%w'h1')).must_equal "(h ?| ARRAY['h1'])"
-  end
-
-  it "#contains should use the @> operator" do
-    @ds.literal(@h.contains(:h1)).must_equal "(h @> h1)"
-  end
-
-  it "#contains should handle hashes" do
-    @ds.literal(@h.contains('a'=>'b')).must_equal "(h @> '\"a\"=>\"b\"'::hstore)"
-  end
-
-  it "#contained_by should use the <@ operator" do
-    @ds.literal(@h.contained_by(:h1)).must_equal "(h <@ h1)"
-  end
-
-  it "#contained_by should handle hashes" do
-    @ds.literal(@h.contained_by('a'=>'b')).must_equal "(h <@ '\"a\"=>\"b\"'::hstore)"
-  end
-
-  it "#defined should use the defined function" do
-    @ds.literal(@h.defined('a')).must_equal "defined(h, 'a')"
-  end
-
-  it "#delete should use the delete function" do
-    @ds.literal(@h.delete('a')).must_equal "delete(h, 'a')"
-  end
-
-  it "#delete should handle arrays" do
-    @ds.literal(@h.delete(%w'a')).must_equal "delete(h, ARRAY['a'])"
-  end
-
-  it "#delete should handle hashes" do
-    @ds.literal(@h.delete('a'=>'b')).must_equal "delete(h, '\"a\"=>\"b\"'::hstore)"
-  end
-
-  it "#delete should return an HStoreOp" do
-    @ds.literal(@h.delete('a')['a']).must_equal "(delete(h, 'a') -> 'a')"
-  end
-
-  it "#each should use the each function" do
-    @ds.literal(@h.each).must_equal "each(h)"
-  end
-
-  it "#has_key? and aliases should use the ? operator" do
-    @ds.literal(@h.has_key?('a')).must_equal "(h ? 'a')"
-    @ds.literal(@h.key?('a')).must_equal "(h ? 'a')"
-    @ds.literal(@h.member?('a')).must_equal "(h ? 'a')"
-    @ds.literal(@h.include?('a')).must_equal "(h ? 'a')"
-    @ds.literal(@h.exist?('a')).must_equal "(h ? 'a')"
-  end
-
-  it "#hstore should return the receiver" do
-    @h.hstore.must_be_same_as(@h)
-  end
-
-  it "#keys and #akeys should use the akeys function" do
-    @ds.literal(@h.keys).must_equal "akeys(h)"
-    @ds.literal(@h.akeys).must_equal "akeys(h)"
-  end
-
-  it "#keys and #akeys should return PGArrayOps" do
-    @ds.literal(@h.keys[0]).must_equal "(akeys(h))[0]"
-    @ds.literal(@h.akeys[0]).must_equal "(akeys(h))[0]"
-  end
-
-  it "#populate should use the populate_record function" do
-    @ds.literal(@h.populate(:a)).must_equal "populate_record(a, h)"
-  end
-
-  it "#record_set should use the #= operator" do
-    @ds.literal(@h.record_set(:a)).must_equal "(a #= h)"
-  end
-
-  it "#skeys should use the skeys function" do
-    @ds.literal(@h.skeys).must_equal "skeys(h)"
-  end
-
-  it "#slice should should use the slice function" do
-    @ds.literal(@h.slice(:a)).must_equal "slice(h, a)"
-  end
-
-  it "#slice should handle arrays" do
-    @ds.literal(@h.slice(%w'a')).must_equal "slice(h, ARRAY['a'])"
-  end
-
-  it "#slice should return an HStoreOp" do
-    @ds.literal(@h.slice(:a)['a']).must_equal "(slice(h, a) -> 'a')"
-  end
-
-  it "#svals should use the svals function" do
-    @ds.literal(@h.svals).must_equal "svals(h)"
-  end
-
-  it "#to_array should use the hstore_to_array function" do
-    @ds.literal(@h.to_array).must_equal "hstore_to_array(h)"
-  end
-
-  it "#to_array should return a PGArrayOp" do
-    @ds.literal(@h.to_array[0]).must_equal "(hstore_to_array(h))[0]"
-  end
-
-  it "#to_matrix should use the hstore_to_matrix function" do
-    @ds.literal(@h.to_matrix).must_equal "hstore_to_matrix(h)"
-  end
-
-  it "#to_matrix should return a PGArrayOp" do
-    @ds.literal(@h.to_matrix[0]).must_equal "(hstore_to_matrix(h))[0]"
-  end
-
-  it "#values and #avals should use the avals function" do
-    @ds.literal(@h.values).must_equal "avals(h)"
-    @ds.literal(@h.avals).must_equal "avals(h)"
-  end
-
-  it "#values and #avals should return PGArrayOps" do
-    @ds.literal(@h.values[0]).must_equal "(avals(h))[0]"
-    @ds.literal(@h.avals[0]).must_equal "(avals(h))[0]"
-  end
-
-  it "should have Sequel.hstore_op return HStoreOp instances as-is" do
-    Sequel.hstore_op(@h).must_be_same_as(@h)
-  end
-
-  it "should have Sequel.hstore return HStoreOp instances" do
-    Sequel.hstore(:h).must_equal @h
-  end
-
-  it "should be able to turn expressions into hstore ops using hstore" do
-    @ds.literal(Sequel.qualify(:b, :a).hstore['a']).must_equal "(b.a -> 'a')"
-    @ds.literal(Sequel.function(:a, :b).hstore['a']).must_equal "(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']).must_equal "(a -> 'a')"
-  end
-
-  it "should allow transforming HStore instances into HStoreOp instances" do
-    @ds.literal(Sequel.hstore('a'=>'b').op['a']).must_equal "('\"a\"=>\"b\"'::hstore -> 'a')"
-  end
-end