active_record_doctor 1.11.0 → 1.13.0

data/test/active_record_doctor/detectors/missing_unique_indexes_test.rb

@@ -1,327 +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 the model 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 the model without an index can lead to duplicates
-      add a unique index on users(ref_token) - validating uniqueness in the model 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_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 the model 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 the model 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 the model 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 the model 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_conditions_is_skipped
-    assert_skipped(conditions: -> { where.not(email: nil) })
-  end
-
-  def test_case_insensitive_is_skipped
-    assert_skipped(case_sensitive: false)
-  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 the TransientRecord::Models::User model without an index can lead to duplicates
-      add a unique index on account_histories(account_id) - using `has_one` in the TransientRecord::Models::Account model 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_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_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,72 +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_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

data/test/active_record_doctor/detectors/unindexed_deleted_at_test.rb

@@ -1,177 +0,0 @@
-# frozen_string_literal: true
-
-class ActiveRecordDoctor::Detectors::UnindexedDeletedAtTest < Minitest::Test
-  def test_indexed_deleted_at_is_not_reported
-    skip("MySQL doesn't support partial indexes") if mysql?
-
-    create_table(:users) do |t|
-      t.string :first_name
-      t.string :last_name
-      t.datetime :deleted_at
-      t.index [:first_name, :last_name],
-        name: "index_profiles_on_first_name_and_last_name",
-        where: "deleted_at IS NULL"
-      t.index [:last_name],
-        name: "index_deleted_profiles_on_last_name",
-        where: "deleted_at IS NOT NULL"
-    end
-
-    refute_problems
-  end
-
-  def test_unindexed_deleted_at_is_reported
-    skip("MySQL doesn't support partial indexes") if mysql?
-
-    create_table(:users) do |t|
-      t.string :first_name
-      t.string :last_name
-      t.datetime :deleted_at
-      t.index [:first_name, :last_name],
-        name: "index_profiles_on_first_name_and_last_name"
-    end
-
-    assert_problems(<<~OUTPUT)
-      consider adding `WHERE deleted_at IS NULL` or `WHERE deleted_at IS NOT NULL` to index_profiles_on_first_name_and_last_name - a partial index can speed lookups of soft-deletable models
-    OUTPUT
-  end
-
-  def test_indexed_discarded_at_is_not_reported
-    skip("MySQL doesn't support partial indexes") if mysql?
-
-    create_table(:users) do |t|
-      t.string :first_name
-      t.string :last_name
-      t.datetime :discarded_at
-      t.index [:first_name, :last_name],
-        name: "index_profiles_on_first_name_and_last_name",
-        where: "discarded_at IS NULL"
-      t.index [:last_name],
-        name: "index_discarded_profiles_on_last_name",
-        where: "discarded_at IS NOT NULL"
-    end
-
-    refute_problems
-  end
-
-  def test_unindexed_discarded_at_is_reported
-    skip("MySQL doesn't support partial indexes") if mysql?
-
-    create_table(:users) do |t|
-      t.string :first_name
-      t.string :last_name
-      t.datetime :discarded_at
-      t.index [:first_name, :last_name],
-        name: "index_profiles_on_first_name_and_last_name"
-    end
-
-    assert_problems(<<~OUTPUT)
-      consider adding `WHERE discarded_at IS NULL` or `WHERE discarded_at IS NOT NULL` to index_profiles_on_first_name_and_last_name - a partial index can speed lookups of soft-deletable models
-    OUTPUT
-  end
-
-  def test_config_ignore_tables
-    skip("MySQL doesn't support partial indexes") if mysql?
-
-    create_table(:users) do |t|
-      t.string :first_name
-      t.string :last_name
-      t.datetime :discarded_at
-      t.index [:first_name, :last_name],
-        name: "index_profiles_on_first_name_and_last_name"
-    end
-
-    config_file(<<-CONFIG)
-      ActiveRecordDoctor.configure do |config|
-        config.detector :unindexed_deleted_at,
-          ignore_tables: ["users"]
-      end
-    CONFIG
-
-    refute_problems
-  end
-
-  def test_global_ignore_tables
-    skip("MySQL doesn't support partial indexes") if mysql?
-
-    create_table(:users) do |t|
-      t.string :first_name
-      t.string :last_name
-      t.datetime :discarded_at
-      t.index [:first_name, :last_name],
-        name: "index_profiles_on_first_name_and_last_name"
-    end
-
-    config_file(<<-CONFIG)
-      ActiveRecordDoctor.configure do |config|
-        config.global :ignore_tables, ["users"]
-      end
-    CONFIG
-
-    refute_problems
-  end
-
-  def test_config_ignore_columns
-    skip("MySQL doesn't support partial indexes") if mysql?
-
-    create_table(:users) do |t|
-      t.string :first_name
-      t.string :last_name
-      t.datetime :discarded_at
-      t.index [:first_name, :last_name],
-        name: "index_profiles_on_first_name_and_last_name"
-    end
-
-    config_file(<<-CONFIG)
-      ActiveRecordDoctor.configure do |config|
-        config.detector :unindexed_deleted_at,
-          ignore_columns: ["users.discarded_at"]
-      end
-    CONFIG
-
-    refute_problems
-  end
-
-  def test_config_ignore_indexes
-    skip("MySQL doesn't support partial indexes") if mysql?
-
-    create_table(:users) do |t|
-      t.string :first_name
-      t.string :last_name
-      t.datetime :discarded_at
-      t.index [:first_name, :last_name],
-        name: "index_profiles_on_first_name_and_last_name"
-    end
-
-    config_file(<<-CONFIG)
-      ActiveRecordDoctor.configure do |config|
-        config.detector :unindexed_deleted_at,
-          ignore_indexes: ["index_profiles_on_first_name_and_last_name"]
-      end
-    CONFIG
-
-    refute_problems
-  end
-
-  def test_config_column_names
-    skip("MySQL doesn't support partial indexes") if mysql?
-
-    create_table(:users) do |t|
-      t.string :first_name
-      t.string :last_name
-      t.datetime :obliverated_at
-      t.index [:first_name, :last_name],
-        name: "index_profiles_on_first_name_and_last_name"
-    end
-
-    config_file(<<-CONFIG)
-      ActiveRecordDoctor.configure do |config|
-        config.detector :unindexed_deleted_at,
-          column_names: ["obliverated_at"]
-      end
-    CONFIG
-
-    assert_problems(<<~OUTPUT)
-      consider adding `WHERE obliverated_at IS NULL` or `WHERE obliverated_at IS NOT NULL` to index_profiles_on_first_name_and_last_name - a partial index can speed lookups of soft-deletable models
-    OUTPUT
-  end
-end

data/test/active_record_doctor/detectors/unindexed_foreign_keys_test.rb

@@ -1,78 +0,0 @@
-# frozen_string_literal: true
-
-class ActiveRecordDoctor::Detectors::UnindexedForeignKeysTest < Minitest::Test
-  def test_unindexed_foreign_key_is_reported
-    skip("MySQL always indexes foreign keys") if mysql?
-
-    create_table(:companies)
-    create_table(:users) do |t|
-      t.references :company, foreign_key: true, index: false
-    end
-
-    assert_problems(<<~OUTPUT)
-      add an index on users.company_id - foreign keys are often used in database lookups and should be indexed for performance reasons
-    OUTPUT
-  end
-
-  def test_indexed_foreign_key_is_not_reported
-    create_table(:companies)
-    create_table(:users) do |t|
-      t.references :company, foreign_key: true, index: true
-    end
-
-    refute_problems
-  end
-
-  def test_config_ignore_tables
-    skip("MySQL always indexes foreign keys") if mysql?
-
-    create_table(:companies)
-    create_table(:users) do |t|
-      t.references :company, foreign_key: true, index: false
-    end
-
-    config_file(<<-CONFIG)
-      ActiveRecordDoctor.configure do |config|
-        config.detector :unindexed_foreign_keys,
-          ignore_tables: ["users"]
-      end
-    CONFIG
-
-    refute_problems
-  end
-
-  def test_global_ignore_tables
-    skip("MySQL always indexes foreign keys") if mysql?
-
-    create_table(:companies)
-    create_table(:users) do |t|
-      t.references :company, foreign_key: true, index: false
-    end
-
-    config_file(<<-CONFIG)
-      ActiveRecordDoctor.configure do |config|
-        config.global :ignore_tables, ["users"]
-      end
-    CONFIG
-
-    refute_problems
-  end
-
-  def test_config_ignore_columns
-    skip("MySQL always indexes foreign keys") if mysql?
-
-    create_table(:companies)
-    create_table(:users) do |t|
-      t.references :company, foreign_key: true, index: false
-    end
-
-    config_file(<<-CONFIG)
-      ActiveRecordDoctor.configure do |config|
-        config.detector :unindexed_foreign_keys,
-          ignore_columns: ["users.company_id"]
-      end
-    CONFIG
-
-    refute_problems
-  end
-end