active_record_doctor 1.8.0 → 1.9.0.rc1

data/test/active_record_doctor/detectors/unindexed_deleted_at_test.rb

@@ -27,10 +27,9 @@ class ActiveRecordDoctor::Detectors::UnindexedDeletedAtTest < Minitest::Test
         name: "index_profiles_on_first_name_and_last_name"
     end
 
-    assert_problems(<<OUTPUT)
-The following indexes should include `deleted_at IS NULL`:
-  index_profiles_on_first_name_and_last_name
-OUTPUT
+    assert_problems(<<~OUTPUT)
+      consider adding `WHERE deleted_at IS 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
@@ -59,9 +58,114 @@ OUTPUT
         name: "index_profiles_on_first_name_and_last_name"
     end
 
-    assert_problems(<<OUTPUT)
-The following indexes should include `deleted_at IS NULL`:
-  index_profiles_on_first_name_and_last_name
-OUTPUT
+    assert_problems(<<~OUTPUT)
+      consider adding `WHERE discarded_at IS 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` 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

@@ -9,10 +9,9 @@ class ActiveRecordDoctor::Detectors::UnindexedForeignKeysTest < Minitest::Test
       t.references :company, foreign_key: true, index: false
     end
 
-    assert_problems(<<OUTPUT)
-The following foreign keys should be indexed for performance reasons:
-  users company_id
-OUTPUT
+    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
@@ -23,4 +22,57 @@ OUTPUT
 
     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

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+class ActiveRecordDoctor::RunnerTest < Minitest::Test
+  def test_run_one_raises_on_unknown_detectors
+    io = StringIO.new
+    runner = ActiveRecordDoctor::Runner.new(load_config, io)
+
+    assert_raises(KeyError) do
+      runner.run_one(:performance_issues)
+    end
+  end
+
+  def test_run_all_returns_true_when_no_errors
+    io = StringIO.new
+    runner = ActiveRecordDoctor::Runner.new(load_config, io)
+
+    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.
+    create_model(:User)
+
+    io = StringIO.new
+    runner = ActiveRecordDoctor::Runner.new(load_config, io)
+
+    refute(runner.run_all)
+    refute(io.string.blank?)
+  end
+
+  def test_help_prints_help
+    ActiveRecordDoctor.detectors.each do |name, _|
+      io = StringIO.new
+      runner = ActiveRecordDoctor::Runner.new(load_config, io)
+
+      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

@@ -0,0 +1,131 @@
+# 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(: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
+      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)
+
+          ::Object.send(:remove_const, :IndexForeignKeysInUsers)
+          ::Object.send(:remove_const, :IndexForeignKeysInOrganizations)
+        end
+      end
+
+      assert_indexes([
+        ["users", ["organization_id"]],
+        ["users", ["account_id"]],
+        ["organizations", ["owner_id"]]
+      ])
+
+      assert_equal(4, 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/model_factory.rb

@@ -1,7 +1,19 @@
 # frozen_string_literal: true
 
 module ModelFactory
-  def self.cleanup
+  def create_table(*args, &block)
+    ModelFactory.create_table(*args, &block)
+  end
+
+  def create_model(*args, &block)
+    ModelFactory.create_model(*args, &block)
+  end
+
+  def cleanup_models
+    ModelFactory.cleanup_models
+  end
+
+  def self.cleanup_models
     delete_models
     drop_all_tables
     GC.start
@@ -10,27 +22,53 @@ module ModelFactory
   def self.drop_all_tables
     connection = ActiveRecord::Base.connection
     loop do
-      before = connection.tables.size
+      before = connection.data_sources.size
       break if before.zero?
 
-      attempt_drop_all_tables(connection)
-      after = connection.tables.size
+      try_drop_all_tables_and_views(connection)
+      remaining_data_sources = connection.data_sources
+      after = remaining_data_sources.size
 
+      # rubocop:disable Style/Next
       if before == after
-        raise("cannot delete temporary tables - most likely due to failing constraints")
+        raise(<<~ERROR)
+          Cannot delete temporary tables - most likely due to failing constraints. Remaining tables and views:
+
+          #{remaining_data_sources.join("\n")}
+        ERROR
+      end
+      # rubocop:enable Style/Next
+    end
+  end
+
+  def self.try_drop_all_tables_and_views(connection)
+    connection.data_sources.each do |table_name|
+      try_drop_table(connection, table_name) || try_drop_view(connection, table_name)
+    end
+  end
+
+  def self.try_drop_table(connection, table_name)
+    ActiveRecord::Migration.suppress_messages do
+      begin
+        connection.drop_table(table_name, force: :cascade)
+        true
+      rescue ActiveRecord::InvalidForeignKey, ActiveRecord::StatementInvalid
+        # The table cannot be dropped due to foreign key constraints so
+        # we'll try to drop it on another attempt.
+        false
       end
     end
   end
 
-  def self.attempt_drop_all_tables(connection)
-    connection.tables.each do |table_name|
-      ActiveRecord::Migration.suppress_messages do
-        begin
-          connection.drop_table(table_name, force: :cascade)
-        rescue ActiveRecord::InvalidForeignKey, ActiveRecord::StatementInvalid
-          # The table cannot be dropped due to foreign key constraints so
-          # we'll try to drop it on another attempt.
-        end
+  def self.try_drop_view(connection, view_name)
+    ActiveRecord::Migration.suppress_messages do
+      begin
+        connection.execute("DROP VIEW #{view_name}")
+        true
+      rescue ActiveRecord::InvalidForeignKey, ActiveRecord::StatementInvalid
+        # The table cannot be dropped due to foreign key constraints so
+        # we'll try to drop it on another attempt.
+        false
       end
     end
   end
@@ -39,23 +77,35 @@ module ModelFactory
     Models.empty
   end
 
-  def self.create_table(table_name, &block)
+  def self.create_table(table_name, options = {}, &block)
     table_name = table_name.to_sym
     ActiveRecord::Migration.suppress_messages do
-      ActiveRecord::Migration.create_table(table_name, &block)
+      ActiveRecord::Migration.create_table(table_name, **options, &block)
     end
-
     # Return a proxy object allowing the caller to chain #create_model
     # right after creating a table so that it can be followed by the model
     # definition.
     ModelDefinitionProxy.new(table_name)
   end
 
-  def self.create_model(table_name, &block)
-    table_name = table_name.to_sym
-    klass = Class.new(ActiveRecord::Base, &block)
-    klass_name = table_name.to_s.classify
-    Models.const_set(klass_name, klass)
+  def self.create_model(model_name, base_class = ActiveRecord::Base, &block)
+    model_name = model_name.to_sym
+
+    # Normally, when a class is defined via `class MyClass < MySuperclass` the
+    # .name class method returns the name of the class when called from within
+    # the class body. However, anonymous classes defined via Class.new DO NOT
+    # HAVE NAMES. They're assigned names when they're assigned to a constant.
+    # If we evaluated the class body, passed via block here, in the class
+    # definition below then some macros would break
+    # (e.g. has_and_belongs_to_many) due to nil name.
+    #
+    # We solve the problem by defining an empty model class first, assigning to
+    # a constant to ensure a name is assigned, and then reopening the class to
+    # give it a non-trivial body.
+    klass = Class.new(base_class)
+    Models.const_set(model_name, klass)
+
+    klass.class_eval(&block) if block_given?
   end
 
   class ModelDefinitionProxy
@@ -64,7 +114,7 @@ module ModelFactory
     end
 
     def create_model(&block)
-      ModelFactory.create_model(@table_name, &block)
+      ModelFactory.create_model(@table_name.to_s.classify, &block)
     end
   end
 

data/test/setup.rb

@@ -7,45 +7,25 @@
 require "uri"
 
 require "active_record"
+require "pg"
+require "mysql2"
 
-# Connect to the database defined in the URL.
-case ENV["DATABASE"]
-when "postgresql"
-  require "pg"
-  DEFAULT_DATABASE_URL = "postgres:///active_record_doctor_test"
-when "mysql"
-  require "mysql2"
-  DEFAULT_DATABASE_URL = "mysql2:///active_record_doctor_test"
-when nil
-  # rubocop:disable Style/StderrPuts
-  $stderr.puts(<<ERROR)
-The DATABASE environment variable is not set. It must be set before running the
-test suite. Valid values are "mysql" and "postgresql".
-ERROR
-  # rubocop:enable Style/StderrPuts
-  exit(1)
-else raise("unrecognized database #{ENV['DATABASE']}")
-end
-ActiveRecord::Base.establish_connection(ENV.fetch("DATABASE_URL", DEFAULT_DATABASE_URL))
+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
 
-# We need to mock Rails because some detectors depend on .eager_load! This must
-# happen AFTER loading active_record_doctor as otherwise it'd attempt to
-# install a Railtie.
-module Rails
-  class TestApplication
-    def eager_load!
-    end
-  end
-
-  def self.application
-    @application ||= TestApplication.new
-  end
-end
-
 # Load Active Record Doctor.
 require "active_record_doctor"
 
@@ -53,23 +33,52 @@ require "active_record_doctor"
 require "minitest"
 require "minitest/autorun"
 require "minitest/fork_executor"
-
 require_relative "model_factory"
 
+# 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 ModelFactory
+
   def setup
-    # Ensure all remnants of previous test runs, most likely in form of tables,
-    # are removed.
-    ModelFactory.cleanup
+    # Delete remnants (models and tables) of previous test case runs.
+    cleanup_models
   end
 
   def teardown
-    ModelFactory.cleanup
+    @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.
+    cleanup_models
   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
@@ -78,49 +87,30 @@ class Minitest::Test
     ActiveRecord::Base.connection.adapter_name == "Mysql2"
   end
 
-  def create_table(*args, &block)
-    ModelFactory.create_table(*args, &block)
+  def detector_name
+    self.class.name.sub(/Test$/, "").demodulize.underscore.to_sym
   end
 
-  def create_model(*args, &block)
-    ModelFactory.create_model(*args, &block)
-  end
-
-  # Return the detector class under test.
-  def detector_class
-    self.class.name.sub(/Test$/, "").constantize
-  end
-
-  # Run the appropriate detector. The detector name is inferred from the test class.
   def run_detector
-    detector_class.run.first
+    io = StringIO.new
+    runner = ActiveRecordDoctor::Runner.new(load_config, io)
+    success = runner.run_one(detector_name)
+    [success, io.string]
   end
 
-  def run_task
-    output = StringIO.new
-    printer = ActiveRecordDoctor::Printers::IOPrinter.new(output)
-    success = ActiveRecordDoctor::Task.new(detector_class, printer).run
-    [success, output.string]
+  def load_config
+    ActiveRecordDoctor.load_config_with_defaults(@config_path)
   end
 
   def assert_problems(expected_output)
-    success, actual_output = run_task
-
-    assert_equal(expected_output, actual_output)
-    refute(success)
+    success, output = run_detector
+    assert_equal(expected_output, output)
+    refute(success, "Expected the detector to return failure.")
   end
 
-  def refute_problems
-    success, actual_output = run_task
-
-    assert_equal("", actual_output)
-    assert(success)
+  def refute_problems(expected_output = "")
+    success, output = run_detector
+    assert_equal(expected_output, output)
+    assert(success, "Expected the detector to return success.")
   end
 end
-
-# 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