active_record_doctor 1.6.0 → 1.7.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
-SHA1:
-  metadata.gz: 01e06f004eba174cadece575f77fe83381f53133
-  data.tar.gz: d835060741b338b07a3f87aef33eff707ef32f98
+SHA256:
+  metadata.gz: e519565b3322adffcd6b6a82a3c00289f1ad0169bb411c45292bb97306c31ae4
+  data.tar.gz: fc8c79e4ba609b97755a59d9c0b0cc86d7dbd9697bd037ecb045187af0d0d34d
 SHA512:
-  metadata.gz: e07f92a2fd4b200fd5d9e0ef50e1b5a516347b8216080071648bca31c6e72683ceb01d85e125002e4aa0cd5f48a8020ca43097488a67906c15be443e68783da4
-  data.tar.gz: 2faca055adba20d77aac44658adb35d40243f491b533a088e5ca44615d16f36e4cee7deca99b1a37607127c5f2bc276e5dac0aa56c34f0b5aa87b611667afd3e
+  metadata.gz: 1a9e7ecb7a194938ab9cb9540dfd6d19a6b8092b23da2374bafa2146164184d29e3fd3877aef6c6709e531c514055bf2bf6be1a268bb4023bb16889f89f08f17
+  data.tar.gz: 545dc4d6ae159b3619d0a0712d31e09aa40ea8ddc104401801791b4d74f3fae59b6cfde609cebea6d5718755f2b488c754524335e53bcf2d9e32a9d7242a6e60

data/README.md

@@ -11,6 +11,7 @@ can:
 * detect uniqueness validations not backed by an unique index
 * detect missing non-`NULL` constraints
 * detect missing presence validations
+* detect incorrect presence validations on boolean columns
 
 More features coming soon!
 
@@ -170,7 +171,12 @@ cases where the name can be wrong (e.g. you forgot to commit a migration or
 changed the table name). Active Record Doctor can help you identify these cases
 before they hit production.
 
-The only  think you need to do is run:
+**IMPORTANT**. Models backed by views are supported only in:
+
+* Rails 5+ and _any_ database or
+* Rails 4.2 with PostgreSQL.
+
+The only think you need to do is run:
 
 ```
 bundle exec rake active_record_doctor:undefined_table_references
@@ -251,6 +257,27 @@ The following models and columns should have presence validations:
 
 This means `User` should have a presence validator on `email` and `name`.
 
+### Detecting Incorrect Presence Validations on Boolean Columns
+
+A boolean column's presence should be validated using inclusion or exclusion
+validators instead of the usual presence validator.
+
+In order to detect boolean columns whose presence is validated incorrectly run:
+
+```
+bundle exec rake active_record_doctor:incorrect_boolean_presence_validation
+```
+
+The output of the command looks like this:
+
+```
+The presence of the following boolean columns is validated incorrectly:
+  User: active
+```
+
+This means `active` is validated with `presence: true` instead of
+`inclusion: { in: [true, false] }` or `exclusion: { in: [nil] }`.
+
 ## Author
 
 This gem is developed and maintained by [Greg Navis](http://www.gregnavis.com).

data/lib/active_record_doctor/printers/io_printer.rb

@@ -36,12 +36,21 @@ module ActiveRecordDoctor
         end.join("\n"))
       end
 
-      def undefined_table_references(models)
+      def undefined_table_references((models, views_checked))
         return if models.empty?
 
+        unless views_checked
+          @io.puts(<<EOS)
+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.
+EOS
+        end
+
         @io.puts('The following models reference undefined tables:')
-        models.each do |model|
-          @io.puts("  #{model.name} (the table #{model.table_name} is undefined)")
+        models.each do |model_name, table_name|
+          @io.puts("  #{model_name} (the table #{table_name} is undefined)")
         end
       end
 
@@ -82,6 +91,15 @@ module ActiveRecordDoctor
           @io.puts("  #{table}: #{columns.join(', ')}")
         end
       end
+
+      def presence_true_on_boolean(presence_true_on_booleans)
+        return if presence_true_on_booleans.empty?
+
+        @io.puts('The presence of the following boolean columns is validated incorrectly:')
+        presence_true_on_booleans.each do |table, columns|
+          @io.puts("  #{table}: #{columns.join(', ')}")
+        end
+      end
     end
   end
 end

data/lib/active_record_doctor/tasks/base.rb

@@ -34,6 +34,20 @@ module ActiveRecordDoctor
           end
       end
 
+      def views
+        @views ||=
+          if Rails::VERSION::MAJOR == 5
+            connection.views
+          elsif connection.is_a?(ActiveRecord::ConnectionAdapters::PostgreSQLAdapter)
+            ActiveRecord::Base.connection.execute(<<-SQL).map { |tuple| tuple.fetch("relname") }
+              SELECT c.relname FROM pg_class c WHERE c.relkind IN ('m', 'v')
+            SQL
+          else
+            # We don't support this Rails/database combination yet.
+            nil
+          end
+      end
+
       def hash_from_pairs(pairs)
         Hash[*pairs.flatten(1)]
       end

data/lib/active_record_doctor/tasks/incorrect_boolean_presence_validation.rb

@@ -0,0 +1,33 @@
+require "active_record_doctor/tasks/base"
+
+module ActiveRecordDoctor
+  module Tasks
+    class IncorrectBooleanPresenceValidation < 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|
+              column.type == :boolean &&
+                has_presence_validator?(model, column)
+            end.map(&:name)
+          ]
+        end.reject do |model_name, columns|
+          columns.empty?
+        end))
+      end
+
+      private
+
+      def has_presence_validator?(model, column)
+        model.validators.any? do |validator|
+          validator.kind == :presence && validator.attributes.include?(column.name.to_sym)
+        end
+      end
+    end
+  end
+end

data/lib/active_record_doctor/tasks/missing_non_null_constraint.rb

@@ -29,9 +29,16 @@ module ActiveRecordDoctor
       end
 
       def has_mandatory_presence_validator?(model, column)
+        allowed_attributes = [column.name.to_sym]
+
+        belongs_to = model.reflect_on_all_associations(:belongs_to).find do |reflection|
+          reflection.foreign_key == column.name
+        end
+        allowed_attributes << belongs_to.name.to_sym if belongs_to
+
         model.validators.any? do |validator|
           validator.is_a?(ActiveRecord::Validations::PresenceValidator) &&
-            validator.attributes.include?(column.name.to_sym) &&
+            (validator.attributes && allowed_attributes).present? &&
             !validator.options[:allow_nil] &&
             !validator.options[:if] &&
             !validator.options[:unless]

data/lib/active_record_doctor/tasks/missing_presence_validation.rb

@@ -13,8 +13,7 @@ module ActiveRecordDoctor
             model.name,
             connection.columns(model.table_name).select do |column|
               validator_needed?(model, column) &&
-                !column.null &&
-                !has_presence_validator?(model, column)
+                !validator_present?(model, column)
             end.map(&:name)
           ]
         end.reject do |model_name, columns|
@@ -25,13 +24,46 @@ module ActiveRecordDoctor
       private
 
       def validator_needed?(model, column)
-        ![model.primary_key, 'created_at', 'updated_at'].include?(column.name)
+        ![model.primary_key, 'created_at', 'updated_at'].include?(column.name) &&
+          !column.null
       end
 
-      def has_presence_validator?(model, column)
+      def validator_present?(model, column)
+        if column.type == :boolean
+          inclusion_validator_present?(model, column) ||
+            exclusion_validator_present?(model, column)
+        else
+          presence_validator_present?(model, column)
+        end
+      end
+
+      def inclusion_validator_present?(model, column)
+        model.validators.any? do |validator|
+          validator.is_a?(ActiveModel::Validations::InclusionValidator) &&
+            validator.attributes.include?(column.name.to_sym) &&
+            !validator.options.fetch(:in, []).include?(nil)
+        end
+      end
+
+      def exclusion_validator_present?(model, column)
+        model.validators.any? do |validator|
+          validator.is_a?(ActiveModel::Validations::ExclusionValidator) &&
+            validator.attributes.include?(column.name.to_sym) &&
+              validator.options.fetch(:in, []).include?(nil)
+        end
+      end
+
+      def presence_validator_present?(model, column)
+        allowed_attributes = [column.name.to_sym]
+
+        belongs_to = model.reflect_on_all_associations(:belongs_to).find do |reflection|
+          reflection.foreign_key == column.name
+        end
+        allowed_attributes << belongs_to.name.to_sym if belongs_to
+
         model.validators.any? do |validator|
           validator.is_a?(ActiveRecord::Validations::PresenceValidator) &&
-            validator.attributes.include?(column.name.to_sym)
+            (validator.attributes & allowed_attributes).present?
         end
       end
     end

data/lib/active_record_doctor/tasks/missing_unique_indexes.rb

@@ -36,7 +36,12 @@ module ActiveRecordDoctor
         validator.options[:if].nil? &&
           validator.options[:unless].nil? &&
           validator.options[:conditions].nil? &&
-          validator.options[:case_sensitive]
+
+          # In Rails 6, default option values are no longer explicitly set on
+          # options so if the key is absent we must fetch the default value
+          # ourselves. case_sensitive is the default in 4.2+ so it's safe to
+          # put true literally.
+          validator.options.fetch(:case_sensitive, true)
       end
 
       def unique_index?(table_name, columns, scope)

data/lib/active_record_doctor/tasks/undefined_table_references.rb

@@ -6,12 +6,27 @@ module ActiveRecordDoctor
       def run
         eager_load!
 
+        # If we can't list views due to old Rails version or unsupported
+        # database then existing_views is nil. We inform the caller we haven't
+        # consulted views so that it can display an appropriate warning.
+        existing_views = views
+
         offending_models = models.select do |model|
           model.table_name.present? &&
-            !model.connection.tables.include?(model.table_name)
+            !tables.include?(model.table_name) &&
+            existing_views &&
+            !existing_views.include?(model.table_name)
+        end.map do |model|
+          [model.name, model.table_name]
         end
 
-        [offending_models, offending_models.blank?]
+        [
+          [
+            offending_models, # Actual results
+            !existing_views.nil? # true if views were checked, false otherwise
+          ],
+          offending_models.blank?
+        ]
       end
     end
   end

data/lib/active_record_doctor/version.rb

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

data/lib/tasks/active_record_doctor.rake

@@ -7,6 +7,7 @@ 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"
+require "active_record_doctor/tasks/incorrect_boolean_presence_validation"
 
 namespace :active_record_doctor do
   def mount(task_class)

data/test/active_record_doctor/tasks/incorrect_boolean_presence_validation_test.rb

@@ -0,0 +1,33 @@
+require 'test_helper'
+
+require 'active_record_doctor/tasks/incorrect_boolean_presence_validation'
+
+class ActiveRecordDoctor::Tasks::IncorrectBooleanPresenceValidationTest < ActiveSupport::TestCase
+  def test_presence_true_is_reported_on_boolean_only
+    Temping.create(:users, temporary: false) do
+      # email is a non-boolean column whose presence CAN be validated in the
+      # usual way. We include it in the test model to ensure the task reports
+      # only boolean columns.
+      validates :email, :active, presence: true
+
+      with_columns do |t|
+        t.string :email, null: false
+        t.boolean :active, null: false
+      end
+    end
+
+    assert_equal({ 'User' => ['active'] }, run_task)
+  end
+
+  def test_inclusion_is_not_reported
+    Temping.create(:users, temporary: false) do
+      validates :active, inclusion: { in: [true, false] }
+
+      with_columns do |t|
+        t.boolean :active, null: false
+      end
+    end
+
+    assert_equal({}, run_task)
+  end
+end

data/test/active_record_doctor/tasks/missing_non_null_constraint_test.rb

@@ -15,6 +15,19 @@ class ActiveRecordDoctor::Tasks::MissingNonNullConstraintTest < ActiveSupport::T
     assert_equal({ 'users' => ['name'] }, run_task)
   end
 
+  def test_association_presence_true_and_null_true
+    Temping.create(:companies, temporary: false)
+    Temping.create(:users, temporary: false) do
+      belongs_to :company, required: true
+
+      with_columns do |t|
+        t.references :company
+      end
+    end
+
+    assert_equal({ 'users' => ['company_id'] }, run_task)
+  end
+
   def test_presence_true_and_null_false
     Temping.create(:users, temporary: false) do
       validates :name, presence: true

data/test/active_record_doctor/tasks/missing_presence_validation_test.rb

@@ -35,6 +35,67 @@ class ActiveRecordDoctor::Tasks::MissingPresenceValidationTest < ActiveSupport::
     assert_equal({}, run_task)
   end
 
+  def test_non_null_column_is_not_reported_if_association_validation_present
+    Temping.create(:companies, temporary: false)
+    Temping.create(:users, temporary: false) do
+      belongs_to :company, required: true
+
+      with_columns do |t|
+        t.references :company, null: false
+      end
+    end
+
+    assert_equal({}, run_task)
+  end
+
+  def test_non_null_boolean_is_reported_if_nil_included
+    Temping.create(:users, temporary: false) do
+      validates :active, inclusion: { in: [nil, true, false] }
+
+      with_columns do |t|
+        t.boolean :active, null: false
+      end
+    end
+
+    assert_equal({ 'User' => ['active'] }, run_task)
+  end
+
+  def test_non_null_boolean_is_not_reported_if_nil_not_included
+    Temping.create(:users, temporary: false) do
+      validates :active, inclusion: { in: [true, false] }
+
+      with_columns do |t|
+        t.boolean :active, null: false
+      end
+    end
+
+    assert_equal({}, run_task)
+  end
+
+  def test_non_null_boolean_is_not_reported_if_nil_excluded
+    Temping.create(:users, temporary: false) do
+      validates :active, exclusion: { in: [nil] }
+
+      with_columns do |t|
+        t.boolean :active, null: false
+      end
+    end
+
+    assert_equal({}, run_task)
+  end
+
+  def test_non_null_boolean_is_reported_if_nil_not_excluded
+    Temping.create(:users, temporary: false) do
+      validates :active, exclusion: { in: [false] }
+
+      with_columns do |t|
+        t.boolean :active, null: false
+      end
+    end
+
+    assert_equal({ 'User' => ['active'] }, run_task)
+  end
+
   def test_timestamps_are_not_reported
     Temping.create(:users, temporary: false) do
       validates :name, presence: true

data/test/active_record_doctor/tasks/undefined_table_references_test.rb

@@ -0,0 +1,51 @@
+require 'test_helper'
+
+require 'active_record_doctor/tasks/undefined_table_references'
+
+class ActiveRecordDoctor::Tasks::UndefinedTableReferencesTest < ActiveSupport::TestCase
+  def test_table_exists
+    # No columns needed, just the table.
+    Temping.create(:users, temporary: false)
+
+    assert_equal([[], true], run_task)
+  end
+
+  def test_table_does_not_exist
+    # No columns needed, just the table.
+    Temping.create(:users, temporary: false)
+
+    # We drop the underlying table to make the model invalid.
+    ActiveRecord::Base.connection.drop_table(User.table_name)
+
+    # We wrap the assertion in begin/ensure because we must recreate the
+    # table as otherwise Temping will raise an error. Assertion errors are
+    # signalled via exceptions which we shouldn't swallow if we don't want to
+    # break the test suite hence the choice of begin/ensure.
+    begin
+      assert_equal([[[User.name, User.table_name]], true], run_task)
+    ensure
+      ActiveRecord::Base.connection.create_table(User.table_name)
+    end
+  end
+
+  def test_view_instead_of_table
+    # No columns needed, just the table.
+    Temping.create(:users, temporary: false)
+
+    # 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.drop_table(User.table_name)
+    ActiveRecord::Base.connection.execute("CREATE VIEW users AS SELECT 1")
+
+    # We wrap the assertion in begin/ensure because we must recreate the
+    # table as otherwise Temping will raise an error. Assertion errors are
+    # signalled via exceptions which we shouldn't swallow if we don't want to
+    # break the test suite hence the choice of begin/ensure.
+    begin
+      assert_equal([[], true], run_task)
+    ensure
+      ActiveRecord::Base.connection.execute("DROP VIEW users")
+      ActiveRecord::Base.connection.create_table(User.table_name)
+    end
+  end
+end