active_record_doctor 1.10.0 → 1.12.0

data/test/active_record_doctor/detectors/missing_unique_indexes_test.rb

@@ -5,12 +5,12 @@ class ActiveRecordDoctor::Detectors::MissingUniqueIndexesTest < Minitest::Test
     create_table(:users) do |t|
       t.string :email
       t.index :email
-    end.create_model do
+    end.define_model do
       validates :email, uniqueness: true
     end
 
     assert_problems(<<~OUTPUT)
-      add a unique index on users(email) - validating uniqueness in the model without an index can lead to duplicates
+      add a unique index on users(email) - validating uniqueness in TransientRecord::Models::User without an index can lead to duplicates
     OUTPUT
   end
 
@@ -20,7 +20,7 @@ class ActiveRecordDoctor::Detectors::MissingUniqueIndexesTest < Minitest::Test
     create_table(:users) do |t|
       t.string :email
       t.index "lower(email)"
-    end.create_model do
+    end.define_model do
       validates :email, uniqueness: true
     end
 
@@ -34,13 +34,13 @@ class ActiveRecordDoctor::Detectors::MissingUniqueIndexesTest < Minitest::Test
     create_table(:users) do |t|
       t.string :email
       t.string :ref_token
-    end.create_model do
+    end.define_model do
       validates :email, :ref_token, uniqueness: true
     end
 
     assert_problems(<<~OUTPUT)
-      add a unique index on users(email) - validating uniqueness in the model without an index can lead to duplicates
-      add a unique index on users(ref_token) - validating uniqueness in the model without an index can lead to duplicates
+      add a unique index on users(email) - validating uniqueness in TransientRecord::Models::User without an index can lead to duplicates
+      add a unique index on users(ref_token) - validating uniqueness in TransientRecord::Models::User without an index can lead to duplicates
     OUTPUT
   end
 
@@ -48,13 +48,32 @@ class ActiveRecordDoctor::Detectors::MissingUniqueIndexesTest < Minitest::Test
     create_table(:users) do |t|
       t.string :email
       t.index :email, unique: true
-    end.create_model do
+    end.define_model do
       validates :email, uniqueness: true
     end
 
     refute_problems
   end
 
+  def test_missing_unique_index_reported_only_on_base_class
+    create_table(:users) do |t|
+      t.string :type
+      t.string :email
+      t.string :name
+    end.define_model do
+      validates :email, uniqueness: true
+    end
+
+    define_model(:Client, TransientRecord::Models::User) do
+      validates :name, uniqueness: true
+    end
+
+    assert_problems(<<~OUTPUT)
+      add a unique index on users(email) - validating uniqueness in TransientRecord::Models::User without an index can lead to duplicates
+      add a unique index on users(name) - validating uniqueness in TransientRecord::Models::Client without an index can lead to duplicates
+    OUTPUT
+  end
+
   def test_present_partial_unique_index
     skip("MySQL doesn't support partial indexes") if mysql?
 
@@ -62,12 +81,12 @@ class ActiveRecordDoctor::Detectors::MissingUniqueIndexesTest < Minitest::Test
       t.string :email
       t.boolean :active
       t.index :email, unique: true, where: "active"
-    end.create_model do
+    end.define_model do
       validates :email, uniqueness: true
     end
 
     assert_problems(<<~OUTPUT)
-      add a unique index on users(email) - validating uniqueness in the model without an index can lead to duplicates
+      add a unique index on users(email) - validating uniqueness in TransientRecord::Models::User without an index can lead to duplicates
     OUTPUT
   end
 
@@ -77,12 +96,12 @@ class ActiveRecordDoctor::Detectors::MissingUniqueIndexesTest < Minitest::Test
       t.integer :company_id
       t.integer :department_id
       t.index [:company_id, :department_id, :email]
-    end.create_model do
+    end.define_model do
       validates :email, uniqueness: { scope: [:company_id, :department_id] }
     end
 
     assert_problems(<<~OUTPUT)
-      add a unique index on users(company_id, department_id, email) - validating uniqueness in the model without an index can lead to duplicates
+      add a unique index on users(company_id, department_id, email) - validating uniqueness in TransientRecord::Models::User without an index can lead to duplicates
     OUTPUT
   end
 
@@ -92,7 +111,7 @@ class ActiveRecordDoctor::Detectors::MissingUniqueIndexesTest < Minitest::Test
       t.integer :company_id
       t.integer :department_id
       t.index [:company_id, :department_id, :email], unique: true
-    end.create_model do
+    end.define_model do
       validates :email, uniqueness: { scope: [:company_id, :department_id] }
     end
 
@@ -105,7 +124,7 @@ class ActiveRecordDoctor::Detectors::MissingUniqueIndexesTest < Minitest::Test
       t.integer :company_id
       t.integer :department_id
       t.index [:company_id, :department_id], unique: true
-    end.create_model do
+    end.define_model do
       validates :email, uniqueness: { scope: [:company_id, :department_id] }
     end
 
@@ -115,13 +134,13 @@ class ActiveRecordDoctor::Detectors::MissingUniqueIndexesTest < Minitest::Test
   def test_missing_unique_index_with_association_attribute
     create_table(:users) do |t|
       t.integer :account_id
-    end.create_model do
+    end.define_model do
       belongs_to :account
       validates :account, uniqueness: true
     end
 
     assert_problems(<<~OUTPUT)
-      add a unique index on users(account_id) - validating uniqueness in the model without an index can lead to duplicates
+      add a unique index on users(account_id) - validating uniqueness in TransientRecord::Models::User without an index can lead to duplicates
     OUTPUT
   end
 
@@ -129,7 +148,7 @@ class ActiveRecordDoctor::Detectors::MissingUniqueIndexesTest < Minitest::Test
     create_table(:users) do |t|
       t.integer :account_id
       t.index :account_id, unique: true
-    end.create_model do
+    end.define_model do
       belongs_to :account
       validates :account, uniqueness: true
     end
@@ -142,13 +161,13 @@ class ActiveRecordDoctor::Detectors::MissingUniqueIndexesTest < Minitest::Test
       t.string :title
       t.integer :commentable_id
       t.string :commentable_type
-    end.create_model do
+    end.define_model do
       belongs_to :commentable, polymorphic: true
       validates :title, uniqueness: { scope: :commentable }
     end
 
     assert_problems(<<~OUTPUT)
-      add a unique index on comments(commentable_type, commentable_id, title) - validating uniqueness in the model without an index can lead to duplicates
+      add a unique index on comments(commentable_type, commentable_id, title) - validating uniqueness in TransientRecord::Models::Comment without an index can lead to duplicates
     OUTPUT
   end
 
@@ -158,7 +177,7 @@ class ActiveRecordDoctor::Detectors::MissingUniqueIndexesTest < Minitest::Test
       t.integer :commentable_id
       t.string :commentable_type
       t.index [:commentable_id, :commentable_type, :title], unique: true
-    end.create_model do
+    end.define_model do
       belongs_to :commentable, polymorphic: true
       validates :title, uniqueness: { scope: :commentable }
     end
@@ -172,19 +191,119 @@ class ActiveRecordDoctor::Detectors::MissingUniqueIndexesTest < Minitest::Test
       t.integer :organization_id
 
       t.index [:email, :organization_id], unique: true
-    end.create_model do
+    end.define_model do
       validates :email, uniqueness: { scope: :organization_id }
     end
 
     refute_problems
   end
 
-  def test_conditions_is_skipped
-    assert_skipped(conditions: -> { where.not(email: nil) })
+  def test_case_insensitive_unique_index_exists
+    skip("Expression indexes are not supported") if ActiveRecordDoctor::Utils.expression_indexes_unsupported?
+
+    create_table(:users) do |t|
+      t.string :email
+
+      t.index :email, unique: true
+    end.define_model do
+      validates :email, uniqueness: { case_sensitive: false }
+    end
+
+    assert_problems(<<~OUTPUT)
+      add a unique expression index on users(lower(email)) - validating case-insensitive uniqueness in TransientRecord::Models::User without an expression index can lead to duplicates (a regular unique index is not enough)
+    OUTPUT
   end
 
-  def test_case_insensitive_is_skipped
-    assert_skipped(case_sensitive: false)
+  def test_case_insensitive_non_unique_lower_index_exists
+    skip("Expression indexes are not supported") if ActiveRecordDoctor::Utils.expression_indexes_unsupported?
+
+    create_table(:users) do |t|
+      t.string :email
+    end.define_model do
+      validates :email, uniqueness: { case_sensitive: false }
+    end
+
+    # ActiveRecord < 5 does not support expression indexes.
+    ActiveRecord::Base.connection.execute(<<-SQL)
+      CREATE INDEX index_users_on_lower_email ON users ((lower(email)))
+    SQL
+
+    assert_problems(<<~OUTPUT)
+      add a unique expression index on users(lower(email)) - validating case-insensitive uniqueness in TransientRecord::Models::User without an expression index can lead to duplicates (a regular unique index is not enough)
+    OUTPUT
+  end
+
+  def test_case_insensitive_unique_lower_index_exists
+    skip("Expression indexes are not supported") if ActiveRecordDoctor::Utils.expression_indexes_unsupported?
+
+    create_table(:users) do |t|
+      t.string :email
+    end.define_model do
+      validates :email, uniqueness: { case_sensitive: false }
+    end
+
+    # ActiveRecord < 5 does not support expression indexes.
+    ActiveRecord::Base.connection.execute(<<-SQL)
+      CREATE UNIQUE INDEX index_users_on_lower_email ON users ((lower(email)))
+    SQL
+
+    refute_problems
+  end
+
+  def test_case_insensitive_compound_unique_index_exists
+    skip("Expression indexes are not supported") if ActiveRecordDoctor::Utils.expression_indexes_unsupported?
+
+    create_table(:users) do |t|
+      t.string :email
+      t.integer :organization_id
+      t.index [:email, :organization_id], unique: true
+    end.define_model do
+      validates :email, uniqueness: { scope: :organization_id, case_sensitive: false }
+    end
+
+    assert_problems(<<~OUTPUT)
+      add a unique expression index on users(organization_id, lower(email)) - validating case-insensitive uniqueness in TransientRecord::Models::User without an expression index can lead to duplicates (a regular unique index is not enough)
+    OUTPUT
+  end
+
+  def test_case_insensitive_compound_non_unique_lower_index_exists
+    skip("Expression indexes are not supported") if ActiveRecordDoctor::Utils.expression_indexes_unsupported?
+
+    create_table(:users) do |t|
+      t.string :email
+      t.integer :organization_id
+    end.define_model do
+      validates :email, uniqueness: { scope: :organization_id, case_sensitive: false }
+    end
+
+    ActiveRecord::Base.connection.execute(<<-SQL)
+      CREATE INDEX index_users_on_lower_email_and_organization_id ON users ((lower(email)), organization_id)
+    SQL
+
+    assert_problems(<<~OUTPUT)
+      add a unique expression index on users(organization_id, lower(email)) - validating case-insensitive uniqueness in TransientRecord::Models::User without an expression index can lead to duplicates (a regular unique index is not enough)
+    OUTPUT
+  end
+
+  def test_case_insensitive_compound_unique_lower_index_exists
+    skip("Expression indexes are not supported") if ActiveRecordDoctor::Utils.expression_indexes_unsupported?
+
+    create_table(:users) do |t|
+      t.string :email
+      t.integer :organization_id
+    end.define_model do
+      validates :email, uniqueness: { scope: :organization_id, case_sensitive: false }
+    end
+
+    ActiveRecord::Base.connection.execute(<<-SQL)
+      CREATE UNIQUE INDEX index_users_on_lower_email_and_organization_id ON users ((lower(email)), organization_id)
+    SQL
+
+    refute_problems
+  end
+
+  def test_conditions_is_skipped
+    assert_skipped(conditions: -> { where.not(email: nil) })
   end
 
   def test_if_is_skipped
@@ -199,7 +318,7 @@ class ActiveRecordDoctor::Detectors::MissingUniqueIndexesTest < Minitest::Test
     create_table(:users) do |t|
       t.string :email
       t.index :email
-    end.create_model do
+    end.define_model do
       validates_with DummyValidator
     end
 
@@ -208,51 +327,101 @@ class ActiveRecordDoctor::Detectors::MissingUniqueIndexesTest < Minitest::Test
 
   def test_has_one_without_index
     create_table(:users)
-      .create_model do
-        has_one :account, class_name: "ModelFactory::Models::Account"
-        has_one :account_history, through: :account, class_name: "ModelFactory::Models::Account"
+      .define_model do
+        has_one :account, class_name: "TransientRecord::Models::Account"
+        has_one :account_history, through: :account, class_name: "TransientRecord::Models::Account"
       end
 
     create_table(:accounts) do |t|
       t.integer :user_id
-    end.create_model do
-      has_one :account_history, class_name: "ModelFactory::Models::AccountHistory"
+    end.define_model do
+      has_one :account_history, class_name: "TransientRecord::Models::AccountHistory"
     end
 
     create_table(:account_histories) do |t|
       t.integer :account_id
-    end.create_model do
-      belongs_to :account,  class_name: "ModelFactory::Models::Account"
+    end.define_model do
+      belongs_to :account,  class_name: "TransientRecord::Models::Account"
     end
 
     assert_problems(<<~OUTPUT)
-      add a unique index on accounts(user_id) - using `has_one` in the ModelFactory::Models::User model without an index can lead to duplicates
-      add a unique index on account_histories(account_id) - using `has_one` in the ModelFactory::Models::Account model without an index can lead to duplicates
+      add a unique index on accounts(user_id) - using `has_one` in TransientRecord::Models::User without an index can lead to duplicates
+      add a unique index on account_histories(account_id) - using `has_one` in TransientRecord::Models::Account without an index can lead to duplicates
     OUTPUT
   end
 
   def test_has_one_with_scope_and_without_index
     create_table(:users)
-      .create_model do
-        has_one :last_comment, -> { order(created_at: :desc) }, class_name: "ModelFactory::Models::Comment"
+      .define_model do
+        has_one :last_comment, -> { order(created_at: :desc) }, class_name: "TransientRecord::Models::Comment"
       end
 
     create_table(:comments) do |t|
       t.integer :user_id
-    end.create_model
+    end.define_model
 
     refute_problems
   end
 
+  def test_missing_has_one_unique_index_reported_only_on_base_class
+    create_table(:users) do |t|
+      t.string :type
+    end.define_model do
+      has_one :account, class_name: "TransientRecord::Models::Account"
+    end
+
+    define_model(:Client, TransientRecord::Models::User)
+
+    create_table(:accounts) do |t|
+      t.integer :user_id
+    end.define_model
+
+    assert_problems(<<~OUTPUT)
+      add a unique index on accounts(user_id) - using `has_one` in TransientRecord::Models::User without an index can lead to duplicates
+    OUTPUT
+  end
+
   def test_has_one_with_index
     create_table(:users)
-      .create_model do
-        has_one :account, class_name: "ModelFactory::Models::Account"
+      .define_model do
+        has_one :account, class_name: "TransientRecord::Models::Account"
       end
 
     create_table(:accounts) do |t|
       t.integer :user_id, index: { unique: true }
-    end.create_model
+    end.define_model
+
+    refute_problems
+  end
+
+  def test_polymorphic_has_one_without_index
+    create_table(:users)
+      .define_model do
+        has_one :account, as: :accountable
+      end
+
+    create_table(:accounts) do |t|
+      t.belongs_to :accountable, polymorphic: true, index: false
+    end.define_model do
+      belongs_to :accountable, polymorphic: true
+    end
+
+    assert_problems(<<~OUTPUT)
+      add a unique index on accounts(accountable_type, accountable_id) - using `has_one` in TransientRecord::Models::User without an index can lead to duplicates
+    OUTPUT
+  end
+
+  def test_polymorphic_has_one_with_index
+    create_table(:users)
+      .define_model do
+        has_one :account, as: :accountable
+      end
+
+    create_table(:accounts) do |t|
+      t.belongs_to :accountable, polymorphic: true, index: { unique: true }
+    end.define_model do
+      belongs_to :accountable, polymorphic: true
+    end
 
     refute_problems
   end
@@ -260,14 +429,14 @@ class ActiveRecordDoctor::Detectors::MissingUniqueIndexesTest < Minitest::Test
   def test_config_ignore_models
     create_table(:users) do |t|
       t.string :email
-    end.create_model do
+    end.define_model do
       validates :email, uniqueness: true
     end
 
     config_file(<<-CONFIG)
       ActiveRecordDoctor.configure do |config|
         config.detector :missing_unique_indexes,
-          ignore_models: ["ModelFactory::Models::User"]
+          ignore_models: ["TransientRecord::Models::User"]
       end
     CONFIG
 
@@ -277,13 +446,13 @@ class ActiveRecordDoctor::Detectors::MissingUniqueIndexesTest < Minitest::Test
   def test_global_ignore_models
     create_table(:users) do |t|
       t.string :email
-    end.create_model do
+    end.define_model do
       validates :email, uniqueness: true
     end
 
     config_file(<<-CONFIG)
       ActiveRecordDoctor.configure do |config|
-        config.global :ignore_models, ["ModelFactory::Models::User"]
+        config.global :ignore_models, ["TransientRecord::Models::User"]
       end
     CONFIG
 
@@ -294,14 +463,14 @@ class ActiveRecordDoctor::Detectors::MissingUniqueIndexesTest < Minitest::Test
     create_table(:users) do |t|
       t.string :email
       t.integer :role
-    end.create_model do
+    end.define_model do
       validates :email, :role, uniqueness: { scope: :organization_id }
     end
 
     config_file(<<-CONFIG)
       ActiveRecordDoctor.configure do |config|
         config.detector :missing_unique_indexes,
-          ignore_columns: ["ModelFactory::Models::User(organization_id, email)", "ModelFactory::Models::User(organization_id, role)"]
+          ignore_columns: ["TransientRecord::Models::User(organization_id, email)", "TransientRecord::Models::User(organization_id, role)"]
       end
     CONFIG
 
@@ -318,7 +487,7 @@ class ActiveRecordDoctor::Detectors::MissingUniqueIndexesTest < Minitest::Test
   def assert_skipped(options)
     create_table(:users) do |t|
       t.string :email
-    end.create_model do
+    end.define_model do
       validates :email, uniqueness: options
     end
 

data/test/active_record_doctor/detectors/short_primary_key_type_test.rb

@@ -25,6 +25,11 @@ class ActiveRecordDoctor::Detectors::ShortPrimaryKeyTypeTest < Minitest::Test
     OUTPUT
   end
 
+  def test_non_integer_and_non_uuid_primary_key_is_not_reported
+    create_table(:companies, id: :string, primary_key: :uuid)
+    refute_problems
+  end
+
   def test_long_integer_primary_key_is_not_reported
     create_table(:companies, id: :bigint)
     refute_problems

data/test/active_record_doctor/detectors/undefined_table_references_test.rb

@@ -3,17 +3,17 @@
 class ActiveRecordDoctor::Detectors::UndefinedTableReferencesTest < Minitest::Test
   def test_model_backed_by_table
     create_table(:users) do
-    end.create_model do
+    end.define_model do
     end
 
     refute_problems
   end
 
   def test_model_backed_by_non_existent_table
-    create_model(:User)
+    define_model(:User)
 
     assert_problems(<<~OUTPUT)
-      ModelFactory::Models::User references a non-existent table or view named users
+      TransientRecord::Models::User references a non-existent table or view named users
     OUTPUT
   end
 
@@ -21,22 +21,20 @@ class ActiveRecordDoctor::Detectors::UndefinedTableReferencesTest < Minitest::Te
     # 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(:User)
+    define_model(:User)
 
-    begin
-      refute_problems
-    ensure
-      ActiveRecord::Base.connection.execute("DROP VIEW users")
-    end
+    refute_problems
+  ensure
+    ActiveRecord::Base.connection.execute("DROP VIEW users")
   end
 
   def test_config_ignore_tables
-    create_model(:User)
+    define_model(:User)
 
     config_file(<<-CONFIG)
       ActiveRecordDoctor.configure do |config|
         config.detector :undefined_table_references,
-          ignore_models: ["ModelFactory::Models::User"]
+          ignore_models: ["TransientRecord::Models::User"]
       end
     CONFIG
 
@@ -44,11 +42,11 @@ class ActiveRecordDoctor::Detectors::UndefinedTableReferencesTest < Minitest::Te
   end
 
   def test_global_ignore_tables
-    create_model(:User)
+    define_model(:User)
 
     config_file(<<-CONFIG)
       ActiveRecordDoctor.configure do |config|
-        config.global :ignore_models, ["ModelFactory::Models::User"]
+        config.global :ignore_models, ["TransientRecord::Models::User"]
       end
     CONFIG
 

data/test/active_record_doctor/detectors/unindexed_foreign_keys_test.rb

@@ -10,10 +10,48 @@ class ActiveRecordDoctor::Detectors::UnindexedForeignKeysTest < Minitest::Test
     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
+      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|

data/test/active_record_doctor/runner_test.rb

@@ -1,42 +1,41 @@
 # 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)
+  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)
+      @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?)
+    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)
+    define_model(:User)
 
-    refute(runner.run_all)
-    refute(io.string.blank?)
+    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)
+      @io.truncate(0)
 
-      runner.help(name)
+      @runner.help(name)
 
-      refute(io.string.blank?, "expected help for #{name}")
+      refute(@io.string.blank?, "expected help for #{name}")
     end
   end
 end