active_record_doctor 1.7.2 → 1.8.0

data/test/active_record_doctor/detectors/missing_unique_indexes_test.rb

@@ -0,0 +1,114 @@
+# 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.create_model do
+      validates :email, uniqueness: true
+    end
+
+    assert_problems(<<OUTPUT)
+The following indexes should be created to back model-level uniqueness validations:
+  users: email
+OUTPUT
+  end
+
+  def test_present_unique_index
+    create_table(:users) do |t|
+      t.string :email
+      t.index :email, unique: true
+    end.create_model do
+      validates :email, uniqueness: true
+    end
+
+    refute_problems
+  end
+
+  def test_missing_unique_index_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.create_model do
+      validates :email, uniqueness: { scope: [:company_id, :department_id] }
+    end
+
+    assert_problems(<<OUTPUT)
+The following indexes should be created to back model-level uniqueness validations:
+  users: company_id, department_id, email
+OUTPUT
+  end
+
+  def test_present_unique_index_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.create_model do
+      validates :email, uniqueness: { scope: [:company_id, :department_id] }
+    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.create_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.create_model do
+      validates_with DummyValidator
+    end
+
+    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.create_model do
+      validates :email, uniqueness: options
+    end
+
+    refute_problems
+  end
+end

data/test/active_record_doctor/detectors/undefined_table_references_test.rb

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+class ActiveRecordDoctor::Detectors::UndefinedTableReferencesTest < Minitest::Test
+  def test_table_exists
+    create_table(:users) do
+    end.create_model do
+    end
+
+    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
+  end
+
+  def test_view_instead_of_table
+    # 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)
+
+    begin
+      refute_problems
+    ensure
+      ActiveRecord::Base.connection.execute("DROP VIEW users")
+    end
+  end
+end

data/test/active_record_doctor/detectors/unindexed_deleted_at_test.rb

@@ -0,0 +1,67 @@
+# 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"
+    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)
+The following indexes should include `deleted_at IS NULL`:
+  index_profiles_on_first_name_and_last_name
+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"
+    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)
+The following indexes should include `deleted_at IS NULL`:
+  index_profiles_on_first_name_and_last_name
+OUTPUT
+  end
+end

data/test/active_record_doctor/detectors/unindexed_foreign_keys_test.rb

@@ -0,0 +1,26 @@
+# 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)
+The following foreign keys should be indexed for performance reasons:
+  users company_id
+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
+end

data/test/active_record_doctor/printers/io_printer_test.rb

@@ -1,8 +1,10 @@
-# Load all tasks
+# frozen_string_literal: true
+
+# Load all detectors
 class ActiveRecordDoctor::Printers::IOPrinterTest < Minitest::Test
-  def test_all_tasks_have_printers
-    ActiveRecordDoctor::Tasks::Base.subclasses.each do |task_class|
-      name = task_class.name.demodulize.underscore.to_sym
+  def test_all_detectors_have_printers
+    ActiveRecordDoctor::Detectors::Base.subclasses.each do |detector_class|
+      name = detector_class.name.demodulize.underscore.to_sym
 
       assert(
         ActiveRecordDoctor::Printers::IOPrinter.method_defined?(name),
@@ -12,17 +14,20 @@ class ActiveRecordDoctor::Printers::IOPrinterTest < Minitest::Test
   end
 
   def test_unindexed_foreign_keys
-    assert_equal(<<EOF, unindexed_foreign_keys({ "users" => ["profile_id", "account_id"], "account" => ["group_id"] }))
-account group_id
-users account_id profile_id
-EOF
+    # rubocop:disable Layout/LineLength
+    assert_equal(<<OUTPUT, unindexed_foreign_keys({ "users" => ["profile_id", "account_id"], "account" => ["group_id"] }))
+The following foreign keys should be indexed for performance reasons:
+  account group_id
+  users account_id profile_id
+OUTPUT
+    # rubocop:enable Layout/LineLength
   end
 
   private
 
   def unindexed_foreign_keys(argument)
     io = StringIO.new
-    ActiveRecordDoctor::Printers::IOPrinter.new(io).unindexed_foreign_keys(argument)
+    ActiveRecordDoctor::Printers::IOPrinter.new(io).unindexed_foreign_keys(argument, {})
     io.string
   end
 end

data/test/model_factory.rb

@@ -0,0 +1,78 @@
+# frozen_string_literal: true
+
+module ModelFactory
+  def self.cleanup
+    delete_models
+    drop_all_tables
+    GC.start
+  end
+
+  def self.drop_all_tables
+    connection = ActiveRecord::Base.connection
+    loop do
+      before = connection.tables.size
+      break if before.zero?
+
+      attempt_drop_all_tables(connection)
+      after = connection.tables.size
+
+      if before == after
+        raise("cannot delete temporary tables - most likely due to failing constraints")
+      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
+      end
+    end
+  end
+
+  def self.delete_models
+    Models.empty
+  end
+
+  def self.create_table(table_name, &block)
+    table_name = table_name.to_sym
+    ActiveRecord::Migration.suppress_messages do
+      ActiveRecord::Migration.create_table(table_name, &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)
+  end
+
+  class ModelDefinitionProxy
+    def initialize(table_name)
+      @table_name = table_name
+    end
+
+    def create_model(&block)
+      ModelFactory.create_model(@table_name, &block)
+    end
+  end
+
+  module Models
+    def self.empty
+      constants.each do |name|
+        remove_const(name)
+      end
+    end
+  end
+end

data/test/setup.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 # Configure Active Record.
 
 # We must import "uri" explicitly as otherwsie URI won't be accessible in
@@ -7,15 +9,30 @@ require "uri"
 require "active_record"
 
 # Connect to the database defined in the URL.
-ActiveRecord::Base.establish_connection(ENV.fetch("DATABASE_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))
 
 # We need to call #connection to enfore Active Record to actually establish
 # the connection.
 ActiveRecord::Base.connection
 
-
-
-# We need to mock Rails because some tasks depend on .eager_load! This must
+# 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
@@ -29,61 +46,75 @@ module Rails
   end
 end
 
-
-
 # Load Active Record Doctor.
 require "active_record_doctor"
 
-
-
 # Configure the test suite.
 require "minitest"
 require "minitest/autorun"
 require "minitest/fork_executor"
 
+require_relative "model_factory"
 
+# Prepare the test class.
+class Minitest::Test
+  def setup
+    # Ensure all remnants of previous test runs, most likely in form of tables,
+    # are removed.
+    ModelFactory.cleanup
+  end
 
-# temping is a test library for creating tables and models on the fly. We use
-# it instead of a fixed dummy Rails app created by the generator.
-require "temping"
+  def teardown
+    ModelFactory.cleanup
+  end
 
-# Temping 3.10.0 is broken because it removes the tables in the order of
-# creation which fails if foreign key constraints are present.
-class Temping
-  class << self
-    alias_method :old_teardown, :teardown
+  private
 
-    def teardown
-      @model_klasses.reverse!
-      old_teardown
+  def postgresql?
+    ActiveRecord::Base.connection.adapter_name == "PostgreSQL"
+  end
 
-      # This hack is required to avoid leaking temporary model classes defined
-      # by Temping. If we don't clear the cache then they'll be kept around and
-      # returned as valid models which will break tests.
-      ActiveSupport::DescendantsTracker.class_variable_get(:@@direct_descendants).clear
-    end
+  def mysql?
+    ActiveRecord::Base.connection.adapter_name == "Mysql2"
   end
-end
 
+  def create_table(*args, &block)
+    ModelFactory.create_table(*args, &block)
+  end
 
+  def create_model(*args, &block)
+    ModelFactory.create_model(*args, &block)
+  end
 
-# Prepare the test class.
-class Minitest::Test
-  def teardown
-    # Remove temporary databases created by the current test case.
-    Temping.teardown
+  # Return the detector class under test.
+  def detector_class
+    self.class.name.sub(/Test$/, "").constantize
   end
 
-  private
+  # Run the appropriate detector. The detector name is inferred from the test class.
+  def run_detector
+    detector_class.run.first
+  end
 
-  # Run the appropriate task. The task name is inferred from the test class.
   def run_task
-    self.class.name.sub(/Test$/, '').constantize.run.first
+    output = StringIO.new
+    printer = ActiveRecordDoctor::Printers::IOPrinter.new(output)
+    success = ActiveRecordDoctor::Task.new(detector_class, printer).run
+    [success, output.string]
   end
 
-  # Assert results are equal without regards to the order of elements.
-  def assert_result(expected_result)
-    assert_equal(expected_result.sort_by(&:to_s), run_task.sort_by(&:to_s))
+  def assert_problems(expected_output)
+    success, actual_output = run_task
+
+    assert_equal(expected_output, actual_output)
+    refute(success)
+  end
+
+  def refute_problems
+    success, actual_output = run_task
+
+    assert_equal("", actual_output)
+    assert(success)
   end
 end
 
@@ -91,7 +122,5 @@ end
 # to be shown.
 Minitest.backtrace_filter = Minitest::BacktraceFilter.new
 
-# Run each test method in a separate process so that we avoid leaking
-# temporary models defined by temping. I'm not entirely sure but it seems to
-# be a problem with Rails caching those classes aggressively.
-# Minitest.parallel_executor = Minitest::ForkExecutor.new
+# Uncomment in case there's test case interference.
+Minitest.parallel_executor = Minitest::ForkExecutor.new