active_record_doctor 1.5.0 → 1.6.0

data/lib/active_record_doctor/tasks/missing_presence_validation.rb

@@ -0,0 +1,39 @@
+require "active_record_doctor/tasks/base"
+
+module ActiveRecordDoctor
+  module Tasks
+    class MissingPresenceValidation < Base
+      def run
+        eager_load!
+
+        success(hash_from_pairs(models.reject do |model|
+          model.table_name.nil? || model.table_name == 'schema_migrations'
+        end.map do |model|
+          [
+            model.name,
+            connection.columns(model.table_name).select do |column|
+              validator_needed?(model, column) &&
+                !column.null &&
+                !has_presence_validator?(model, column)
+            end.map(&:name)
+          ]
+        end.reject do |model_name, columns|
+          columns.empty?
+        end))
+      end
+
+      private
+
+      def validator_needed?(model, column)
+        ![model.primary_key, 'created_at', 'updated_at'].include?(column.name)
+      end
+
+      def has_presence_validator?(model, column)
+        model.validators.any? do |validator|
+          validator.is_a?(ActiveRecord::Validations::PresenceValidator) &&
+            validator.attributes.include?(column.name.to_sym)
+        end
+      end
+    end
+  end
+end

data/lib/active_record_doctor/tasks/missing_unique_indexes.rb

@@ -0,0 +1,51 @@
+require "active_record_doctor/tasks/base"
+
+module ActiveRecordDoctor
+  module Tasks
+    class MissingUniqueIndexes < Base
+      def run
+        eager_load!
+
+        success(hash_from_pairs(models.reject do |model|
+          model.table_name.nil?
+        end.map do |model|
+          [
+            model.table_name,
+            model.validators.select do |validator|
+              table_name = model.table_name
+              attributes = validator.attributes
+              scope = validator.options.fetch(:scope, [])
+
+              validator.is_a?(ActiveRecord::Validations::UniquenessValidator) &&
+                supported_validator?(validator) &&
+                !unique_index?(table_name, attributes, scope)
+            end.map do |validator|
+              scope = Array(validator.options.fetch(:scope, []))
+              attributes = validator.attributes
+              (scope + attributes).map(&:to_s)
+            end
+          ]
+        end.reject do |_table_name, indexes|
+          indexes.empty?
+        end))
+      end
+
+      private
+
+      def supported_validator?(validator)
+        validator.options[:if].nil? &&
+          validator.options[:unless].nil? &&
+          validator.options[:conditions].nil? &&
+          validator.options[:case_sensitive]
+      end
+
+      def unique_index?(table_name, columns, scope)
+        columns = (Array(scope) + columns).map(&:to_s)
+
+        indexes(table_name).any? do |index|
+          index.columns == columns && index.unique
+        end
+      end
+    end
+  end
+end

data/lib/active_record_doctor/tasks/undefined_table_references.rb

@@ -1,33 +1,17 @@
-require "active_record_doctor/compatibility"
-require "active_record_doctor/printers/io_printer"
+require "active_record_doctor/tasks/base"
 
 module ActiveRecordDoctor
   module Tasks
-    class UndefinedTableReferences
-      include Compatibility
-
-      def self.run
-        new.run
-      end
-
-      def initialize(printer: ActiveRecordDoctor::Printers::IOPrinter.new)
-        @printer = printer
-      end
-
+    class UndefinedTableReferences < Base
       def run
-        @printer.print_undefined_table_references(undefined_table_references)
-        undefined_table_references.present? ? 1 : 0
-      end
-
-      private
+        eager_load!
 
-      def undefined_table_references
-        Rails.application.eager_load!
-
-        ActiveRecord::Base.descendants.select do |model|
+        offending_models = models.select do |model|
           model.table_name.present? &&
             !model.connection.tables.include?(model.table_name)
         end
+
+        [offending_models, offending_models.blank?]
       end
     end
   end

data/lib/active_record_doctor/tasks/unindexed_deleted_at.rb

@@ -1,27 +1,10 @@
-require "active_record_doctor/compatibility"
-require "active_record_doctor/printers/io_printer"
+require "active_record_doctor/tasks/base"
 
 module ActiveRecordDoctor
   module Tasks
-    class UnindexedDeletedAt
-      include Compatibility
-
-      def self.run
-        new.run
-      end
-
-      def initialize(printer: ActiveRecordDoctor::Printers::IOPrinter.new)
-        @printer = printer
-      end
-
+    class UnindexedDeletedAt < Base
       def run
-        @printer.print_unindexed_deleted_at(unindexed_deleted_at)
-      end
-
-      private
-
-      def unindexed_deleted_at
-        connection.tables.select do |table|
+        success(connection.tables.select do |table|
           connection.columns(table).map(&:name).include?('deleted_at')
         end.flat_map do |table|
           connection.indexes(table).reject do |index|
@@ -29,11 +12,7 @@ module ActiveRecordDoctor
           end.map do |index|
             index.name
           end
-        end
-      end
-
-      def connection
-        @connection ||= ActiveRecord::Base.connection
+        end)
       end
     end
   end

data/lib/active_record_doctor/tasks/unindexed_foreign_keys.rb

@@ -1,27 +1,10 @@
-require "active_record_doctor/compatibility"
-require "active_record_doctor/printers/io_printer"
+require "active_record_doctor/tasks/base"
 
 module ActiveRecordDoctor
   module Tasks
-    class UnindexedForeignKeys
-      include Compatibility
-
-      def self.run
-        new.run
-      end
-
-      def initialize(printer: ActiveRecordDoctor::Printers::IOPrinter.new)
-        @printer = printer
-      end
-
+    class UnindexedForeignKeys < Base
       def run
-        @printer.print_unindexed_foreign_keys(unindexed_foreign_keys)
-      end
-
-      private
-
-      def unindexed_foreign_keys
-        hash_from_pairs(connection_tables.select do |table|
+        success(hash_from_pairs(tables.select do |table|
           "schema_migrations" != table
         end.map do |table|
           [
@@ -34,9 +17,11 @@ module ActiveRecordDoctor
           ]
         end.select do |table, columns|
           !columns.empty?
-        end)
+        end))
       end
 
+      private
+
       def foreign_key?(table, column)
         column.name.end_with?("_id")
       end
@@ -53,14 +38,6 @@ module ActiveRecordDoctor
           index.columns == [type_column_name, column.name]
         end
       end
-
-      def connection
-        @connection ||= ActiveRecord::Base.connection
-      end
-
-      def hash_from_pairs(pairs)
-        Hash[*pairs.flatten(1)]
-      end
     end
   end
 end

data/lib/active_record_doctor/version.rb

@@ -1,3 +1,3 @@
 module ActiveRecordDoctor
-  VERSION = "1.5.0"
+  VERSION = "1.6.0"
 end

data/lib/tasks/active_record_doctor.rake

@@ -0,0 +1,31 @@
+require "active_record_doctor/tasks"
+require "active_record_doctor/tasks/unindexed_foreign_keys"
+require "active_record_doctor/tasks/extraneous_indexes"
+require "active_record_doctor/tasks/missing_foreign_keys"
+require "active_record_doctor/tasks/undefined_table_references"
+require "active_record_doctor/tasks/unindexed_deleted_at"
+require "active_record_doctor/tasks/missing_unique_indexes"
+require "active_record_doctor/tasks/missing_presence_validation"
+require "active_record_doctor/tasks/missing_non_null_constraint"
+
+namespace :active_record_doctor do
+  def mount(task_class)
+    name = task_class.name.demodulize.underscore.to_sym
+
+    task name => :environment do
+      result, success = task_class.run
+      success = true if success.nil?
+
+      printer = ActiveRecordDoctor::Printers::IOPrinter.new
+      printer.public_send(name, result)
+
+      # nil doesn't indicate a failure but rather no explicit result. We assume
+      # success by default hence only false results in an erroneous exit code.
+      exit(1) if success == false
+    end
+  end
+
+  ActiveRecordDoctor::Tasks.all.each do |task|
+    mount task
+  end
+end

data/test/active_record_doctor/printers/io_printer_test.rb

@@ -3,8 +3,8 @@ require 'test_helper'
 require 'active_record_doctor/printers/io_printer'
 
 class ActiveRecordDoctor::Printers::IOPrinterTest < ActiveSupport::TestCase
-  def test_print_unindexed_foreign_keys
-    assert_equal(<<EOF, print_unindexed_foreign_keys({ "users" => ["profile_id", "account_id"], "account" => ["group_id"] }))
+  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
@@ -12,9 +12,9 @@ EOF
 
   private
 
-  def print_unindexed_foreign_keys(argument)
+  def unindexed_foreign_keys(argument)
     io = StringIO.new
-    ActiveRecordDoctor::Printers::IOPrinter.new(io: io).print_unindexed_foreign_keys(argument)
+    ActiveRecordDoctor::Printers::IOPrinter.new(io).unindexed_foreign_keys(argument)
     io.string
   end
 end

data/test/active_record_doctor/tasks/extraneous_indexes_test.rb

@@ -1,27 +1,81 @@
 require 'test_helper'
 
 require 'active_record_doctor/tasks/extraneous_indexes'
- 
+
 class ActiveRecordDoctor::Tasks::ExtraneousIndexesTest < ActiveSupport::TestCase
-  def test_extraneous_indexes_are_reported
-    result = run_task
+  def test_index_on_primary_key_is_duplicate
+    Temping.create(:user, temporary: false) do
+      with_columns do |t|
+        t.index :id
+      end
+    end
+
+    assert_result([['index_users_on_id', [:primary_key, 'users']]])
+  end
+
+  def test_non_unique_version_of_index_is_duplicate
+    Temping.create(:user, temporary: false) do
+      with_columns do |t|
+        t.string :email
+        t.index :email, name: 'index_users_on_email'
+        t.index :email, unique: true, name: 'unique_index_on_users_email'
+      end
+    end
 
-    assert_equal(
+    assert_result([
+      ['index_users_on_email', [:multi_column, 'unique_index_on_users_email']]
+    ])
+  end
+
+  def test_single_column_covered_by_unique_and_non_unique_multi_column_is_duplicate
+    Temping.create(:user, temporary: false) do
+      with_columns do |t|
+        t.string :first_name
+        t.string :last_name
+        t.string :email
+        t.index [:last_name, :first_name, :email]
+        t.index [:last_name, :first_name],
+          unique: true,
+          name: 'unique_index_on_users_last_name_and_first_name'
+        t.index :last_name
+      end
+    end
+
+    assert_result([
       [
-        ["index_employers_on_id", [:primary_key, "employers"]],
-        ["index_users_on_last_name", [:multi_column, "index_users_on_last_name_and_first_name_and_email", "unique_index_on_users_last_name_and_first_name"]],
-        ["index_users_on_last_name_and_first_name", [:multi_column, "index_users_on_last_name_and_first_name_and_email", "unique_index_on_users_last_name_and_first_name"]],
-        ["index_users_on_email", [:multi_column, "unique_index_on_users_email"]],
-      ].sort,
-      result.sort
-    )
+        'index_users_on_last_name',
+        [
+          :multi_column,
+          'index_users_on_last_name_and_first_name_and_email',
+          'unique_index_on_users_last_name_and_first_name'
+        ]
+      ]
+    ])
   end
 
-  private
+  def test_multi_column_covered_by_unique_and_non_unique_multi_column_is_duplicate
+    Temping.create(:user, temporary: false) do
+      with_columns do |t|
+        t.string :first_name
+        t.string :last_name
+        t.string :email
+        t.index [:last_name, :first_name, :email]
+        t.index [:last_name, :first_name],
+          unique: true,
+          name: 'unique_index_on_users_last_name_and_first_name'
+        t.index [:last_name, :first_name]
+      end
+    end
 
-  def run_task
-    printer = SpyPrinter.new
-    ActiveRecordDoctor::Tasks::ExtraneousIndexes.new(printer: printer).run
-    printer.extraneous_indexes
+    assert_result([
+      [
+        'index_users_on_last_name_and_first_name',
+        [
+          :multi_column,
+          'index_users_on_last_name_and_first_name_and_email',
+          'unique_index_on_users_last_name_and_first_name'
+        ]
+      ]
+    ])
   end
 end

data/test/active_record_doctor/tasks/missing_foreign_keys_test.rb

@@ -3,17 +3,25 @@ require 'test_helper'
 require 'active_record_doctor/tasks/missing_foreign_keys'
 
 class ActiveRecordDoctor::Tasks::MissingForeignKeysTest < ActiveSupport::TestCase
-  def test_missing_foreign_keys_are_reported
-    result = run_task
+  def test_missing_foreign_key_is_reported
+    Temping.create(:companies, temporary: false)
+    Temping.create(:users, temporary: false) do
+      with_columns do |t|
+        t.references :company, foreign_key: false
+      end
+    end
 
-    assert_equal({'users' => ['profile_id']}, result)
+    assert_equal({'users' => ['company_id']}, run_task)
   end
 
-  private
+  def test_present_foreign_key_is_not_reported
+    Temping.create(:companies, temporary: false)
+    Temping.create(:users, temporary: false) do
+      with_columns do |t|
+        t.references :company, foreign_key: true
+      end
+    end
 
-  def run_task
-    printer = SpyPrinter.new
-    ActiveRecordDoctor::Tasks::MissingForeignKeys.new(printer: printer).run
-    printer.missing_foreign_keys
+    assert_equal({}, run_task)
   end
 end

data/test/active_record_doctor/tasks/missing_non_null_constraint_test.rb

@@ -0,0 +1,89 @@
+require 'test_helper'
+
+require 'active_record_doctor/tasks/missing_non_null_constraint'
+
+class ActiveRecordDoctor::Tasks::MissingNonNullConstraintTest < ActiveSupport::TestCase
+  def test_presence_true_and_null_true
+    Temping.create(:users, temporary: false) do
+      validates :name, presence: true
+
+      with_columns do |t|
+        t.string :name, null: true
+      end
+    end
+
+    assert_equal({ 'users' => ['name'] }, run_task)
+  end
+
+  def test_presence_true_and_null_false
+    Temping.create(:users, temporary: false) do
+      validates :name, presence: true
+
+      with_columns do |t|
+        t.string :name, null: false
+      end
+    end
+
+    assert_equal({}, run_task)
+  end
+
+  def test_presence_false_and_null_true
+    Temping.create(:users, temporary: false) do
+      validates :name, presence: false
+
+      with_columns do |t|
+        t.string :name, null: true
+      end
+    end
+
+    assert_equal({}, run_task)
+  end
+
+  def test_presence_false_and_null_false
+    Temping.create(:users, temporary: false) do
+      validates :name, presence: false
+
+      with_columns do |t|
+        t.string :name, null: false
+      end
+    end
+
+    assert_equal({}, run_task)
+  end
+
+  def test_presence_true_with_if
+    Temping.create(:users, temporary: false) do
+      validates :name, presence: true, if: -> { false }
+
+      with_columns do |t|
+        t.string :name, null: true
+      end
+    end
+
+    assert_equal({}, run_task)
+  end
+
+  def test_presence_true_with_unless
+    Temping.create(:users, temporary: false) do
+      validates :name, presence: true, unless: -> { false }
+
+      with_columns do |t|
+        t.string :name, null: true
+      end
+    end
+
+    assert_equal({}, run_task)
+  end
+
+  def test_presence_true_with_allow_nil
+    Temping.create(:users, temporary: false) do
+      validates :name, presence: true, allow_nil: true
+
+      with_columns do |t|
+        t.string :name, null: true
+      end
+    end
+
+    assert_equal({}, run_task)
+  end
+end