require "cases/helper"
require "support/schema_dumping_helper"
if ActiveRecord::Base.connection.supports_extensions?
class PostgresqlHstoreTest < ActiveRecord::PostgreSQLTestCase
include SchemaDumpingHelper
class Hstore < ActiveRecord::Base
self.table_name = "hstores"
store_accessor :settings, :language, :timezone
end
class FakeParameters
def to_unsafe_h
{ "hi" => "hi" }
end
end
def setup
@connection = ActiveRecord::Base.connection
unless @connection.extension_enabled?("hstore")
@connection.enable_extension "hstore"
@connection.commit_db_transaction
end
@connection.reconnect!
@connection.transaction do
@connection.create_table("hstores") do |t|
t.hstore "tags", default: ""
t.hstore "payload", array: true
t.hstore "settings"
end
end
Hstore.reset_column_information
@column = Hstore.columns_hash["tags"]
@type = Hstore.type_for_attribute("tags")
end
teardown do
@connection.drop_table "hstores", if_exists: true
end
def test_hstore_included_in_extensions
assert @connection.respond_to?(:extensions), "connection should have a list of extensions"
assert_includes @connection.extensions, "hstore", "extension list should include hstore"
end
def test_disable_enable_hstore
assert @connection.extension_enabled?("hstore")
@connection.disable_extension "hstore"
assert_not @connection.extension_enabled?("hstore")
@connection.enable_extension "hstore"
assert @connection.extension_enabled?("hstore")
ensure
# Restore column(s) dropped by `drop extension hstore cascade;`
load_schema
end
def test_column
assert_equal :hstore, @column.type
assert_equal "hstore", @column.sql_type
assert_not @column.array?
assert_not @type.binary?
end
def test_default
@connection.add_column "hstores", "permissions", :hstore, default: '"users"=>"read", "articles"=>"write"'
Hstore.reset_column_information
assert_equal({ "users" => "read", "articles" => "write" }, Hstore.column_defaults["permissions"])
assert_equal({ "users" => "read", "articles" => "write" }, Hstore.new.permissions)
ensure
Hstore.reset_column_information
end
def test_change_table_supports_hstore
@connection.transaction do
@connection.change_table("hstores") do |t|
t.hstore "users", default: ""
end
Hstore.reset_column_information
column = Hstore.columns_hash["users"]
assert_equal :hstore, column.type
raise ActiveRecord::Rollback # reset the schema change
end
ensure
Hstore.reset_column_information
end
def test_hstore_migration
hstore_migration = Class.new(ActiveRecord::Migration::Current) do
def change
change_table("hstores") do |t|
t.hstore :keys
end
end
end
hstore_migration.new.suppress_messages do
hstore_migration.migrate(:up)
assert_includes @connection.columns(:hstores).map(&:name), "keys"
hstore_migration.migrate(:down)
assert_not_includes @connection.columns(:hstores).map(&:name), "keys"
end
end
def test_cast_value_on_write
x = Hstore.new tags: { "bool" => true, "number" => 5 }
assert_equal({ "bool" => true, "number" => 5 }, x.tags_before_type_cast)
assert_equal({ "bool" => "true", "number" => "5" }, x.tags)
x.save
assert_equal({ "bool" => "true", "number" => "5" }, x.reload.tags)
end
def test_type_cast_hstore
assert_equal({ "1" => "2" }, @type.deserialize("\"1\"=>\"2\""))
assert_equal({}, @type.deserialize(""))
assert_equal({ "key" => nil }, @type.deserialize("key => NULL"))
assert_equal({ "c" => "}", '"a"' => 'b "a b' }, @type.deserialize(%q(c=>"}", "\"a\""=>"b \"a b")))
end
def test_with_store_accessors
x = Hstore.new(language: "fr", timezone: "GMT")
assert_equal "fr", x.language
assert_equal "GMT", x.timezone
x.save!
x = Hstore.first
assert_equal "fr", x.language
assert_equal "GMT", x.timezone
x.language = "de"
x.save!
x = Hstore.first
assert_equal "de", x.language
assert_equal "GMT", x.timezone
end
def test_duplication_with_store_accessors
x = Hstore.new(language: "fr", timezone: "GMT")
assert_equal "fr", x.language
assert_equal "GMT", x.timezone
y = x.dup
assert_equal "fr", y.language
assert_equal "GMT", y.timezone
end
def test_yaml_round_trip_with_store_accessors
x = Hstore.new(language: "fr", timezone: "GMT")
assert_equal "fr", x.language
assert_equal "GMT", x.timezone
y = YAML.load(YAML.dump(x))
assert_equal "fr", y.language
assert_equal "GMT", y.timezone
end
def test_changes_in_place
hstore = Hstore.create!(settings: { "one" => "two" })
hstore.settings["three"] = "four"
hstore.save!
hstore.reload
assert_equal "four", hstore.settings["three"]
assert_not hstore.changed?
end
def test_dirty_from_user_equal
settings = { "alongkey" => "anything", "key" => "value" }
hstore = Hstore.create!(settings: settings)
hstore.settings = { "key" => "value", "alongkey" => "anything" }
assert_equal settings, hstore.settings
refute hstore.changed?
end
def test_hstore_dirty_from_database_equal
settings = { "alongkey" => "anything", "key" => "value" }
hstore = Hstore.create!(settings: settings)
hstore.reload
assert_equal settings, hstore.settings
hstore.settings = settings
refute hstore.changed?
end
def test_gen1
assert_equal('" "=>""', @type.serialize(" " => ""))
end
def test_gen2
assert_equal('","=>""', @type.serialize("," => ""))
end
def test_gen3
assert_equal('"="=>""', @type.serialize("=" => ""))
end
def test_gen4
assert_equal('">"=>""', @type.serialize(">" => ""))
end
def test_parse1
assert_equal({ "a" => nil, "b" => nil, "c" => "NuLl", "null" => "c" }, @type.deserialize('a=>null,b=>NuLl,c=>"NuLl",null=>c'))
end
def test_parse2
assert_equal({ " " => " " }, @type.deserialize("\\ =>\\ "))
end
def test_parse3
assert_equal({ "=" => ">" }, @type.deserialize("==>>"))
end
def test_parse4
assert_equal({ "=a" => "q=w" }, @type.deserialize('\=a=>q=w'))
end
def test_parse5
assert_equal({ "=a" => "q=w" }, @type.deserialize('"=a"=>q\=w'))
end
def test_parse6
assert_equal({ "\"a" => "q>w" }, @type.deserialize('"\"a"=>q>w'))
end
def test_parse7
assert_equal({ "\"a" => "q\"w" }, @type.deserialize('\"a=>q"w'))
end
def test_rewrite
@connection.execute "insert into hstores (tags) VALUES ('1=>2')"
x = Hstore.first
x.tags = { '"a\'' => "b" }
assert x.save!
end
def test_select
@connection.execute "insert into hstores (tags) VALUES ('1=>2')"
x = Hstore.first
assert_equal({ "1" => "2" }, x.tags)
end
def test_array_cycle
assert_array_cycle([{ "AA" => "BB", "CC" => "DD" }, { "AA" => nil }])
end
def test_array_strings_with_quotes
assert_array_cycle([{ "this has" => 'some "s that need to be escaped"' }])
end
def test_array_strings_with_commas
assert_array_cycle([{ "this,has" => "many,values" }])
end
def test_array_strings_with_array_delimiters
assert_array_cycle(["{" => "}"])
end
def test_array_strings_with_null_strings
assert_array_cycle([{ "NULL" => "NULL" }])
end
def test_contains_nils
assert_array_cycle([{ "NULL" => nil }])
end
def test_select_multikey
@connection.execute "insert into hstores (tags) VALUES ('1=>2,2=>3')"
x = Hstore.first
assert_equal({ "1" => "2", "2" => "3" }, x.tags)
end
def test_create
assert_cycle("a" => "b", "1" => "2")
end
def test_nil
assert_cycle("a" => nil)
end
def test_quotes
assert_cycle("a" => 'b"ar', '1"foo' => "2")
end
def test_whitespace
assert_cycle("a b" => "b ar", '1"foo' => "2")
end
def test_backslash
assert_cycle('a\\b' => 'b\\ar', '1"foo' => "2")
end
def test_comma
assert_cycle("a, b" => "bar", '1"foo' => "2")
end
def test_arrow
assert_cycle("a=>b" => "bar", '1"foo' => "2")
end
def test_quoting_special_characters
assert_cycle("ca" => "cà", "ac" => "àc")
end
def test_multiline
assert_cycle("a\nb" => "c\nd")
end
class TagCollection
def initialize(hash); @hash = hash end
def to_hash; @hash end
def self.load(hash); new(hash) end
def self.dump(object); object.to_hash end
end
class HstoreWithSerialize < Hstore
serialize :tags, TagCollection
end
def test_hstore_with_serialized_attributes
HstoreWithSerialize.create! tags: TagCollection.new("one" => "two")
record = HstoreWithSerialize.first
assert_instance_of TagCollection, record.tags
assert_equal({ "one" => "two" }, record.tags.to_hash)
record.tags = TagCollection.new("three" => "four")
record.save!
assert_equal({ "three" => "four" }, HstoreWithSerialize.first.tags.to_hash)
end
def test_clone_hstore_with_serialized_attributes
HstoreWithSerialize.create! tags: TagCollection.new("one" => "two")
record = HstoreWithSerialize.first
dupe = record.dup
assert_equal({ "one" => "two" }, dupe.tags.to_hash)
end
def test_schema_dump_with_shorthand
output = dump_table_schema("hstores")
assert_match %r[t\.hstore "tags",\s+default: {}], output
end
def test_supports_to_unsafe_h_values
assert_equal("\"hi\"=>\"hi\"", @type.serialize(FakeParameters.new))
end
private
def assert_array_cycle(array)
# test creation
x = Hstore.create!(payload: array)
x.reload
assert_equal(array, x.payload)
# test updating
x = Hstore.create!(payload: [])
x.payload = array
x.save!
x.reload
assert_equal(array, x.payload)
end
def assert_cycle(hash)
# test creation
x = Hstore.create!(tags: hash)
x.reload
assert_equal(hash, x.tags)
# test updating
x = Hstore.create!(tags: {})
x.tags = hash
x.save!
x.reload
assert_equal(hash, x.tags)
end
end
end