path: root/activerecord/test/cases/adapters/postgresql/uuid_test.rb

require "cases/helper"
require "support/schema_dumping_helper"

module PostgresqlUUIDHelper
  def connection
    @connection ||= ActiveRecord::Base.connection
  end

  def drop_table(name)
    connection.drop_table name, if_exists: true
  end

  def uuid_function
    connection.supports_pgcrypto_uuid? ? "gen_random_uuid()" : "uuid_generate_v4()"
  end
end

class PostgresqlUUIDTest < ActiveRecord::PostgreSQLTestCase
  include PostgresqlUUIDHelper
  include SchemaDumpingHelper

  class UUIDType < ActiveRecord::Base
    self.table_name = "uuid_data_type"
  end

  setup do
    enable_extension!("uuid-ossp", connection)
    enable_extension!("pgcrypto",  connection) if connection.supports_pgcrypto_uuid?

    connection.create_table "uuid_data_type" do |t|
      t.uuid "guid"
    end
  end

  teardown do
    drop_table "uuid_data_type"
  end

  if ActiveRecord::Base.connection.supports_pgcrypto_uuid?
    def test_uuid_column_default
      connection.add_column :uuid_data_type, :thingy, :uuid, null: false, default: "gen_random_uuid()"
      UUIDType.reset_column_information
      column = UUIDType.columns_hash["thingy"]
      assert_equal "gen_random_uuid()", column.default_function
    end
  end

  def test_change_column_default
    connection.add_column :uuid_data_type, :thingy, :uuid, null: false, default: "uuid_generate_v1()"
    UUIDType.reset_column_information
    column = UUIDType.columns_hash["thingy"]
    assert_equal "uuid_generate_v1()", column.default_function

    connection.change_column :uuid_data_type, :thingy, :uuid, null: false, default: "uuid_generate_v4()"
    UUIDType.reset_column_information
    column = UUIDType.columns_hash["thingy"]
    assert_equal "uuid_generate_v4()", column.default_function
  ensure
    UUIDType.reset_column_information
  end

  def test_data_type_of_uuid_types
    column = UUIDType.columns_hash["guid"]
    assert_equal :uuid, column.type
    assert_equal "uuid", column.sql_type
    assert_not column.array?

    type = UUIDType.type_for_attribute("guid")
    assert_not type.binary?
  end

  def test_treat_blank_uuid_as_nil
    UUIDType.create! guid: ""
    assert_nil(UUIDType.last.guid)
  end

  def test_treat_invalid_uuid_as_nil
    uuid = UUIDType.create! guid: "foobar"
    assert_nil(uuid.guid)
  end

  def test_invalid_uuid_dont_modify_before_type_cast
    uuid = UUIDType.new guid: "foobar"
    assert_equal "foobar", uuid.guid_before_type_cast
  end

  def test_acceptable_uuid_regex
    # Valid uuids
    ["A0EEBC99-9C0B-4EF8-BB6D-6BB9BD380A11",
     "{a0eebc99-9c0b-4ef8-bb6d-6bb9bd380a11}",
     "a0eebc999c0b4ef8bb6d6bb9bd380a11",
     "a0ee-bc99-9c0b-4ef8-bb6d-6bb9-bd38-0a11",
     "{a0eebc99-9c0b4ef8-bb6d6bb9-bd380a11}",
     # The following is not a valid RFC 4122 UUID, but PG doesn't seem to care,
     # so we shouldn't block it either. (Pay attention to "fb6d" – the "f" here
     # is invalid – it must be one of 8, 9, A, B, a, b according to the spec.)
     "{a0eebc99-9c0b-4ef8-fb6d-6bb9bd380a11}",
    ].each do |valid_uuid|
      uuid = UUIDType.new guid: valid_uuid
      assert_not_nil uuid.guid
    end

    # Invalid uuids
    [["A0EEBC99-9C0B-4EF8-BB6D-6BB9BD380A11"],
     Hash.new,
     0,
     0.0,
     true,
     "Z0000C99-9C0B-4EF8-BB6D-6BB9BD380A11",
     "a0eebc999r0b4ef8ab6d6bb9bd380a11",
     "a0ee-bc99------4ef8-bb6d-6bb9-bd38-0a11",
     "{a0eebc99-bb6d6bb9-bd380a11}"].each do |invalid_uuid|
      uuid = UUIDType.new guid: invalid_uuid
      assert_nil uuid.guid
    end
  end

  def test_uuid_formats
    ["A0EEBC99-9C0B-4EF8-BB6D-6BB9BD380A11",
     "{a0eebc99-9c0b-4ef8-bb6d-6bb9bd380a11}",
     "a0eebc999c0b4ef8bb6d6bb9bd380a11",
     "a0ee-bc99-9c0b-4ef8-bb6d-6bb9-bd38-0a11",
     "{a0eebc99-9c0b4ef8-bb6d6bb9-bd380a11}"].each do |valid_uuid|
      UUIDType.create(guid: valid_uuid)
      uuid = UUIDType.last
      assert_equal "a0eebc99-9c0b-4ef8-bb6d-6bb9bd380a11", uuid.guid
    end
  end

  def test_schema_dump_with_shorthand
    output = dump_table_schema "uuid_data_type"
    assert_match %r{t\.uuid "guid"}, output
  end

  def test_uniqueness_validation_ignores_uuid
    klass = Class.new(ActiveRecord::Base) do
      self.table_name = "uuid_data_type"
      validates :guid, uniqueness: { case_sensitive: false }

      def self.name
        "UUIDType"
      end
    end

    record = klass.create!(guid: "a0ee-bc99-9c0b-4ef8-bb6d-6bb9-bd38-0a11")
    duplicate = klass.new(guid: record.guid)

    assert record.guid.present? # Ensure we actually are testing a UUID
    assert_not duplicate.valid?
  end
end

class PostgresqlUUIDGenerationTest < ActiveRecord::PostgreSQLTestCase
  include PostgresqlUUIDHelper
  include SchemaDumpingHelper

  class UUID < ActiveRecord::Base
    self.table_name = "pg_uuids"
  end

  setup do
    connection.create_table("pg_uuids", id: :uuid, default: "uuid_generate_v1()") do |t|
      t.string "name"
      t.uuid "other_uuid", default: "uuid_generate_v4()"
    end

    # Create custom PostgreSQL function to generate UUIDs
    # to test dumping tables which columns have defaults with custom functions
    connection.execute <<-SQL
    CREATE OR REPLACE FUNCTION my_uuid_generator() RETURNS uuid
    AS $$ SELECT * FROM #{uuid_function} $$
    LANGUAGE SQL VOLATILE;
    SQL

    # Create such a table with custom function as default value generator
    connection.create_table("pg_uuids_2", id: :uuid, default: "my_uuid_generator()") do |t|
      t.string "name"
      t.uuid "other_uuid_2", default: "my_uuid_generator()"
    end

    connection.create_table("pg_uuids_3", id: :uuid) do |t|
      t.string "name"
    end
  end

  teardown do
    drop_table "pg_uuids"
    drop_table "pg_uuids_2"
    drop_table "pg_uuids_3"
    connection.execute "DROP FUNCTION IF EXISTS my_uuid_generator();"
  end

  if ActiveRecord::Base.connection.supports_extensions?
    def test_id_is_uuid
      assert_equal :uuid, UUID.columns_hash["id"].type
      assert UUID.primary_key
    end

    def test_id_has_a_default
      u = UUID.create
      assert_not_nil u.id
    end

    def test_auto_create_uuid
      u = UUID.create
      u.reload
      assert_not_nil u.other_uuid
    end

    def test_pk_and_sequence_for_uuid_primary_key
      pk, seq = connection.pk_and_sequence_for("pg_uuids")
      assert_equal "id", pk
      assert_nil seq
    end

    def test_schema_dumper_for_uuid_primary_key
      schema = dump_table_schema "pg_uuids"
      assert_match(/\bcreate_table "pg_uuids", id: :uuid, default: -> { "uuid_generate_v1\(\)" }/, schema)
      assert_match(/t\.uuid "other_uuid", default: -> { "uuid_generate_v4\(\)" }/, schema)
    end

    def test_schema_dumper_for_uuid_primary_key_with_custom_default
      schema = dump_table_schema "pg_uuids_2"
      assert_match(/\bcreate_table "pg_uuids_2", id: :uuid, default: -> { "my_uuid_generator\(\)" }/, schema)
      assert_match(/t\.uuid "other_uuid_2", default: -> { "my_uuid_generator\(\)" }/, schema)
    end

    def test_schema_dumper_for_uuid_primary_key_default
      schema = dump_table_schema "pg_uuids_3"
      if connection.supports_pgcrypto_uuid?
        assert_match(/\bcreate_table "pg_uuids_3", id: :uuid, default: -> { "gen_random_uuid\(\)" }/, schema)
      else
        assert_match(/\bcreate_table "pg_uuids_3", id: :uuid, default: -> { "uuid_generate_v4\(\)" }/, schema)
      end
    end

    def test_schema_dumper_for_uuid_primary_key_default_in_legacy_migration
      @verbose_was = ActiveRecord::Migration.verbose
      ActiveRecord::Migration.verbose = false

      migration = Class.new(ActiveRecord::Migration[5.0]) do
        def version; 101 end
        def migrate(x)
          create_table("pg_uuids_4", id: :uuid)
        end
      end.new
      ActiveRecord::Migrator.new(:up, [migration]).migrate

      schema = dump_table_schema "pg_uuids_4"
      assert_match(/\bcreate_table "pg_uuids_4", id: :uuid, default: -> { "uuid_generate_v4\(\)" }/, schema)
    ensure
      drop_table "pg_uuids_4"
      ActiveRecord::Migration.verbose = @verbose_was
    end
  end
end

class PostgresqlUUIDTestNilDefault < ActiveRecord::PostgreSQLTestCase
  include PostgresqlUUIDHelper
  include SchemaDumpingHelper

  setup do
    connection.create_table("pg_uuids", id: false) do |t|
      t.primary_key :id, :uuid, default: nil
      t.string "name"
    end
  end

  teardown do
    drop_table "pg_uuids"
  end

  if ActiveRecord::Base.connection.supports_extensions?
    def test_id_allows_default_override_via_nil
      col_desc = connection.execute("SELECT pg_get_expr(d.adbin, d.adrelid) as default
                                    FROM pg_attribute a
                                    LEFT JOIN pg_attrdef d ON a.attrelid = d.adrelid AND a.attnum = d.adnum
                                    WHERE a.attname='id' AND a.attrelid = 'pg_uuids'::regclass").first
      assert_nil col_desc["default"]
    end

    def test_schema_dumper_for_uuid_primary_key_with_default_override_via_nil
      schema = dump_table_schema "pg_uuids"
      assert_match(/\bcreate_table "pg_uuids", id: :uuid, default: nil/, schema)
    end

    def test_schema_dumper_for_uuid_primary_key_with_default_nil_in_legacy_migration
      @verbose_was = ActiveRecord::Migration.verbose
      ActiveRecord::Migration.verbose = false

      migration = Class.new(ActiveRecord::Migration[5.0]) do
        def version; 101 end
        def migrate(x)
          create_table("pg_uuids_4", id: :uuid, default: nil)
        end
      end.new
      ActiveRecord::Migrator.new(:up, [migration]).migrate

      schema = dump_table_schema "pg_uuids_4"
      assert_match(/\bcreate_table "pg_uuids_4", id: :uuid, default: nil/, schema)
    ensure
      drop_table "pg_uuids_4"
      ActiveRecord::Migration.verbose = @verbose_was
    end
  end
end

class PostgresqlUUIDTestInverseOf < ActiveRecord::PostgreSQLTestCase
  include PostgresqlUUIDHelper

  class UuidPost < ActiveRecord::Base
    self.table_name = "pg_uuid_posts"
    has_many :uuid_comments, inverse_of: :uuid_post
  end

  class UuidComment < ActiveRecord::Base
    self.table_name = "pg_uuid_comments"
    belongs_to :uuid_post
  end

  setup do
    connection.transaction do
      connection.create_table("pg_uuid_posts", id: :uuid) do |t|
        t.string "title"
      end
      connection.create_table("pg_uuid_comments", id: :uuid) do |t|
        t.references :uuid_post, type: :uuid
        t.string "content"
      end
    end
  end

  teardown do
    drop_table "pg_uuid_comments"
    drop_table "pg_uuid_posts"
  end

  if ActiveRecord::Base.connection.supports_extensions?
    def test_collection_association_with_uuid
      post    = UuidPost.create!
      comment = post.uuid_comments.create!
      assert post.uuid_comments.find(comment.id)
    end

    def test_find_with_uuid
      UuidPost.create!
      assert_raise ActiveRecord::RecordNotFound do
        UuidPost.find(123456)
      end
    end

    def test_find_by_with_uuid
      UuidPost.create!
      assert_nil UuidPost.find_by(id: 789)
    end
  end
end