active_record_doctor 1.8.0 → 1.10.0

data/test/active_record_doctor/detectors/short_primary_key_type_test.rb

@@ -0,0 +1,72 @@
+# 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,7 +1,7 @@
 # frozen_string_literal: true
 
 class ActiveRecordDoctor::Detectors::UndefinedTableReferencesTest < Minitest::Test
-  def test_table_exists
+  def test_model_backed_by_table
     create_table(:users) do
     end.create_model do
     end
@@ -9,31 +9,19 @@ class ActiveRecordDoctor::Detectors::UndefinedTableReferencesTest < Minitest::Te
     refute_problems
   end
 
-  def test_table_does_not_exist_when_views_supported
-    create_model(:users)
-
-    if mysql? && ActiveRecord::VERSION::STRING < "5.0"
-      assert_problems(<<OUTPUT)
-WARNING: Models backed by database views are supported only in Rails 5+ OR
-Rails 4.2 + PostgreSQL. It seems this is NOT your setup. Therefore, such models
-will be erroneously reported below as not having their underlying tables/views.
-Consider upgrading Rails or disabling this task temporarily.
-The following models reference undefined tables:
-  ModelFactory::Models::User (the table users is undefined)
-OUTPUT
-    else
-      assert_problems(<<OUTPUT)
-The following models reference undefined tables:
-  ModelFactory::Models::User (the table users is undefined)
-OUTPUT
-    end
+  def test_model_backed_by_non_existent_table
+    create_model(:User)
+
+    assert_problems(<<~OUTPUT)
+      ModelFactory::Models::User references a non-existent table or view named users
+    OUTPUT
   end
 
-  def test_view_instead_of_table
+  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")
-    create_model(:users)
+    create_model(:User)
 
     begin
       refute_problems
@@ -41,4 +29,29 @@ OUTPUT
       ActiveRecord::Base.connection.execute("DROP VIEW users")
     end
   end
+
+  def test_config_ignore_tables
+    create_model(:User)
+
+    config_file(<<-CONFIG)
+      ActiveRecordDoctor.configure do |config|
+        config.detector :undefined_table_references,
+          ignore_models: ["ModelFactory::Models::User"]
+      end
+    CONFIG
+
+    refute_problems
+  end
+
+  def test_global_ignore_tables
+    create_model(:User)
+
+    config_file(<<-CONFIG)
+      ActiveRecordDoctor.configure do |config|
+        config.global :ignore_models, ["ModelFactory::Models::User"]
+      end
+    CONFIG
+
+    refute_problems
+  end
 end

data/test/active_record_doctor/detectors/unindexed_deleted_at_test.rb

@@ -11,6 +11,9 @@ class ActiveRecordDoctor::Detectors::UnindexedDeletedAtTest < Minitest::Test
       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
@@ -27,10 +30,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` 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
@@ -43,6 +45,9 @@ OUTPUT
       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
@@ -59,9 +64,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` 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

@@ -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