active_record_doctor 1.9.0 → 1.10.0

data/lib/active_record_doctor/detectors/incorrect_length_validation.rb

@@ -0,0 +1,63 @@
+# frozen_string_literal: true
+
+require "active_record_doctor/detectors/base"
+
+module ActiveRecordDoctor
+  module Detectors
+    class IncorrectLengthValidation < Base # :nodoc:
+      @description = "detect mismatches between database length limits and model length validations"
+      @config = {
+        ignore_models: {
+          description: "models whose validators should not be checked",
+          global: true
+        },
+        ignore_attributes: {
+          description: "attributes, written as Model.attribute, whose validators should not be checked"
+        }
+      }
+
+      private
+
+      def message(model:, attribute:, table:, database_maximum:, model_maximum:)
+        # rubocop:disable Layout/LineLength
+        if database_maximum && model_maximum
+          "the schema limits #{table}.#{attribute} to #{database_maximum} characters but the length validator on #{model}.#{attribute} enforces a maximum of #{model_maximum} characters - set both limits to the same value or remove both"
+        elsif database_maximum && model_maximum.nil?
+          "the schema limits #{table}.#{attribute} to #{database_maximum} characters but there's no length validator on #{model}.#{attribute} - remove the database limit or add the validator"
+        elsif database_maximum.nil? && model_maximum
+          "the length validator on #{model}.#{attribute} enforces a maximum of #{model_maximum} characters but there's no schema limit on #{table}.#{attribute} - remove the validator or the schema length limit"
+        end
+        # rubocop:enable Layout/LineLength
+      end
+
+      def detect
+        models(except: config(:ignore_models)).each do |model|
+          next unless model.table_exists?
+
+          connection.columns(model.table_name).each do |column|
+            next if config(:ignore_attributes).include?("#{model.name}.#{column.name}")
+            next if ![:string, :text].include?(column.type)
+
+            model_maximum = maximum_allowed_by_validations(model)
+            next if model_maximum == column.limit
+
+            problem!(
+              model: model.name,
+              attribute: column.name,
+              table: model.table_name,
+              database_maximum: column.limit,
+              model_maximum: model_maximum
+            )
+          end
+        end
+      end
+
+      def maximum_allowed_by_validations(model)
+        length_validator = model.validators.find do |validator|
+          validator.kind == :length && validator.options.include?(:maximum)
+        end
+        length_validator ? length_validator.options[:maximum] : nil
+      end
+    end
+  end
+end

data/lib/active_record_doctor/detectors/missing_non_null_constraint.rb

@@ -24,7 +24,7 @@ module ActiveRecordDoctor
 
       def detect
         table_models = models.group_by(&:table_name)
-        table_models.delete_if { |table| table.nil? || !table_exists?(table) }
+        table_models.delete_if { |_table, models| !models.first.table_exists? }
 
         table_models.each do |table, models|
           next if config(:ignore_tables).include?(table)
@@ -37,6 +37,7 @@ module ActiveRecordDoctor
             next if config(:ignore_columns).include?("#{table}.#{column.name}")
             next if !column.null
             next if !concrete_models.all? { |model| non_null_needed?(model, column) }
+            next if not_null_check_constraint_exists?(table, column)
 
             problem!(column: column.name, table: table)
           end

data/lib/active_record_doctor/detectors/missing_presence_validation.rb

@@ -24,8 +24,7 @@ module ActiveRecordDoctor
 
       def detect
         models(except: config(:ignore_models)).each do |model|
-          next if model.table_name.nil?
-          next unless table_exists?(model.table_name)
+          next unless model.table_exists?
 
           connection.columns(model.table_name).each do |column|
             next unless validator_needed?(model, column)
@@ -38,8 +37,8 @@ module ActiveRecordDoctor
       end
 
       def validator_needed?(model, column)
-        ![model.primary_key, "created_at", "updated_at"].include?(column.name) &&
-          !column.null
+        ![model.primary_key, "created_at", "updated_at", "created_on", "updated_on"].include?(column.name) &&
+          (!column.null || not_null_check_constraint_exists?(model.table_name, column))
       end
 
       def validator_present?(model, column)

data/lib/active_record_doctor/detectors/missing_unique_indexes.rb

@@ -18,31 +18,60 @@ module ActiveRecordDoctor
 
       private
 
-      def message(table:, columns:)
-        # rubocop:disable Layout/LineLength
-        "add a unique index on #{table}(#{columns.join(', ')}) - validating uniqueness in the model without an index can lead to duplicates"
-        # rubocop:enable Layout/LineLength
+      # rubocop:disable Layout/LineLength
+      def message(model:, table:, columns:, problem:)
+        case problem
+        when :validations
+          "add a unique index on #{table}(#{columns.join(', ')}) - validating uniqueness in the model without an index can lead to duplicates"
+        when :has_ones
+          "add a unique index on #{table}(#{columns.first}) - using `has_one` in the #{model.name} model without an index can lead to duplicates"
+        end
       end
+      # rubocop:enable Layout/LineLength
 
       def detect
-        ignore_columns = config(:ignore_columns).map do |column|
-          column.gsub(" ", "")
-        end
+        validations_without_indexes
+        has_ones_without_indexes
+      end
 
+      def validations_without_indexes
         models(except: config(:ignore_models)).each do |model|
-          next if model.table_name.nil?
+          next unless model.table_exists?
 
           model.validators.each do |validator|
             scope = Array(validator.options.fetch(:scope, []))
 
             next unless validator.is_a?(ActiveRecord::Validations::UniquenessValidator)
             next unless supported_validator?(validator)
-            next if unique_index?(model.table_name, validator.attributes, scope)
 
-            columns = (scope + validator.attributes).map(&:to_s)
-            next if ignore_columns.include?("#{model.name}(#{columns.join(',')})")
+            validator.attributes.each do |attribute|
+              columns = resolve_attributes(model, scope + [attribute])
+
+              next if unique_index?(model.table_name, columns)
+              next if ignore_columns.include?("#{model.name}(#{columns.join(',')})")
+
+              problem!(model: model, table: model.table_name, columns: columns, problem: :validations)
+            end
+          end
+        end
+      end
+
+      def has_ones_without_indexes # rubocop:disable Naming/PredicateName
+        models.each do |model|
+          has_ones = model.reflect_on_all_associations(:has_one)
+          has_ones.each do |has_one|
+            next if has_one.is_a?(ActiveRecord::Reflection::ThroughReflection) || has_one.scope
+
+            association_model = has_one.klass
+            next if config(:ignore_models).include?(association_model.name)
 
-            problem!(table: model.table_name, columns: columns)
+            foreign_key = has_one.foreign_key
+            next if ignore_columns.include?(foreign_key.to_s)
+
+            table_name = association_model.table_name
+            next if unique_index?(table_name, [foreign_key])
+
+            problem!(model: model, table: table_name, columns: [foreign_key], problem: :has_ones)
           end
         end
       end
@@ -59,11 +88,32 @@ module ActiveRecordDoctor
           validator.options.fetch(:case_sensitive, true)
       end
 
-      def unique_index?(table_name, columns, scope)
-        columns = (Array(scope) + columns).map(&:to_s)
+      def resolve_attributes(model, attributes)
+        attributes.flat_map do |attribute|
+          reflection = model.reflect_on_association(attribute)
+
+          if reflection.nil?
+            attribute
+          elsif reflection.polymorphic?
+            [reflection.foreign_type, reflection.foreign_key]
+          else
+            reflection.foreign_key
+          end
+        end.map(&:to_s)
+      end
 
+      def unique_index?(table_name, columns, scope = nil)
+        columns = (Array(scope) + columns).map(&:to_s)
         indexes(table_name).any? do |index|
-          index.columns.to_set == columns.to_set && index.unique
+          index.unique &&
+            index.where.nil? &&
+            (Array(index.columns) - columns).empty?
+        end
+      end
+
+      def ignore_columns
+        @ignore_columns ||= config(:ignore_columns).map do |column|
+          column.gsub(" ", "")
         end
       end
     end

data/lib/active_record_doctor/detectors/short_primary_key_type.rb

@@ -23,7 +23,7 @@ module ActiveRecordDoctor
         tables(except: config(:ignore_tables)).each do |table|
           column = primary_key(table)
           next if column.nil?
-          next if bigint?(column)
+          next if bigint?(column) || uuid?(column)
 
           problem!(table: table, column: column.name)
         end
@@ -36,6 +36,10 @@ module ActiveRecordDoctor
           /\Abigint\b/.match?(column.sql_type)
         end
       end
+
+      def uuid?(column)
+        column.sql_type == "uuid"
+      end
     end
   end
 end

data/lib/active_record_doctor/detectors/undefined_table_references.rb

@@ -21,9 +21,7 @@ module ActiveRecordDoctor
 
       def detect
         models(except: config(:ignore_models)).each do |model|
-          next if model.table_name.nil?
-          next if tables.include?(model.table_name)
-          next if tables_and_views.include?(model.table_name)
+          next if model.table_exists? || views.include?(model.table_name)
 
           problem!(model: model.name, table: model.table_name)
         end

data/lib/active_record_doctor/detectors/unindexed_deleted_at.rb

@@ -26,7 +26,7 @@ module ActiveRecordDoctor
 
       def message(index:, column_name:)
         # rubocop:disable Layout/LineLength
-        "consider adding `WHERE #{column_name} IS NULL` to #{index} - a partial index can speed lookups of soft-deletable models"
+        "consider adding `WHERE #{column_name} IS NULL` or `WHERE #{column_name} IS NOT NULL` to #{index} - a partial index can speed lookups of soft-deletable models"
         # rubocop:enable Layout/LineLength
       end
 
@@ -42,8 +42,7 @@ module ActiveRecordDoctor
 
           timestamp_columns.each do |timestamp_column|
             indexes(table, except: config(:ignore_indexes)).each do |index|
-              # TODO: whole word
-              next if index.where =~ /\b#{timestamp_column.name}\s+IS\s+NULL\b/i
+              next if index.where =~ /\b#{timestamp_column.name}\s+IS\s+(NOT\s+)?NULL\b/i
 
               problem!(index: index.name, column_name: timestamp_column.name)
             end

data/lib/active_record_doctor/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module ActiveRecordDoctor
-  VERSION = "1.9.0"
+  VERSION = "1.10.0"
 end

data/lib/active_record_doctor.rb

@@ -7,6 +7,7 @@ require "active_record_doctor/detectors/missing_presence_validation"
 require "active_record_doctor/detectors/missing_foreign_keys"
 require "active_record_doctor/detectors/missing_unique_indexes"
 require "active_record_doctor/detectors/incorrect_boolean_presence_validation"
+require "active_record_doctor/detectors/incorrect_length_validation"
 require "active_record_doctor/detectors/extraneous_indexes"
 require "active_record_doctor/detectors/unindexed_deleted_at"
 require "active_record_doctor/detectors/undefined_table_references"

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

@@ -62,14 +62,14 @@ MIGRATION
     end
 
     def add_index(table, column)
-      index_name = Class.new.extend(ActiveRecord::ConnectionAdapters::SchemaStatements).index_name table, column
-      # rubocop:disable Layout/LineLength
-      if index_name.size > ActiveRecord::Base.connection.allowed_index_name_length
-        "    add_index :#{table}, :#{column}, name: '#{index_name.first ActiveRecord::Base.connection.allowed_index_name_length}'"
+      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
-      # rubocop:enable Layout/LineLength
     end
 
     def migration_version

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

@@ -11,6 +11,27 @@ 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
+
   def test_non_unique_version_of_index_is_duplicate
     create_table(:users) do |t|
       t.string :email
@@ -61,6 +82,19 @@ remove index_users_on_last_name_and_first_name - can be replaced by index_users_
 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

data/test/active_record_doctor/detectors/incorrect_dependent_option_test.rb

@@ -14,7 +14,7 @@ class ActiveRecordDoctor::Detectors::IncorrectDependentOptionTest < Minitest::Te
     end
 
     assert_problems(<<~OUTPUT)
-      use `dependent: :delete_all` or similar on ModelFactory::Models::Company.users - associated models have no validations and can be deleted in bulk
+      use `dependent: :delete_all` or similar on ModelFactory::Models::Company.users - associated model ModelFactory::Models::User has no validations and can be deleted in bulk
     OUTPUT
   end
 
@@ -56,7 +56,7 @@ class ActiveRecordDoctor::Detectors::IncorrectDependentOptionTest < Minitest::Te
     end
 
     assert_problems(<<~OUTPUT)
-      use `dependent: :destroy` or similar on ModelFactory::Models::Company.users - the associated model has callbacks that are currently skipped
+      use `dependent: :destroy` or similar on ModelFactory::Models::Company.users - the associated model ModelFactory::Models::User has callbacks that are currently skipped
     OUTPUT
   end
 
@@ -93,7 +93,7 @@ class ActiveRecordDoctor::Detectors::IncorrectDependentOptionTest < Minitest::Te
     end
 
     assert_problems(<<~OUTPUT)
-      use `dependent: :delete` or similar on ModelFactory::Models::Company.owner - the associated model has no callbacks and can be deleted without loading
+      use `dependent: :delete` or similar on ModelFactory::Models::Company.owner - the associated model ModelFactory::Models::User has no callbacks and can be deleted without loading
     OUTPUT
   end
 
@@ -110,7 +110,7 @@ class ActiveRecordDoctor::Detectors::IncorrectDependentOptionTest < Minitest::Te
     end
 
     assert_problems(<<~OUTPUT)
-      use `dependent: :delete` or similar on ModelFactory::Models::User.company - the associated model has no callbacks and can be deleted without loading
+      use `dependent: :delete` or similar on ModelFactory::Models::User.company - the associated model ModelFactory::Models::Company has no callbacks and can be deleted without loading
     OUTPUT
   end
 
@@ -134,7 +134,7 @@ class ActiveRecordDoctor::Detectors::IncorrectDependentOptionTest < Minitest::Te
     end
 
     assert_problems(<<~OUTPUT)
-      use `dependent: :delete` or similar on ModelFactory::Models::User.company - the associated model has no callbacks and can be deleted without loading
+      use `dependent: :delete` or similar on ModelFactory::Models::User.company - the associated model ModelFactory::Models::Company has no callbacks and can be deleted without loading
     OUTPUT
   end
 
@@ -158,7 +158,7 @@ class ActiveRecordDoctor::Detectors::IncorrectDependentOptionTest < Minitest::Te
     end
 
     assert_problems(<<~OUTPUT)
-      use `dependent: :delete` or similar on ModelFactory::Models::User.company - the associated model has no callbacks and can be deleted without loading
+      use `dependent: :delete` or similar on ModelFactory::Models::User.company - the associated model ModelFactory::Models::Company has no callbacks and can be deleted without loading
     OUTPUT
   end
 
@@ -187,7 +187,7 @@ class ActiveRecordDoctor::Detectors::IncorrectDependentOptionTest < Minitest::Te
     end
 
     assert_problems(<<~OUTPUT)
-      use `dependent: :destroy` or similar on ModelFactory::Models::User.company - the associated model has callbacks that are currently skipped
+      use `dependent: :destroy` or similar on ModelFactory::Models::User.company - the associated model ModelFactory::Models::Company has callbacks that are currently skipped
     OUTPUT
   end
 
@@ -228,6 +228,104 @@ class ActiveRecordDoctor::Detectors::IncorrectDependentOptionTest < Minitest::Te
     refute_problems
   end
 
+  def test_polymorphic_destroy_reported_when_all_associations_deletable
+    create_table(:images) do |t|
+      t.bigint :imageable_id, null: false
+      t.string :imageable_type, null: true
+    end.create_model do
+      belongs_to :imageable, polymorphic: true, dependent: :destroy
+    end
+
+    create_table(:users) do
+    end.create_model do
+      has_one :image, as: :imageable
+    end
+
+    create_table(:companies) do
+    end.create_model do
+      has_one :image, as: :imageable
+    end
+
+    assert_problems(<<~OUTPUT)
+      use `dependent: :delete` or similar on ModelFactory::Models::Image.imageable - the associated models ModelFactory::Models::Company, ModelFactory::Models::User have no callbacks and can be deleted without loading
+    OUTPUT
+  end
+
+  def test_polymorphic_destroy_not_reported_when_some_associations_not_deletable
+    create_table(:images) do |t|
+      t.bigint :imageable_id, null: false
+      t.string :imageable_type, null: true
+    end.create_model do
+      belongs_to :imageable, polymorphic: true, dependent: :destroy
+    end
+
+    create_table(:users) do
+    end.create_model do
+      has_one :image, as: :imageable
+
+      before_destroy :log
+
+      def log
+      end
+    end
+
+    create_table(:companies) do
+    end.create_model do
+      has_one :image, as: :imageable
+    end
+
+    refute_problems
+  end
+
+  def test_polymorphic_delete_reported_when_some_associations_not_deletable
+    create_table(:images) do |t|
+      t.bigint :imageable_id, null: false
+      t.string :imageable_type, null: true
+    end.create_model do
+      belongs_to :imageable, polymorphic: true, dependent: :delete
+    end
+
+    create_table(:users) do
+    end.create_model do
+      has_one :image, as: :imageable
+
+      before_destroy :log
+
+      def log
+      end
+    end
+
+    create_table(:companies) do
+    end.create_model do
+      has_one :image, as: :imageable
+    end
+
+    assert_problems(<<~OUTPUT)
+      use `dependent: :destroy` or similar on ModelFactory::Models::Image.imageable - the associated model ModelFactory::Models::User has callbacks that are currently skipped
+    OUTPUT
+  end
+
+  def test_polymorphic_delete_not_reported_when_all_associations_deletable
+    create_table(:images) do |t|
+      t.bigint :imageable_id, null: false
+      t.string :imageable_type, null: true
+    end.create_model do
+      belongs_to :imageable, polymorphic: true, dependent: :delete
+    end
+
+    create_table(:users) do
+    end.create_model do
+      has_one :image, as: :imageable
+    end
+
+    create_table(:companies) do
+    end.create_model do
+      has_one :image, as: :imageable
+    end
+
+    refute_problems
+  end
+
   def test_config_ignore_models
     create_table(:companies) do
     end.create_model do

data/test/active_record_doctor/detectors/incorrect_length_validation_test.rb

@@ -0,0 +1,105 @@
+# frozen_string_literal: true
+
+class ActiveRecordDoctor::Detectors::IncorrectLengthValidationTest < Minitest::Test
+  def test_validation_and_limit_equal_is_ok
+    create_table(:users) do |t|
+      t.string :email, limit: 64
+    end.create_model do
+      validates :email, length: { maximum: 64 }
+    end
+
+    refute_problems
+  end
+
+  def test_validation_and_limit_different_is_error
+    create_table(:users) do |t|
+      t.string :email, limit: 64
+    end.create_model do
+      validates :email, length: { maximum: 32 }
+    end
+
+    assert_problems(<<~OUTPUT)
+      the schema limits users.email to 64 characters but the length validator on ModelFactory::Models::User.email enforces a maximum of 32 characters - set both limits to the same value or remove both
+    OUTPUT
+  end
+
+  def test_validation_and_no_limit_is_error
+    skip("MySQL always sets a limit on text columns") if mysql?
+
+    create_table(:users) do |t|
+      t.string :email
+    end.create_model do
+      validates :email, length: { maximum: 32 }
+    end
+
+    assert_problems(<<~OUTPUT)
+      the length validator on ModelFactory::Models::User.email enforces a maximum of 32 characters but there's no schema limit on users.email - remove the validator or the schema length limit
+    OUTPUT
+  end
+
+  def test_no_validation_and_limit_is_error
+    create_table(:users) do |t|
+      t.string :email, limit: 64
+    end.create_model do
+    end
+
+    assert_problems(<<~OUTPUT)
+      the schema limits users.email to 64 characters but there's no length validator on ModelFactory::Models::User.email - remove the database limit or add the validator
+    OUTPUT
+  end
+
+  def test_no_validation_and_no_limit_is_ok
+    skip("MySQL always sets a limit on text columns") if mysql?
+
+    create_table(:users) do |t|
+      t.string :email
+    end.create_model do
+    end
+
+    refute_problems
+  end
+
+  def test_config_ignore_models
+    create_table(:users) do |t|
+      t.string :email, limit: 64
+    end.create_model
+
+    config_file(<<-CONFIG)
+      ActiveRecordDoctor.configure do |config|
+        config.detector :incorrect_length_validation,
+          ignore_models: ["ModelFactory::Models::User"]
+      end
+    CONFIG
+
+    refute_problems
+  end
+
+  def test_global_ignore_models
+    create_table(:users) do |t|
+      t.string :email, limit: 64
+    end.create_model
+
+    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 :email, limit: 64
+    end.create_model
+
+    config_file(<<-CONFIG)
+      ActiveRecordDoctor.configure do |config|
+        config.detector :incorrect_length_validation,
+          ignore_attributes: ["ModelFactory::Models::User.email"]
+      end
+    CONFIG
+
+    refute_problems
+  end
+end