active_record_doctor 1.8.0 → 1.10.0

data/test/active_record_doctor/detectors/missing_non_null_constraint_test.rb

@@ -1,34 +1,32 @@
 # frozen_string_literal: true
 
 class ActiveRecordDoctor::Detectors::MissingNonNullConstraintTest < Minitest::Test
-  def test_presence_true_and_null_true
+  def test_optional_columns_with_presence_validator_are_disallowed
     create_table(:users) do |t|
       t.string :name, null: true
     end.create_model do
       validates :name, presence: true
     end
 
-    assert_problems(<<OUTPUT)
-The following columns should be marked as `null: false`:
-  users: name
-OUTPUT
+    assert_problems(<<~OUTPUT)
+      add `NOT NULL` to users.name - models validates its presence but it's not non-NULL in the database
+    OUTPUT
   end
 
-  def test_association_presence_true_and_null_true
+  def test_optional_foreign_keys_with_required_association_are_disallowed
     create_table(:companies)
     create_table(:users) do |t|
-      t.references :company
+      t.references :company, null: true
     end.create_model do
       belongs_to :company, required: true
     end
 
-    assert_problems(<<OUTPUT)
-The following columns should be marked as `null: false`:
-  users: company_id
-OUTPUT
+    assert_problems(<<~OUTPUT)
+      add `NOT NULL` to users.company_id - models validates its presence but it's not non-NULL in the database
+    OUTPUT
   end
 
-  def test_presence_true_and_null_false
+  def test_required_columns_with_presence_validators_are_allowed
     create_table(:users) do |t|
       t.string :name, null: false
     end.create_model do
@@ -38,7 +36,17 @@ OUTPUT
     refute_problems
   end
 
-  def test_presence_false_and_null_true
+  def test_optional_columns_without_presence_validator_are_allowed
+    create_table(:users) do |t|
+      t.string :name, null: false
+    end.create_model do
+      validates :name, presence: false
+    end
+
+    refute_problems
+  end
+
+  def test_validators_matched_to_correct_columns
     create_table(:users) do |t|
       t.string :name, null: true
     end.create_model do
@@ -54,48 +62,188 @@ OUTPUT
     refute_problems
   end
 
-  def test_presence_false_and_null_false
+  def test_validators_with_if_on_optional_columns_are_allowed
     create_table(:users) do |t|
-      t.string :name, null: false
+      t.string :name, null: true
     end.create_model do
-      validates :name, presence: false
+      validates :name, presence: true, if: -> { false }
     end
 
     refute_problems
   end
 
-  def test_presence_true_with_if
+  def test_validators_with_unless_on_optional_columns_are_allowed
     create_table(:users) do |t|
       t.string :name, null: true
     end.create_model do
-      validates :name, presence: true, if: -> { false }
+      validates :name, presence: true, unless: -> { false }
     end
 
     refute_problems
   end
 
-  def test_presence_true_with_unless
+  def test_validators_allowing_nil_on_optional_columns_are_allowed
     create_table(:users) do |t|
       t.string :name, null: true
     end.create_model do
-      validates :name, presence: true, unless: -> { false }
+      validates :name, presence: true, allow_nil: true
     end
 
     refute_problems
   end
 
-  def test_presence_true_with_allow_nil
+  def test_models_with_non_existent_tables_are_skipped
+    create_model(:User)
+
+    refute_problems
+  end
+
+  def test_optional_columns_validated_by_all_sti_models_are_disallowed
+    create_table(:users) do |t|
+      t.string :type, null: false
+      t.string :email, null: true
+    end.create_model
+
+    create_model(:Client, ModelFactory::Models::User) do
+      validates :email, presence: true
+    end
+
+    assert_problems(<<~OUTPUT)
+      add `NOT NULL` to users.email - models validates its presence but it's not non-NULL in the database
+    OUTPUT
+  end
+
+  def test_optional_columns_validated_by_some_sti_models_are_allowed
+    create_table(:users) do |t|
+      t.string :type, null: false
+      t.string :email, null: true
+    end.create_model
+
+    create_model(:Client, ModelFactory::Models::User) do
+      validates :email, presence: true
+    end
+
+    create_model(:Admin, ModelFactory::Models::User) do
+      validates :email, presence: false
+    end
+
+    refute_problems
+  end
+
+  def test_optional_columns_validated_by_all_non_sti_models_are_disallowed
+    create_table(:users) do |t|
+      t.string :email, null: true
+    end.create_model do
+      validates :email, presence: true
+    end
+
+    create_model(:Client) do
+      self.table_name = :users
+
+      validates :email, presence: true
+    end
+
+    assert_problems(<<~OUTPUT)
+      add `NOT NULL` to users.email - models validates its presence but it's not non-NULL in the database
+    OUTPUT
+  end
+
+  def test_optional_columns_validated_by_some_non_sti_models_are_allowed
+    create_table(:users) do |t|
+      t.string :email, null: true
+    end.create_model do
+      validates :email, presence: true
+    end
+
+    create_model(:Client) do
+      self.table_name = :users
+
+      validates :email, presence: false
+    end
+
+    refute_problems
+  end
+
+  def test_not_null_check_constraint
+    skip unless postgresql?
+
+    create_table(:users) do |t|
+      t.string :email
+    end.create_model do
+      validates :email, presence: true
+    end
+
+    ActiveRecord::Base.connection.execute(<<-SQL)
+      ALTER TABLE users ADD CONSTRAINT email_not_null CHECK (email IS NOT NULL)
+    SQL
+
+    refute_problems
+  end
+
+  def test_not_null_check_constraint_not_valid
+    skip unless postgresql?
+
+    create_table(:users) do |t|
+      t.string :email
+    end.create_model do
+      validates :email, presence: true
+    end
+
+    ActiveRecord::Base.connection.execute(<<-SQL)
+      ALTER TABLE users ADD CONSTRAINT email_not_null CHECK (email IS NOT NULL) NOT VALID
+    SQL
+
+    assert_problems(<<~OUTPUT)
+      add `NOT NULL` to users.email - models validates its presence but it's not non-NULL in the database
+    OUTPUT
+  end
+
+  def test_config_ignore_tables
     create_table(:users) do |t|
       t.string :name, null: true
     end.create_model do
-      validates :name, presence: true, allow_nil: true
+      validates :name, presence: true
     end
 
+    config_file(<<-CONFIG)
+      ActiveRecordDoctor.configure do |config|
+        config.detector :missing_non_null_constraint,
+          ignore_tables: ["users"]
+      end
+    CONFIG
+
     refute_problems
   end
 
-  def test_models_with_non_existent_tables_are_skipped
-    create_model(:users)
+  def test_global_ignore_tables
+    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.global :ignore_tables, ["users"]
+      end
+    CONFIG
+
+    refute_problems
+  end
+
+  def test_config_ignore_columns
+    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,
+          ignore_columns: ["users.name"]
+      end
+    CONFIG
 
     refute_problems
   end

data/test/active_record_doctor/detectors/missing_presence_validation_test.rb

@@ -16,10 +16,9 @@ class ActiveRecordDoctor::Detectors::MissingPresenceValidationTest < Minitest::T
     end.create_model do
     end
 
-    assert_problems(<<OUTPUT)
-The following models and columns should have presence validations:
-  ModelFactory::Models::User: name
-OUTPUT
+    assert_problems(<<~OUTPUT)
+      add a `presence` validator to ModelFactory::Models::User.name - it's NOT NULL but lacks a validator
+    OUTPUT
   end
 
   def test_non_null_column_is_not_reported_if_validation_present
@@ -43,6 +42,23 @@ OUTPUT
     refute_problems
   end
 
+  def test_not_null_column_is_not_reported_if_habtm_association
+    create_table(:users).create_model do
+      has_and_belongs_to_many :projects, class_name: "ModelFactory::Models::Project"
+    end
+
+    create_table(:projects_users) do |t|
+      t.bigint :project_id, null: false
+      t.bigint :user_id, null: false
+    end
+
+    create_table(:projects).create_model do
+      has_and_belongs_to_many :users, class_name: "ModelFactory::Models::User"
+    end
+
+    refute_problems
+  end
+
   def test_non_null_boolean_is_reported_if_nil_included
     create_table(:users) do |t|
       t.boolean :active, null: false
@@ -50,10 +66,9 @@ OUTPUT
       validates :active, inclusion: { in: [nil, true, false] }
     end
 
-    assert_problems(<<OUTPUT)
-The following models and columns should have presence validations:
-  ModelFactory::Models::User: active
-OUTPUT
+    assert_problems(<<~OUTPUT)
+      add a `presence` validator to ModelFactory::Models::User.active - it's NOT NULL but lacks a validator
+    OUTPUT
   end
 
   def test_non_null_boolean_is_not_reported_if_nil_not_included
@@ -83,24 +98,106 @@ OUTPUT
       validates :active, exclusion: { in: [false] }
     end
 
-    assert_problems(<<OUTPUT)
-The following models and columns should have presence validations:
-  ModelFactory::Models::User: active
-OUTPUT
+    assert_problems(<<~OUTPUT)
+      add a `presence` validator to ModelFactory::Models::User.active - it's NOT NULL but lacks a validator
+    OUTPUT
   end
 
   def test_timestamps_are_not_reported
     create_table(:users) do |t|
+      # Create created_at/updated_at timestamps.
       t.timestamps null: false
+
+      # Rails also supports created_on/updated_on. We used datetime, which is
+      # what the timestamps method users under the hood, to avoid default value
+      # errors in some MySQL versions when using t.timestamp.
+      t.datetime :created_on, null: false
+      t.datetime :updated_on, null: false
     end.create_model do
-      validates :name, presence: true
     end
 
     refute_problems
   end
 
   def test_models_with_non_existent_tables_are_skipped
-    create_model(:users)
+    create_model(:User)
+
+    refute_problems
+  end
+
+  def test_not_null_check_constraint
+    skip unless postgresql?
+
+    create_table(:users) do |t|
+      t.string :name
+    end.create_model
+
+    ActiveRecord::Base.connection.execute(<<-SQL)
+      ALTER TABLE users ADD CONSTRAINT name_not_null CHECK (name IS NOT NULL)
+    SQL
+
+    assert_problems(<<~OUTPUT)
+      add a `presence` validator to ModelFactory::Models::User.name - it's NOT NULL but lacks a validator
+    OUTPUT
+  end
+
+  def test_not_null_check_constraint_not_valid
+    skip unless postgresql?
+
+    create_table(:users) do |t|
+      t.string :name
+    end.create_model
+
+    ActiveRecord::Base.connection.execute(<<-SQL)
+      ALTER TABLE users ADD CONSTRAINT name_not_null CHECK (name IS NOT NULL) NOT VALID
+    SQL
+
+    refute_problems
+  end
+
+  def test_config_ignore_models
+    create_table(:users) do |t|
+      t.string :name, null: false
+    end.create_model do
+    end
+
+    config_file(<<-CONFIG)
+      ActiveRecordDoctor.configure do |config|
+        config.detector :missing_presence_validation,
+          ignore_models: ["ModelFactory::Models::User"]
+      end
+    CONFIG
+
+    refute_problems
+  end
+
+  def test_global_ignore_models
+    create_table(:users) do |t|
+      t.string :name, null: false
+    end.create_model do
+    end
+
+    config_file(<<-CONFIG)
+      ActiveRecordDoctor.configure do |config|
+        config.global :ignore_models, ["ModelFactory::Models::User"]
+      end
+    CONFIG
+
+    refute_problems
+  end
+
+  def test_config_ignore_attributes
+    create_table(:users) do |t|
+      t.string :name, null: false
+    end.create_model do
+    end
+
+    config_file(<<-CONFIG)
+      ActiveRecordDoctor.configure do |config|
+        config.detector :missing_presence_validation,
+          ignore_attributes: ["ModelFactory::Models::User.name"]
+      end
+    CONFIG
 
     refute_problems
   end

data/test/active_record_doctor/detectors/missing_unique_indexes_test.rb

@@ -9,10 +9,39 @@ class ActiveRecordDoctor::Detectors::MissingUniqueIndexesTest < Minitest::Test
       validates :email, uniqueness: true
     end
 
-    assert_problems(<<OUTPUT)
-The following indexes should be created to back model-level uniqueness validations:
-  users: email
-OUTPUT
+    assert_problems(<<~OUTPUT)
+      add a unique index on users(email) - validating uniqueness in the model without an index can lead to duplicates
+    OUTPUT
+  end
+
+  def test_missing_unique_index_on_functional_index
+    skip if !(ActiveRecord::VERSION::STRING >= "5.0" && postgresql?)
+
+    create_table(:users) do |t|
+      t.string :email
+      t.index "lower(email)"
+    end.create_model do
+      validates :email, uniqueness: true
+    end
+
+    # Running the detector should NOT raise an error when a functional index
+    # is present. No need to assert anything -- the test is successful if no
+    # exception was raised.
+    run_detector
+  end
+
+  def test_validates_multiple_attributes
+    create_table(:users) do |t|
+      t.string :email
+      t.string :ref_token
+    end.create_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
+    OUTPUT
   end
 
   def test_present_unique_index
@@ -26,7 +55,23 @@ OUTPUT
     refute_problems
   end
 
-  def test_missing_unique_index_with_scope
+  def test_present_partial_unique_index
+    skip("MySQL doesn't support partial indexes") if mysql?
+
+    create_table(:users) do |t|
+      t.string :email
+      t.boolean :active
+      t.index :email, unique: true, where: "active"
+    end.create_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
+    OUTPUT
+  end
+
+  def test_unique_index_with_extra_columns_with_scope
     create_table(:users) do |t|
       t.string :email
       t.integer :company_id
@@ -36,13 +81,12 @@ OUTPUT
       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
+    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
+    OUTPUT
   end
 
-  def test_present_unique_index_with_scope
+  def test_unique_index_with_exact_columns_with_scope
     create_table(:users) do |t|
       t.string :email
       t.integer :company_id
@@ -55,6 +99,73 @@ OUTPUT
     refute_problems
   end
 
+  def test_unique_index_with_fewer_columns_with_scope
+    create_table(:users) do |t|
+      t.string :email
+      t.integer :company_id
+      t.integer :department_id
+      t.index [:company_id, :department_id], unique: true
+    end.create_model do
+      validates :email, uniqueness: { scope: [:company_id, :department_id] }
+    end
+
+    refute_problems
+  end
+
+  def test_missing_unique_index_with_association_attribute
+    create_table(:users) do |t|
+      t.integer :account_id
+    end.create_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
+    OUTPUT
+  end
+
+  def test_present_unique_index_with_association_attribute
+    create_table(:users) do |t|
+      t.integer :account_id
+      t.index :account_id, unique: true
+    end.create_model do
+      belongs_to :account
+      validates :account, uniqueness: true
+    end
+
+    refute_problems
+  end
+
+  def test_missing_unique_index_with_association_scope
+    create_table(:comments) do |t|
+      t.string :title
+      t.integer :commentable_id
+      t.string :commentable_type
+    end.create_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
+    OUTPUT
+  end
+
+  def test_present_unique_index_with_association_scope
+    create_table(:comments) do |t|
+      t.string :title
+      t.integer :commentable_id
+      t.string :commentable_type
+      t.index [:commentable_id, :commentable_type, :title], unique: true
+    end.create_model do
+      belongs_to :commentable, polymorphic: true
+      validates :title, uniqueness: { scope: :commentable }
+    end
+
+    refute_problems
+  end
+
   def test_column_order_is_ignored
     create_table(:users) do |t|
       t.string :email
@@ -95,6 +206,108 @@ OUTPUT
     refute_problems
   end
 
+  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"
+      end
+
+    create_table(:accounts) do |t|
+      t.integer :user_id
+    end.create_model do
+      has_one :account_history, class_name: "ModelFactory::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
+
+    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
+    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"
+      end
+
+    create_table(:comments) do |t|
+      t.integer :user_id
+    end.create_model
+
+    refute_problems
+  end
+
+  def test_has_one_with_index
+    create_table(:users)
+      .create_model do
+        has_one :account, class_name: "ModelFactory::Models::Account"
+      end
+
+    create_table(:accounts) do |t|
+      t.integer :user_id, index: { unique: true }
+    end.create_model
+
+    refute_problems
+  end
+
+  def test_config_ignore_models
+    create_table(:users) do |t|
+      t.string :email
+    end.create_model do
+      validates :email, uniqueness: true
+    end
+
+    config_file(<<-CONFIG)
+      ActiveRecordDoctor.configure do |config|
+        config.detector :missing_unique_indexes,
+          ignore_models: ["ModelFactory::Models::User"]
+      end
+    CONFIG
+
+    refute_problems
+  end
+
+  def test_global_ignore_models
+    create_table(:users) do |t|
+      t.string :email
+    end.create_model do
+      validates :email, uniqueness: true
+    end
+
+    config_file(<<-CONFIG)
+      ActiveRecordDoctor.configure do |config|
+        config.global :ignore_models, ["ModelFactory::Models::User"]
+      end
+    CONFIG
+
+    refute_problems
+  end
+
+  def test_config_ignore_columns
+    create_table(:users) do |t|
+      t.string :email
+      t.integer :role
+    end.create_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)"]
+      end
+    CONFIG
+
+    refute_problems
+  end
+
   class DummyValidator < ActiveModel::Validator
     def validate(record)
     end