active_record_doctor 1.8.0 → 1.10.0

data/lib/generators/active_record_doctor/add_indexes/add_indexes_generator.rb

@@ -3,8 +3,6 @@
 module ActiveRecordDoctor
   # Generate migrations that add missing indexes to the database.
   class AddIndexesGenerator < Rails::Generators::Base
-    MigrationDescription = Struct.new(:table, :columns)
-
     desc "Generate migrations for the specified indexes"
     argument :path, type: :string, default: nil, banner: "PATH"
 
@@ -12,56 +10,71 @@ module ActiveRecordDoctor
       migration_descriptions = read_migration_descriptions(path)
       now = Time.now
 
-      migration_descriptions.each_with_index do |migration_description, index|
+      migration_descriptions.each_with_index do |(table, columns), index|
         timestamp = (now + index).strftime("%Y%m%d%H%M%S")
-        file_name = "db/migrate/#{timestamp}_index_foreign_keys_in_#{migration_description.table}.rb"
-        create_file(file_name, content(migration_description))
+        file_name = "db/migrate/#{timestamp}_index_foreign_keys_in_#{table}.rb"
+        create_file(file_name, content(table, columns).tap { |x| puts x })
       end
     end
 
     private
 
+    INPUT_LINE = /^add an index on (\w+)\.(\w+) - .*$/.freeze
+    private_constant :INPUT_LINE
+
     def read_migration_descriptions(path)
-      File.readlines(path).each_with_index.map do |line, index|
-        table, *columns = line.split(/\s+/)
+      tables_to_columns = Hash.new { |hash, table| hash[table] = [] }
 
-        if table.empty?
-          raise("No table name in #{path} on line #{index + 1}. Ensure the line doesn't start with whitespace.")
-        end
-        if columns.empty?
-          raise("No columns for table #{table} in #{path} on line #{index + 1}.")
+      File.readlines(path).each_with_index do |line, index|
+        next if line.blank?
+
+        match = INPUT_LINE.match(line)
+        if match.nil?
+          raise("cannot extract table and column name from line #{index + 1}: #{line}")
         end
 
-        MigrationDescription.new(table, columns)
+        table = match[1]
+        column = match[2]
+
+        tables_to_columns[table] << column
       end
+
+      tables_to_columns
     end
 
-    def content(migration_description)
+    def content(table, columns)
       # In order to properly indent the resulting code, we must disable the
       # rubocop rule below.
 
       <<MIGRATION
-class IndexForeignKeysIn#{migration_description.table.camelize} < ActiveRecord::Migration#{migration_version}
+class IndexForeignKeysIn#{table.camelize} < ActiveRecord::Migration#{migration_version}
   def change
-#{add_indexes(migration_description)}
+#{add_indexes(table, columns)}
   end
 end
 MIGRATION
     end
 
-    def add_indexes(migration_description)
-      migration_description.columns.map do |column|
-        add_index(migration_description.table, column)
+    def add_indexes(table, columns)
+      columns.map do |column|
+        add_index(table, column)
       end.join("\n")
     end
 
     def add_index(table, column)
-      "    add_index :#{table}, :#{column}"
+      connection = ActiveRecord::Base.connection
+
+      index_name = connection.index_name(table, column)
+      if index_name.size > connection.index_name_length
+        "    add_index :#{table}, :#{column}, name: '#{index_name.first(connection.index_name_length)}'"
+      else
+        "    add_index :#{table}, :#{column}"
+      end
     end
 
     def migration_version
       if ActiveRecord::VERSION::STRING >= "5.1"
-        "[#{version}]"
+        "[#{ActiveRecord::Migration.current_version}]"
       else
         ""
       end

data/lib/tasks/active_record_doctor.rake

@@ -11,23 +11,14 @@ require "active_record_doctor/detectors/missing_presence_validation"
 require "active_record_doctor/detectors/missing_non_null_constraint"
 require "active_record_doctor/detectors/incorrect_boolean_presence_validation"
 require "active_record_doctor/detectors/incorrect_dependent_option"
-require "active_record_doctor/task"
+require "active_record_doctor/detectors/short_primary_key_type"
+require "active_record_doctor/detectors/mismatched_foreign_key_type"
+require "active_record_doctor/rake/task"
 
-namespace :active_record_doctor do
-  tasks = ActiveRecordDoctor::Detectors.all.map do |detector_class|
-    ActiveRecordDoctor::Task.new(detector_class)
-  end
-
-  tasks.each do |task|
-    desc task.description
-    task task.name => :environment do
-      task.run or exit(1)
-    end
-  end
-
-  desc "Run all active_record_doctor tasks"
-  task :all => :environment do
-    results = tasks.map { |task| task.run }
-    results.all? or exit(1)
-  end
+ActiveRecordDoctor::Rake::Task.new do |task|
+  # This file is imported when active_record_doctor is being used as part of a
+  # Rails app so it's the right place for all Rails-specific settings.
+  task.deps = [:environment]
+  task.config_path = ::Rails.root.join(".active_record_doctor")
+  task.setup = -> { ::Rails.application.eager_load! }
 end

data/test/active_record_doctor/config/loader_test.rb

@@ -0,0 +1,120 @@
+# frozen_string_literal: true
+
+class ActiveRecordDoctor::LoaderTest < Minitest::Test
+  def test_load_config
+    config_path = config_file(<<-CONFIG)
+      ActiveRecordDoctor.configure do |config|
+        config.global :ignore_tables, ["schema_migrations"]
+
+        config.detector :extraneous_indexes, ignore_tables: ["users"]
+      end
+    CONFIG
+
+    config = ActiveRecordDoctor.load_config(config_path)
+
+    assert_equal(
+      { ignore_tables: ["schema_migrations"] },
+      config.globals
+    )
+    assert_equal(
+      { extraneous_indexes: { ignore_tables: ["users"] } },
+      config.detectors
+    )
+  end
+
+  def test_load_config_raises_when_configuration_file_missing
+    exc = assert_raises(ActiveRecordDoctor::Error::ConfigurationFileMissing) do
+      ActiveRecordDoctor.load_config("/tmp/config.rb")
+    end
+    assert_equal("/tmp/config.rb", exc.config_path)
+  end
+
+  def test_load_config_raises_when_configuration_file_raises
+    config_path = config_file("1/0")
+
+    assert_raises(ActiveRecordDoctor::Error::ConfigurationError) do
+      ActiveRecordDoctor.load_config(config_path)
+    end
+  end
+
+  def test_load_config_raises_when_configure_not_called
+    config_path = config_file("# configure is not called")
+
+    assert_raises(ActiveRecordDoctor::Error::ConfigureNotCalled) do
+      ActiveRecordDoctor.load_config(config_path)
+    end
+  end
+
+  def test_load_config_raises_when_configure_called_twice
+    config_path = config_file(<<-CONFIG)
+      ActiveRecordDoctor.configure { |config| }
+      ActiveRecordDoctor.configure { |config| }
+    CONFIG
+
+    assert_raises(ActiveRecordDoctor::Error::ConfigureCalledTwice) do
+      ActiveRecordDoctor.load_config(config_path)
+    end
+  end
+
+  def test_load_config_raises_when_unrecognized_global_set
+    config_path = config_file(<<-CONFIG)
+      ActiveRecordDoctor.configure do |config|
+        config.global :user, "acme"
+      end
+    CONFIG
+
+    assert_raises(ActiveRecordDoctor::Error::UnrecognizedGlobalSetting) do
+      ActiveRecordDoctor.load_config(config_path)
+    end
+  end
+
+  def test_load_config_raises_when_global_set_twice
+    config_path = config_file(<<-CONFIG)
+      ActiveRecordDoctor.configure do |config|
+        config.global :ignore_tables, ["schema_migrations"]
+        config.global :ignore_tables, ["schema_migrations"]
+      end
+    CONFIG
+
+    assert_raises(ActiveRecordDoctor::Error::DuplicateGlobalSetting) do
+      ActiveRecordDoctor.load_config(config_path)
+    end
+  end
+
+  def test_load_config_raises_when_configured_unrecognized_detector
+    config_path = config_file(<<-CONFIG)
+      ActiveRecordDoctor.configure do |config|
+        config.detector :other_performance_issues, {}
+      end
+    CONFIG
+
+    assert_raises(ActiveRecordDoctor::Error::UnrecognizedDetectorName) do
+      ActiveRecordDoctor.load_config(config_path)
+    end
+  end
+
+  def test_load_config_raises_when_detector_configured_twice
+    config_path = config_file(<<-CONFIG)
+      ActiveRecordDoctor.configure do |config|
+        config.detector :extraneous_indexes, ignore_tables: ["users"]
+        config.detector :extraneous_indexes, ignore_tables: ["users"]
+      end
+    CONFIG
+
+    assert_raises(ActiveRecordDoctor::Error::DetectorConfiguredTwice) do
+      ActiveRecordDoctor.load_config(config_path)
+    end
+  end
+
+  def test_load_config_raises_when_provided_unrecognized_detector_setting
+    config_path = config_file(<<-CONFIG)
+      ActiveRecordDoctor.configure do |config|
+        config.detector :extraneous_indexes, { delay: 1 }
+      end
+    CONFIG
+
+    assert_raises(ActiveRecordDoctor::Error::UnrecognizedDetectorSettings) do
+      ActiveRecordDoctor.load_config(config_path)
+    end
+  end
+end

data/test/active_record_doctor/config_test.rb

@@ -0,0 +1,116 @@
+# frozen_string_literal: true
+
+class ActiveRecordDoctor::ConfigTest < Minitest::Test
+  def test_merge_globals_empty
+    config1 = ActiveRecordDoctor::Config.new({}, {})
+    config2 = ActiveRecordDoctor::Config.new({}, {})
+
+    config = config1.merge(config2)
+
+    assert_equal({}, config.globals)
+  end
+
+  def test_merge_globals_in_config1
+    config1 = ActiveRecordDoctor::Config.new(
+      { config1_global: "config1:config1_global" },
+      {}
+    )
+    config2 = ActiveRecordDoctor::Config.new({}, {})
+
+    config = config1.merge(config2)
+
+    assert_equal(
+      { config1_global: "config1:config1_global" },
+      config.globals
+    )
+  end
+
+  def test_merge_globals_in_config2
+    config1 = ActiveRecordDoctor::Config.new({}, {})
+    config2 = ActiveRecordDoctor::Config.new(
+      { config2_global: "config2:config2_global" },
+      {}
+    )
+
+    config = config1.merge(config2)
+
+    assert_equal(
+      { config2_global: "config2:config2_global" },
+      config.globals
+    )
+  end
+
+  def test_merge_globals_in_config1_and_config2
+    config1 = ActiveRecordDoctor::Config.new(
+      {
+        config1_global: "config1:config1_global",
+        shared_global: "config1:shared_global"
+      },
+      {}
+    )
+    config2 = ActiveRecordDoctor::Config.new(
+      {
+        config2_global: "config2:config2_global",
+        shared_global: "config2:shared_global"
+      },
+      {}
+    )
+
+    config = config1.merge(config2)
+
+    assert_equal(
+      {
+        config1_global: "config1:config1_global",
+        shared_global: "config2:shared_global",
+        config2_global: "config2:config2_global"
+      },
+      config.globals
+    )
+  end
+
+  def test_merge_detectors
+    config1 = ActiveRecordDoctor::Config.new(
+      {},
+      {
+        config1_detector: {
+          config1_setting: "config1:config1_detector.config1_setting"
+        },
+        shared_detector: {
+          config1_setting: "config1:shared_detector.config1_setting",
+          shared_setting: "config1:shared_detector.shared_setting"
+        }
+      }
+    )
+    config2 = ActiveRecordDoctor::Config.new(
+      {},
+      {
+        config2_detector: {
+          config2_setting: "config2:config2_detector.config2_setting"
+        },
+        shared_detector: {
+          config2_setting: "config2:shared_detector.config2_setting",
+          shared_setting: "config2:shared_detector.shared_setting"
+        }
+      }
+    )
+
+    config = config1.merge(config2)
+
+    assert_equal(
+      {
+        config1_detector: {
+          config1_setting: "config1:config1_detector.config1_setting"
+        },
+        config2_detector: {
+          config2_setting: "config2:config2_detector.config2_setting"
+        },
+        shared_detector: {
+          config1_setting: "config1:shared_detector.config1_setting",
+          config2_setting: "config2:shared_detector.config2_setting",
+          shared_setting: "config2:shared_detector.shared_setting"
+        }
+      },
+      config.detectors
+    )
+  end
+end

data/test/active_record_doctor/detectors/disable_test.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+class ActiveRecordDoctor::Detectors::DisableTest < Minitest::Test
+  # Disabling detectors is implemented in the base class. It's enought to test
+  # it on a single detector to be reasonably certain it works on all of them.
+  def test_disabling
+    create_table(:users) do |t|
+      t.string :name, null: true
+    end.create_model do
+      validates :name, presence: true
+    end
+
+    config_file(<<-CONFIG)
+      ActiveRecordDoctor.configure do |config|
+        config.detector :missing_non_null_constraint,
+          enabled: false
+      end
+    CONFIG
+
+    refute_problems
+  end
+
+  private
+
+  # We need to override that method in order to skip the mechanism that
+  # infers detector name from the test class name.
+  def detector_name
+    :missing_non_null_constraint
+  end
+end

data/test/active_record_doctor/detectors/extraneous_indexes_test.rb

@@ -7,8 +7,28 @@ class ActiveRecordDoctor::Detectors::ExtraneousIndexesTest < Minitest::Test
     end
 
     assert_problems(<<OUTPUT)
-The following indexes are extraneous and can be removed:
-  index_users_on_id (is a primary key of users)
+remove index_users_on_id - coincides with the primary key on the table
+OUTPUT
+  end
+
+  def test_partial_index_on_primary_key
+    skip("MySQL doesn't support partial indexes") if mysql?
+
+    create_table(:users) do |t|
+      t.boolean :admin
+      t.index :id, where: "admin"
+    end
+
+    refute_problems
+  end
+
+  def test_index_on_non_standard_primary_key
+    create_table(:profiles, primary_key: :user_id) do |t|
+      t.index :user_id
+    end
+
+    assert_problems(<<OUTPUT)
+remove index_profiles_on_user_id - coincides with the primary key on the table
 OUTPUT
   end
 
@@ -22,8 +42,7 @@ OUTPUT
     ActiveRecord::Base.connection.add_index :users, :email, name: "index_users_on_email"
 
     assert_problems(<<OUTPUT)
-The following indexes are extraneous and can be removed:
-  index_users_on_email (can be handled by unique_index_on_users_email)
+remove index_users_on_email - can be replaced by unique_index_on_users_email
 OUTPUT
   end
 
@@ -40,8 +59,7 @@ OUTPUT
     end
 
     assert_problems(<<OUTPUT)
-The following indexes are extraneous and can be removed:
-  index_users_on_last_name (can be handled by index_users_on_last_name_and_first_name_and_email, unique_index_on_users_last_name_and_first_name)
+remove index_users_on_last_name - can be replaced by index_users_on_last_name_and_first_name_and_email or unique_index_on_users_last_name_and_first_name
 OUTPUT
   end
 
@@ -60,8 +78,147 @@ OUTPUT
     ActiveRecord::Base.connection.add_index :users, [:last_name, :first_name]
 
     assert_problems(<<OUTPUT)
-The following indexes are extraneous and can be removed:
-  index_users_on_last_name_and_first_name (can be handled by index_users_on_last_name_and_first_name_and_email, unique_index_on_users_last_name_and_first_name)
+remove index_users_on_last_name_and_first_name - can be replaced by index_users_on_last_name_and_first_name_and_email or unique_index_on_users_last_name_and_first_name
+OUTPUT
+  end
+
+  def test_unique_index_with_fewer_columns
+    create_table(:users) do |t|
+      t.string :first_name
+      t.string :last_name
+      t.index :first_name, unique: true
+      t.index [:last_name, :first_name], unique: true
+    end
+
+    assert_problems(<<OUTPUT)
+remove index_users_on_last_name_and_first_name - can be replaced by index_users_on_first_name
 OUTPUT
   end
+
+  def test_not_covered_by_different_index_type
+    create_table(:users) do |t|
+      t.string :first_name
+      t.string :last_name
+      t.index [:last_name, :first_name], using: :btree
+
+      if mysql?
+        t.index :last_name, type: :fulltext
+      else
+        t.index :last_name, using: :hash
+      end
+    end
+
+    refute_problems
+  end
+
+  def test_not_covered_by_partial_index
+    skip("MySQL doesn't support partial indexes") if mysql?
+
+    create_table(:users) do |t|
+      t.string :first_name
+      t.string :last_name
+      t.boolean :active
+      t.index [:last_name, :first_name], where: "active"
+      t.index :last_name
+    end
+
+    refute_problems
+  end
+
+  def test_not_covered_with_different_opclasses
+    skip("ActiveRecord < 5.2 doesn't support operator classes") if ActiveRecord::VERSION::STRING < "5.2"
+    skip("MySQL doesn't support operator classes") if mysql?
+
+    create_table(:users) do |t|
+      t.string :first_name
+      t.string :last_name
+      t.index [:last_name, :first_name], opclass: :varchar_pattern_ops
+      t.index :last_name
+    end
+
+    refute_problems
+  end
+
+  def test_config_ignore_tables
+    # The detector recognizes two kinds of errors and both must take
+    # ignore_tables into account. We trigger those errors by indexing the
+    # primary key (the first extraneous index) and then indexing email twice
+    # (index2... is the other extraneous index).
+    create_table(:users) do |t|
+      t.index :id
+      t.string :email
+
+      t.index :email, name: "index1_on_users_email"
+      t.index :email, name: "index2_on_users_email"
+    end
+
+    config_file(<<-CONFIG)
+      ActiveRecordDoctor.configure do |config|
+        config.detector :extraneous_indexes,
+          ignore_tables: ["users"]
+      end
+    CONFIG
+
+    refute_problems
+  end
+
+  def test_config_global_ignore_tables
+    create_table(:users) do |t|
+      t.index :id
+      t.string :email
+
+      t.index :email, name: "index1_on_users_email"
+      t.index :email, name: "index2_on_users_email"
+    end
+
+    config_file(<<-CONFIG)
+      ActiveRecordDoctor.configure do |config|
+        config.global :ignore_tables, ["users"]
+      end
+    CONFIG
+
+    refute_problems
+  end
+
+  def test_config_global_ignore_indexes
+    create_table(:users) do |t|
+      t.index :id
+      t.string :email
+
+      t.index :email, name: "index1_on_users_email"
+      t.index :email, name: "index2_on_users_email"
+    end
+
+    config_file(<<-CONFIG)
+      ActiveRecordDoctor.configure do |config|
+        config.global :ignore_indexes, [
+          "index1_on_users_email",
+          "index2_on_users_email",
+          "index_users_on_id",
+        ]
+      end
+    CONFIG
+
+    refute_problems
+  end
+
+  def test_config_detector_ignore_indexes
+    create_table(:users) do |t|
+      t.index :id
+      t.string :email
+      t.string :api_key
+
+      t.index :email, name: "index_on_users_email"
+      t.index [:email, :api_key], name: "index_on_users_email_and_api_key"
+    end
+
+    config_file(<<-CONFIG)
+      ActiveRecordDoctor.configure do |config|
+        config.detector :extraneous_indexes,
+          ignore_indexes: ["index_users_on_id", "index_on_users_email"]
+      end
+    CONFIG
+
+    refute_problems
+  end
 end

data/test/active_record_doctor/detectors/incorrect_boolean_presence_validation_test.rb

@@ -12,10 +12,9 @@ class ActiveRecordDoctor::Detectors::IncorrectBooleanPresenceValidationTest < Mi
       validates :email, :active, presence: true
     end
 
-    assert_problems(<<OUTPUT)
-The presence of the following boolean columns is validated incorrectly:
-  ModelFactory::Models::User: active
-OUTPUT
+    assert_problems(<<~OUTPUT)
+      replace the `presence` validator on ModelFactory::Models::User.active with `inclusion` - `presence` can't be used on booleans
+    OUTPUT
   end
 
   def test_inclusion_is_not_reported
@@ -29,7 +28,51 @@ OUTPUT
   end
 
   def test_models_with_non_existent_tables_are_skipped
-    create_model(:users)
+    create_model(:User)
+
+    refute_problems
+  end
+
+  def test_config_ignore_models
+    create_table(:users) do |t|
+      t.string :email, null: false
+    end.create_model
+
+    config_file(<<-CONFIG)
+      ActiveRecordDoctor.configure do |config|
+        config.detector :incorrect_boolean_presence_validation,
+          ignore_models: ["ModelFactory.User"]
+      end
+    CONFIG
+
+    refute_problems
+  end
+
+  def test_global_ignore_models
+    create_table(:users) do |t|
+      t.string :email, null: false
+    end.create_model
+
+    config_file(<<-CONFIG)
+      ActiveRecordDoctor.configure do |config|
+        config.global :ignore_models, ["ModelFactory.User"]
+      end
+    CONFIG
+
+    refute_problems
+  end
+
+  def test_config_ignore_attributes
+    create_table(:users) do |t|
+      t.string :email, null: false
+    end.create_model
+
+    config_file(<<-CONFIG)
+      ActiveRecordDoctor.configure do |config|
+        config.detector :incorrect_boolean_presence_validation,
+          ignore_attributes: ["ModelFactory.User.email"]
+      end
+    CONFIG
 
     refute_problems
   end