active_record_doctor 1.12.0 → 1.14.0

data/test/active_record_doctor/detectors/missing_unique_indexes_test.rb

@@ -1,496 +0,0 @@
-# frozen_string_literal: true
-
-class ActiveRecordDoctor::Detectors::MissingUniqueIndexesTest < Minitest::Test
-  def test_missing_unique_index
-    create_table(:users) do |t|
-      t.string :email
-      t.index :email
-    end.define_model do
-      validates :email, uniqueness: true
-    end
-
-    assert_problems(<<~OUTPUT)
-      add a unique index on users(email) - validating uniqueness in TransientRecord::Models::User without an index can lead to duplicates
-    OUTPUT
-  end
-
-  def test_missing_unique_index_on_functional_index
-    skip if !(ActiveRecord::VERSION::STRING >= "5.0" && postgresql?)
-
-    create_table(:users) do |t|
-      t.string :email
-      t.index "lower(email)"
-    end.define_model do
-      validates :email, uniqueness: true
-    end
-
-    # Running the detector should NOT raise an error when a functional index
-    # is present. No need to assert anything -- the test is successful if no
-    # exception was raised.
-    run_detector
-  end
-
-  def test_validates_multiple_attributes
-    create_table(:users) do |t|
-      t.string :email
-      t.string :ref_token
-    end.define_model do
-      validates :email, :ref_token, uniqueness: true
-    end
-
-    assert_problems(<<~OUTPUT)
-      add a unique index on users(email) - validating uniqueness in TransientRecord::Models::User without an index can lead to duplicates
-      add a unique index on users(ref_token) - validating uniqueness in TransientRecord::Models::User without an index can lead to duplicates
-    OUTPUT
-  end
-
-  def test_present_unique_index
-    create_table(:users) do |t|
-      t.string :email
-      t.index :email, unique: true
-    end.define_model do
-      validates :email, uniqueness: true
-    end
-
-    refute_problems
-  end
-
-  def test_missing_unique_index_reported_only_on_base_class
-    create_table(:users) do |t|
-      t.string :type
-      t.string :email
-      t.string :name
-    end.define_model do
-      validates :email, uniqueness: true
-    end
-
-    define_model(:Client, TransientRecord::Models::User) do
-      validates :name, uniqueness: true
-    end
-
-    assert_problems(<<~OUTPUT)
-      add a unique index on users(email) - validating uniqueness in TransientRecord::Models::User without an index can lead to duplicates
-      add a unique index on users(name) - validating uniqueness in TransientRecord::Models::Client without an index can lead to duplicates
-    OUTPUT
-  end
-
-  def test_present_partial_unique_index
-    skip("MySQL doesn't support partial indexes") if mysql?
-
-    create_table(:users) do |t|
-      t.string :email
-      t.boolean :active
-      t.index :email, unique: true, where: "active"
-    end.define_model do
-      validates :email, uniqueness: true
-    end
-
-    assert_problems(<<~OUTPUT)
-      add a unique index on users(email) - validating uniqueness in TransientRecord::Models::User without an index can lead to duplicates
-    OUTPUT
-  end
-
-  def test_unique_index_with_extra_columns_with_scope
-    create_table(:users) do |t|
-      t.string :email
-      t.integer :company_id
-      t.integer :department_id
-      t.index [:company_id, :department_id, :email]
-    end.define_model do
-      validates :email, uniqueness: { scope: [:company_id, :department_id] }
-    end
-
-    assert_problems(<<~OUTPUT)
-      add a unique index on users(company_id, department_id, email) - validating uniqueness in TransientRecord::Models::User without an index can lead to duplicates
-    OUTPUT
-  end
-
-  def test_unique_index_with_exact_columns_with_scope
-    create_table(:users) do |t|
-      t.string :email
-      t.integer :company_id
-      t.integer :department_id
-      t.index [:company_id, :department_id, :email], unique: true
-    end.define_model do
-      validates :email, uniqueness: { scope: [:company_id, :department_id] }
-    end
-
-    refute_problems
-  end
-
-  def test_unique_index_with_fewer_columns_with_scope
-    create_table(:users) do |t|
-      t.string :email
-      t.integer :company_id
-      t.integer :department_id
-      t.index [:company_id, :department_id], unique: true
-    end.define_model do
-      validates :email, uniqueness: { scope: [:company_id, :department_id] }
-    end
-
-    refute_problems
-  end
-
-  def test_missing_unique_index_with_association_attribute
-    create_table(:users) do |t|
-      t.integer :account_id
-    end.define_model do
-      belongs_to :account
-      validates :account, uniqueness: true
-    end
-
-    assert_problems(<<~OUTPUT)
-      add a unique index on users(account_id) - validating uniqueness in TransientRecord::Models::User without an index can lead to duplicates
-    OUTPUT
-  end
-
-  def test_present_unique_index_with_association_attribute
-    create_table(:users) do |t|
-      t.integer :account_id
-      t.index :account_id, unique: true
-    end.define_model do
-      belongs_to :account
-      validates :account, uniqueness: true
-    end
-
-    refute_problems
-  end
-
-  def test_missing_unique_index_with_association_scope
-    create_table(:comments) do |t|
-      t.string :title
-      t.integer :commentable_id
-      t.string :commentable_type
-    end.define_model do
-      belongs_to :commentable, polymorphic: true
-      validates :title, uniqueness: { scope: :commentable }
-    end
-
-    assert_problems(<<~OUTPUT)
-      add a unique index on comments(commentable_type, commentable_id, title) - validating uniqueness in TransientRecord::Models::Comment without an index can lead to duplicates
-    OUTPUT
-  end
-
-  def test_present_unique_index_with_association_scope
-    create_table(:comments) do |t|
-      t.string :title
-      t.integer :commentable_id
-      t.string :commentable_type
-      t.index [:commentable_id, :commentable_type, :title], unique: true
-    end.define_model do
-      belongs_to :commentable, polymorphic: true
-      validates :title, uniqueness: { scope: :commentable }
-    end
-
-    refute_problems
-  end
-
-  def test_column_order_is_ignored
-    create_table(:users) do |t|
-      t.string :email
-      t.integer :organization_id
-
-      t.index [:email, :organization_id], unique: true
-    end.define_model do
-      validates :email, uniqueness: { scope: :organization_id }
-    end
-
-    refute_problems
-  end
-
-  def test_case_insensitive_unique_index_exists
-    skip("Expression indexes are not supported") if ActiveRecordDoctor::Utils.expression_indexes_unsupported?
-
-    create_table(:users) do |t|
-      t.string :email
-
-      t.index :email, unique: true
-    end.define_model do
-      validates :email, uniqueness: { case_sensitive: false }
-    end
-
-    assert_problems(<<~OUTPUT)
-      add a unique expression index on users(lower(email)) - validating case-insensitive uniqueness in TransientRecord::Models::User without an expression index can lead to duplicates (a regular unique index is not enough)
-    OUTPUT
-  end
-
-  def test_case_insensitive_non_unique_lower_index_exists
-    skip("Expression indexes are not supported") if ActiveRecordDoctor::Utils.expression_indexes_unsupported?
-
-    create_table(:users) do |t|
-      t.string :email
-    end.define_model do
-      validates :email, uniqueness: { case_sensitive: false }
-    end
-
-    # ActiveRecord < 5 does not support expression indexes.
-    ActiveRecord::Base.connection.execute(<<-SQL)
-      CREATE INDEX index_users_on_lower_email ON users ((lower(email)))
-    SQL
-
-    assert_problems(<<~OUTPUT)
-      add a unique expression index on users(lower(email)) - validating case-insensitive uniqueness in TransientRecord::Models::User without an expression index can lead to duplicates (a regular unique index is not enough)
-    OUTPUT
-  end
-
-  def test_case_insensitive_unique_lower_index_exists
-    skip("Expression indexes are not supported") if ActiveRecordDoctor::Utils.expression_indexes_unsupported?
-
-    create_table(:users) do |t|
-      t.string :email
-    end.define_model do
-      validates :email, uniqueness: { case_sensitive: false }
-    end
-
-    # ActiveRecord < 5 does not support expression indexes.
-    ActiveRecord::Base.connection.execute(<<-SQL)
-      CREATE UNIQUE INDEX index_users_on_lower_email ON users ((lower(email)))
-    SQL
-
-    refute_problems
-  end
-
-  def test_case_insensitive_compound_unique_index_exists
-    skip("Expression indexes are not supported") if ActiveRecordDoctor::Utils.expression_indexes_unsupported?
-
-    create_table(:users) do |t|
-      t.string :email
-      t.integer :organization_id
-      t.index [:email, :organization_id], unique: true
-    end.define_model do
-      validates :email, uniqueness: { scope: :organization_id, case_sensitive: false }
-    end
-
-    assert_problems(<<~OUTPUT)
-      add a unique expression index on users(organization_id, lower(email)) - validating case-insensitive uniqueness in TransientRecord::Models::User without an expression index can lead to duplicates (a regular unique index is not enough)
-    OUTPUT
-  end
-
-  def test_case_insensitive_compound_non_unique_lower_index_exists
-    skip("Expression indexes are not supported") if ActiveRecordDoctor::Utils.expression_indexes_unsupported?
-
-    create_table(:users) do |t|
-      t.string :email
-      t.integer :organization_id
-    end.define_model do
-      validates :email, uniqueness: { scope: :organization_id, case_sensitive: false }
-    end
-
-    ActiveRecord::Base.connection.execute(<<-SQL)
-      CREATE INDEX index_users_on_lower_email_and_organization_id ON users ((lower(email)), organization_id)
-    SQL
-
-    assert_problems(<<~OUTPUT)
-      add a unique expression index on users(organization_id, lower(email)) - validating case-insensitive uniqueness in TransientRecord::Models::User without an expression index can lead to duplicates (a regular unique index is not enough)
-    OUTPUT
-  end
-
-  def test_case_insensitive_compound_unique_lower_index_exists
-    skip("Expression indexes are not supported") if ActiveRecordDoctor::Utils.expression_indexes_unsupported?
-
-    create_table(:users) do |t|
-      t.string :email
-      t.integer :organization_id
-    end.define_model do
-      validates :email, uniqueness: { scope: :organization_id, case_sensitive: false }
-    end
-
-    ActiveRecord::Base.connection.execute(<<-SQL)
-      CREATE UNIQUE INDEX index_users_on_lower_email_and_organization_id ON users ((lower(email)), organization_id)
-    SQL
-
-    refute_problems
-  end
-
-  def test_conditions_is_skipped
-    assert_skipped(conditions: -> { where.not(email: nil) })
-  end
-
-  def test_if_is_skipped
-    assert_skipped(if: ->(_model) { true })
-  end
-
-  def test_unless_is_skipped
-    assert_skipped(unless: ->(_model) { true })
-  end
-
-  def test_skips_validator_without_attributes
-    create_table(:users) do |t|
-      t.string :email
-      t.index :email
-    end.define_model do
-      validates_with DummyValidator
-    end
-
-    refute_problems
-  end
-
-  def test_has_one_without_index
-    create_table(:users)
-      .define_model do
-        has_one :account, class_name: "TransientRecord::Models::Account"
-        has_one :account_history, through: :account, class_name: "TransientRecord::Models::Account"
-      end
-
-    create_table(:accounts) do |t|
-      t.integer :user_id
-    end.define_model do
-      has_one :account_history, class_name: "TransientRecord::Models::AccountHistory"
-    end
-
-    create_table(:account_histories) do |t|
-      t.integer :account_id
-    end.define_model do
-      belongs_to :account,  class_name: "TransientRecord::Models::Account"
-    end
-
-    assert_problems(<<~OUTPUT)
-      add a unique index on accounts(user_id) - using `has_one` in TransientRecord::Models::User without an index can lead to duplicates
-      add a unique index on account_histories(account_id) - using `has_one` in TransientRecord::Models::Account without an index can lead to duplicates
-    OUTPUT
-  end
-
-  def test_has_one_with_scope_and_without_index
-    create_table(:users)
-      .define_model do
-        has_one :last_comment, -> { order(created_at: :desc) }, class_name: "TransientRecord::Models::Comment"
-      end
-
-    create_table(:comments) do |t|
-      t.integer :user_id
-    end.define_model
-
-    refute_problems
-  end
-
-  def test_missing_has_one_unique_index_reported_only_on_base_class
-    create_table(:users) do |t|
-      t.string :type
-    end.define_model do
-      has_one :account, class_name: "TransientRecord::Models::Account"
-    end
-
-    define_model(:Client, TransientRecord::Models::User)
-
-    create_table(:accounts) do |t|
-      t.integer :user_id
-    end.define_model
-
-    assert_problems(<<~OUTPUT)
-      add a unique index on accounts(user_id) - using `has_one` in TransientRecord::Models::User without an index can lead to duplicates
-    OUTPUT
-  end
-
-  def test_has_one_with_index
-    create_table(:users)
-      .define_model do
-        has_one :account, class_name: "TransientRecord::Models::Account"
-      end
-
-    create_table(:accounts) do |t|
-      t.integer :user_id, index: { unique: true }
-    end.define_model
-
-    refute_problems
-  end
-
-  def test_polymorphic_has_one_without_index
-    create_table(:users)
-      .define_model do
-        has_one :account, as: :accountable
-      end
-
-    create_table(:accounts) do |t|
-      t.belongs_to :accountable, polymorphic: true, index: false
-    end.define_model do
-      belongs_to :accountable, polymorphic: true
-    end
-
-    assert_problems(<<~OUTPUT)
-      add a unique index on accounts(accountable_type, accountable_id) - using `has_one` in TransientRecord::Models::User without an index can lead to duplicates
-    OUTPUT
-  end
-
-  def test_polymorphic_has_one_with_index
-    create_table(:users)
-      .define_model do
-        has_one :account, as: :accountable
-      end
-
-    create_table(:accounts) do |t|
-      t.belongs_to :accountable, polymorphic: true, index: { unique: true }
-    end.define_model do
-      belongs_to :accountable, polymorphic: true
-    end
-
-    refute_problems
-  end
-
-  def test_config_ignore_models
-    create_table(:users) do |t|
-      t.string :email
-    end.define_model do
-      validates :email, uniqueness: true
-    end
-
-    config_file(<<-CONFIG)
-      ActiveRecordDoctor.configure do |config|
-        config.detector :missing_unique_indexes,
-          ignore_models: ["TransientRecord::Models::User"]
-      end
-    CONFIG
-
-    refute_problems
-  end
-
-  def test_global_ignore_models
-    create_table(:users) do |t|
-      t.string :email
-    end.define_model do
-      validates :email, uniqueness: true
-    end
-
-    config_file(<<-CONFIG)
-      ActiveRecordDoctor.configure do |config|
-        config.global :ignore_models, ["TransientRecord::Models::User"]
-      end
-    CONFIG
-
-    refute_problems
-  end
-
-  def test_config_ignore_columns
-    create_table(:users) do |t|
-      t.string :email
-      t.integer :role
-    end.define_model do
-      validates :email, :role, uniqueness: { scope: :organization_id }
-    end
-
-    config_file(<<-CONFIG)
-      ActiveRecordDoctor.configure do |config|
-        config.detector :missing_unique_indexes,
-          ignore_columns: ["TransientRecord::Models::User(organization_id, email)", "TransientRecord::Models::User(organization_id, role)"]
-      end
-    CONFIG
-
-    refute_problems
-  end
-
-  class DummyValidator < ActiveModel::Validator
-    def validate(record)
-    end
-  end
-
-  private
-
-  def assert_skipped(options)
-    create_table(:users) do |t|
-      t.string :email
-    end.define_model do
-      validates :email, uniqueness: options
-    end
-
-    refute_problems
-  end
-end

data/test/active_record_doctor/detectors/short_primary_key_type_test.rb

@@ -1,77 +0,0 @@
-# frozen_string_literal: true
-
-class ActiveRecordDoctor::Detectors::ShortPrimaryKeyTypeTest < Minitest::Test
-  def setup
-    @connection = ActiveRecord::Base.connection
-    @connection.enable_extension("uuid-ossp") if postgresql?
-    super
-  end
-
-  def teardown
-    @connection.disable_extension("uuid-ossp") if postgresql?
-    super
-  end
-
-  def test_short_integer_primary_key_is_reported
-    create_table(:companies, id: :int)
-
-    # In Rails 4.2 and MySQL primary key is not created due to a bug
-    if mysql? && ActiveRecord::VERSION::STRING < "5.0"
-      @connection.execute("ALTER TABLE companies ADD PRIMARY KEY(id)")
-    end
-
-    assert_problems(<<~OUTPUT)
-      change the type of companies.id to bigint
-    OUTPUT
-  end
-
-  def test_non_integer_and_non_uuid_primary_key_is_not_reported
-    create_table(:companies, id: :string, primary_key: :uuid)
-    refute_problems
-  end
-
-  def test_long_integer_primary_key_is_not_reported
-    create_table(:companies, id: :bigint)
-    refute_problems
-  end
-
-  def test_uuid_primary_key_is_not_reported
-    skip unless postgresql?
-
-    create_table(:companies, id: :uuid)
-    refute_problems
-  end
-
-  def test_no_primary_key_is_not_reported
-    create_table(:companies, id: false) do |t|
-      t.string :name, null: false
-    end
-
-    refute_problems
-  end
-
-  def test_config_ignore_tables
-    create_table(:companies, id: :integer)
-
-    config_file(<<-CONFIG)
-      ActiveRecordDoctor.configure do |config|
-        config.detector :short_primary_key_type,
-          ignore_tables: ["companies"]
-      end
-    CONFIG
-
-    refute_problems
-  end
-
-  def test_global_ignore_tables
-    create_table(:companies, id: :integer)
-
-    config_file(<<-CONFIG)
-      ActiveRecordDoctor.configure do |config|
-        config.global :ignore_tables, ["companies"]
-      end
-    CONFIG
-
-    refute_problems
-  end
-end

data/test/active_record_doctor/detectors/undefined_table_references_test.rb

@@ -1,55 +0,0 @@
-# frozen_string_literal: true
-
-class ActiveRecordDoctor::Detectors::UndefinedTableReferencesTest < Minitest::Test
-  def test_model_backed_by_table
-    create_table(:users) do
-    end.define_model do
-    end
-
-    refute_problems
-  end
-
-  def test_model_backed_by_non_existent_table
-    define_model(:User)
-
-    assert_problems(<<~OUTPUT)
-      TransientRecord::Models::User references a non-existent table or view named users
-    OUTPUT
-  end
-
-  def test_model_backed_by_view
-    # We replace the underlying table with a view. The view doesn't have to be
-    # backed by an actual table - it can simply return a predefined tuple.
-    ActiveRecord::Base.connection.execute("CREATE VIEW users AS SELECT 1")
-    define_model(:User)
-
-    refute_problems
-  ensure
-    ActiveRecord::Base.connection.execute("DROP VIEW users")
-  end
-
-  def test_config_ignore_tables
-    define_model(:User)
-
-    config_file(<<-CONFIG)
-      ActiveRecordDoctor.configure do |config|
-        config.detector :undefined_table_references,
-          ignore_models: ["TransientRecord::Models::User"]
-      end
-    CONFIG
-
-    refute_problems
-  end
-
-  def test_global_ignore_tables
-    define_model(:User)
-
-    config_file(<<-CONFIG)
-      ActiveRecordDoctor.configure do |config|
-        config.global :ignore_models, ["TransientRecord::Models::User"]
-      end
-    CONFIG
-
-    refute_problems
-  end
-end