active_record_doctor 1.12.0 → 1.14.0

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,116 +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_unindexed_foreign_key_with_nonstandard_name_is_reported
-    skip("MySQL always indexes foreign keys") if mysql?
-
-    create_table(:companies)
-    create_table(:users) do |t|
-      t.integer :company
-      t.foreign_key :companies, column: :company
-    end
-
-    assert_problems(<<~OUTPUT)
-      add an index on users(company) - foreign keys are often used in database lookups and should be indexed for performance reasons
-    OUTPUT
-  end
-
-  def test_unindexed_polymorphic_foreign_key_is_reported
-    create_table(:notes) do |t|
-      t.integer :notable_id
-      t.string :notable_type
-    end
-
-    assert_problems(<<~OUTPUT)
-      add an index on notes(notable_type, notable_id) - foreign keys are often used in database lookups and should be indexed for performance reasons
-    OUTPUT
-  end
-
-  def test_indexed_polymorphic_foreign_key_is_not_reported
-    create_table(:notes) do |t|
-      t.string :title
-      t.integer :notable_id
-      t.string :notable_type
-
-      # Includes additional column except `notable`
-      t.index [:notable_type, :notable_id, :title]
-    end
-
-    refute_problems
-  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

data/test/active_record_doctor/runner_test.rb

@@ -1,41 +0,0 @@
-# frozen_string_literal: true
-
-class ActiveRecordDoctor::RunnerTest < Minitest::Test
-  def setup
-    @io = StringIO.new
-    @runner = ActiveRecordDoctor::Runner.new(
-      config: load_config,
-      logger: ActiveRecordDoctor::Logger::Dummy.new,
-      io: @io
-    )
-  end
-
-  def test_run_one_raises_on_unknown_detectors
-    assert_raises(KeyError) do
-      @runner.run_one(:performance_issues)
-    end
-  end
-
-  def test_run_all_returns_true_when_no_errors
-    assert(@runner.run_all)
-    assert(@io.string.blank?)
-  end
-
-  def test_run_all_returns_false_when_errors
-    # Create a model without its underlying table to trigger an error.
-    define_model(:User)
-
-    refute(@runner.run_all)
-    refute(@io.string.blank?)
-  end
-
-  def test_help_prints_help
-    ActiveRecordDoctor.detectors.each do |name, _|
-      @io.truncate(0)
-
-      @runner.help(name)
-
-      refute(@io.string.blank?, "expected help for #{name}")
-    end
-  end
-end

data/test/generators/active_record_doctor/add_indexes/add_indexes_generator_test.rb

@@ -1,141 +0,0 @@
-# frozen_string_literal: true
-
-require "rails/generators"
-
-require "generators/active_record_doctor/add_indexes/add_indexes_generator"
-
-class ActiveRecordDoctor::AddIndexesGeneratorTest < Minitest::Test
-  TIMESTAMP = Time.new(2021, 2, 1, 13, 15, 30)
-
-  def test_create_migrations
-    create_table(:notes) do |t|
-      t.integer :notable_id, null: false
-      t.string :notable_type, null: false
-    end
-    create_table(:users) do |t|
-      t.integer :organization_id, null: false
-      t.integer :account_id, null: false
-    end
-    create_table(:organizations) do |t|
-      t.integer :owner_id
-    end
-
-    Dir.mktmpdir do |dir|
-      Dir.chdir(dir)
-
-      path = File.join(dir, "indexes.txt")
-      File.write(path, <<~INDEXES)
-        add an index on users(organization_id) - foreign keys are often used in database lookups and should be indexed for performance reasons
-        add an index on users(account_id) - foreign keys are often used in database lookups and should be indexed for performance reasons
-        add an index on organizations(owner_id) - foreign keys are often used in database lookups and should be indexed for performance reasons
-        add an index on notes(notable_type, notable_id) - foreign keys are often used in database lookups and should be indexed for performance reasons
-      INDEXES
-
-      capture_io do
-        Time.stub(:now, TIMESTAMP) do
-          ActiveRecordDoctor::AddIndexesGenerator.start([path])
-
-          load(File.join("db", "migrate", "20210201131530_index_foreign_keys_in_users.rb"))
-          IndexForeignKeysInUsers.migrate(:up)
-
-          load(File.join("db", "migrate", "20210201131531_index_foreign_keys_in_organizations.rb"))
-          IndexForeignKeysInOrganizations.migrate(:up)
-
-          load(File.join("db", "migrate", "20210201131532_index_foreign_keys_in_notes.rb"))
-          IndexForeignKeysInNotes.migrate(:up)
-
-          ::Object.send(:remove_const, :IndexForeignKeysInUsers)
-          ::Object.send(:remove_const, :IndexForeignKeysInOrganizations)
-          ::Object.send(:remove_const, :IndexForeignKeysInNotes)
-        end
-      end
-
-      assert_indexes([
-        ["notes", ["notable_type", "notable_id"]],
-        ["users", ["organization_id"]],
-        ["users", ["account_id"]],
-        ["organizations", ["owner_id"]]
-      ])
-
-      assert_equal(5, Dir.entries("./db/migrate").size)
-    end
-  end
-
-  def test_create_migrations_raises_when_malformed_inpout
-    Tempfile.create do |file|
-      file.write(<<~INDEXES)
-        add an index on users() - foreign keys are often used in database lookups and should be indexed for performance reasons
-      INDEXES
-      file.flush
-
-      assert_raises(RuntimeError) do
-        capture_io do
-          ActiveRecordDoctor::AddIndexesGenerator.start([file.path])
-        end
-      end
-    end
-  end
-
-  def test_create_migrations_skips_blank_lines
-    Dir.mktmpdir do |dir|
-      Dir.chdir(dir)
-
-      path = File.join(dir, "indexes.txt")
-      File.write(path, "\n")
-
-      capture_io do
-        Time.stub(:now, TIMESTAMP) do
-          # Not raising an exception is considered success.
-          ActiveRecordDoctor::AddIndexesGenerator.start([path])
-        end
-      end
-    end
-  end
-
-  def test_create_migrations_truncates_long_index_names
-    # Both the table and column names must be quite long. Otherwise, the
-    # we might reach table or column name length limits and fail to generate an
-    # index name that's long enough.
-    create_table(:organizations_migrated_from_legacy_app) do |t|
-      t.integer :legacy_owner_id_compatible_with_v1_to_v8
-    end
-
-    Dir.mktmpdir do |dir|
-      Dir.chdir(dir)
-
-      path = File.join(dir, "indexes.txt")
-      File.write(path, <<~INDEXES)
-        add an index on organizations_migrated_from_legacy_app(legacy_owner_id_compatible_with_v1_to_v8) - foreign keys are often used in database lookups and should be indexed for performance reasons
-      INDEXES
-
-      capture_io do
-        Time.stub(:now, TIMESTAMP) do
-          # If no exceptions are raised then we consider this to be a success.
-          ActiveRecordDoctor::AddIndexesGenerator.start([path])
-
-          load(File.join(
-            "db",
-            "migrate",
-            "20210201131530_index_foreign_keys_in_organizations_migrated_from_legacy_app.rb"
-          ))
-          ::IndexForeignKeysInOrganizationsMigratedFromLegacyApp.migrate(:up)
-
-          ::Object.send(:remove_const, :IndexForeignKeysInOrganizationsMigratedFromLegacyApp)
-        end
-      end
-    end
-  end
-
-  private
-
-  def assert_indexes(expected_indexes)
-    actual_indexes =
-      ActiveRecord::Base.connection.tables.map do |table|
-        ActiveRecord::Base.connection.indexes(table).map do |index|
-          [index.table, index.columns]
-        end
-      end.flatten(1)
-
-    assert_equal(expected_indexes.sort, actual_indexes.sort)
-  end
-end

data/test/setup.rb

@@ -1,124 +0,0 @@
-# frozen_string_literal: true
-
-# Configure Active Record.
-
-# We must import "uri" explicitly as otherwsie URI won't be accessible in
-# Ruby 2.7.2 / Rails 6.
-require "uri"
-
-require "active_record"
-require "pg"
-require "mysql2"
-
-adapter = ENV.fetch("DATABASE_ADAPTER")
-ActiveRecord::Base.establish_connection(
-  adapter: adapter,
-  host: ENV["DATABASE_HOST"],
-  port: ENV["DATABASE_PORT"],
-  username: ENV["DATABASE_USERNAME"],
-  password: ENV["DATABASE_PASSWORD"],
-  database: "active_record_doctor_test"
-)
-
-puts "Using #{adapter}"
-
-# We need to call #connection to enfore Active Record to actually establish
-# the connection.
-ActiveRecord::Base.connection
-
-# Load Active Record Doctor.
-require "active_record_doctor"
-
-# Configure the test suite.
-require "minitest"
-require "minitest/autorun"
-require "minitest/fork_executor"
-require "transient_record"
-
-# Filter out Minitest backtrace while allowing backtrace from other libraries
-# to be shown.
-Minitest.backtrace_filter = Minitest::BacktraceFilter.new
-
-# Uncomment in case there's test case interference.
-Minitest.parallel_executor = Minitest::ForkExecutor.new
-
-# Prepare the test class.
-class Minitest::Test
-  include TransientRecord
-
-  def setup
-    # Delete remnants (models and tables) of previous test case runs.
-    TransientRecord.cleanup
-  end
-
-  def teardown
-    @config_path = nil
-
-    if @previous_dir
-      Dir.chdir(@previous_dir)
-      @previous_dir = nil
-    end
-
-    # Ensure all remnants of previous test runs, most likely in form of tables,
-    # are removed.
-    TransientRecord.cleanup
-  end
-
-  private
-
-  attr_reader :config_path
-
-  def config_file(content)
-    @previous_dir = Dir.pwd
-
-    directory = Dir.mktmpdir("active_record_doctor")
-    @config_path = File.join(directory, ".active_record_doctor")
-    File.write(@config_path, content)
-    Dir.chdir(directory)
-
-    @config_path
-  end
-
-  def postgresql?
-    ActiveRecord::Base.connection.adapter_name == "PostgreSQL"
-  end
-
-  def mysql?
-    ActiveRecord::Base.connection.adapter_name == "Mysql2"
-  end
-
-  def detector_name
-    self.class.name.sub(/Test$/, "").demodulize.underscore.to_sym
-  end
-
-  def run_detector
-    io = StringIO.new
-    runner = ActiveRecordDoctor::Runner.new(
-      config: load_config,
-      logger: ActiveRecordDoctor::Logger::Dummy.new,
-      io: io
-    )
-    success = runner.run_one(detector_name)
-    [success, io.string]
-  end
-
-  def load_config
-    ActiveRecordDoctor.load_config_with_defaults(@config_path)
-  end
-
-  def assert_problems(expected_output)
-    success, output = run_detector
-    assert_equal(sort_lines(expected_output), sort_lines(output))
-    refute(success, "Expected the detector to return failure.")
-  end
-
-  def refute_problems(expected_output = "")
-    success, output = run_detector
-    assert_equal(sort_lines(expected_output), sort_lines(output))
-    assert(success, "Expected the detector to return success.")
-  end
-
-  def sort_lines(string)
-    string.split("\n").sort
-  end
-end