Merge pull request #83 from fatkodima/path-exists-cops

Add new `Minitest/AssertPathExists` and `Minitest/RefutePathExists` cops

CHANGELOG.md

@@ -4,6 +4,7 @@
 
 ### New features
 
+* [#83](https://github.com/rubocop-hq/rubocop-minitest/pull/83): New cops `AssertPathExists` and `RefutePathExists` check for use of `assert_path_exists`/`refute_path_exists` instead of `assert(File.exist?(path))`/`refute(File.exist?(path))`. ([@fatkodima][])
 * [#87](https://github.com/rubocop-hq/rubocop-minitest/pull/87): Add new `Minitest/AssertSilent` cop. ([@fatkodima][])
 * [#84](https://github.com/rubocop-hq/rubocop-minitest/pull/84): New cops `AssertKindOf` and `RefuteKindOf` check for use of `assert_kind_of`/`refute_kind_of` instead of `assert(foo.kind_of?(Class))`/`refute(foo.kind_of?(Class))`. ([@fatkodima][])
 * [#85](https://github.com/rubocop-hq/rubocop-minitest/pull/85): Add autocorrect to `Rails/AssertEmptyLiteral` cop. ([@fatkodima][])

config/default.yml

@@ -53,6 +53,12 @@ Minitest/AssertNil:
   Enabled: true
   VersionAdded: '0.1'
 
+Minitest/AssertPathExists:
+  Description: 'This cop enforces the test to use `assert_path_exists` instead of using `assert(File.exist?(path))`.'
+  StyleGuide: 'https://minitest.rubystyle.guide/#assert-path-exists'
+  Enabled: 'pending'
+  VersionAdded: '0.10'
+
 Minitest/AssertRespondTo:
   Description: 'This cop enforces the test to use `assert_respond_to(object, :do_something)` over `assert(object.respond_to?(:do_something))`.'
   StyleGuide: 'https://minitest.rubystyle.guide#assert-responds-to-method'
@@ -125,6 +131,12 @@ Minitest/RefuteNil:
   Enabled: true
   VersionAdded: '0.2'
 
+Minitest/RefutePathExists:
+  Description: 'This cop enforces the test to use `refute_path_exists` instead of using `refute(File.exist?(path))`.'
+  StyleGuide: 'https://minitest.rubystyle.guide/#refute-path-exists'
+  Enabled: 'pending'
+  VersionAdded: '0.10'
+
 Minitest/RefuteRespondTo:
   Description: 'This cop enforces the test to use `refute_respond_to(object, :do_something)` over `refute(object.respond_to?(:do_something))`.'
   StyleGuide: 'https://minitest.rubystyle.guide#refute-respond-to'

docs/modules/ROOT/pages/cops.adoc

@@ -10,6 +10,7 @@
 * xref:cops_minitest.adoc#minitestassertkindof[Minitest/AssertKindOf]
 * xref:cops_minitest.adoc#minitestassertmatch[Minitest/AssertMatch]
 * xref:cops_minitest.adoc#minitestassertnil[Minitest/AssertNil]
+* xref:cops_minitest.adoc#minitestassertpathexists[Minitest/AssertPathExists]
 * xref:cops_minitest.adoc#minitestassertrespondto[Minitest/AssertRespondTo]
 * xref:cops_minitest.adoc#minitestassertsilent[Minitest/AssertSilent]
 * xref:cops_minitest.adoc#minitestasserttruthy[Minitest/AssertTruthy]
@@ -22,6 +23,7 @@
 * xref:cops_minitest.adoc#minitestrefutekindof[Minitest/RefuteKindOf]
 * xref:cops_minitest.adoc#minitestrefutematch[Minitest/RefuteMatch]
 * xref:cops_minitest.adoc#minitestrefutenil[Minitest/RefuteNil]
+* xref:cops_minitest.adoc#minitestrefutepathexists[Minitest/RefutePathExists]
 * xref:cops_minitest.adoc#minitestrefuterespondto[Minitest/RefuteRespondTo]
 
 // END_COP_LIST

docs/modules/ROOT/pages/cops_minitest.adoc

@@ -249,6 +249,38 @@ assert_nil(actual, 'message')
 
 * https://minitest.rubystyle.guide#assert-nil
 
+== Minitest/AssertPathExists
+
+|===
+| Enabled by default | Safe | Supports autocorrection | VersionAdded | VersionChanged
+
+| Pending
+| Yes
+| Yes
+| 0.10
+| -
+|===
+
+This cop enforces the test to use `assert_path_exists`
+instead of using `assert(File.exist?(path))`.
+
+=== Examples
+
+[source,ruby]
+----
+# bad
+assert(File.exist?(path))
+assert(File.exist?(path), 'message')
+
+# good
+assert_path_exists(path)
+assert_path_exists(path, 'message')
+----
+
+=== References
+
+* https://minitest.rubystyle.guide/#assert-path-exists
+
 == Minitest/AssertRespondTo
 
 |===
@@ -637,6 +669,38 @@ refute_nil(actual, 'message')
 
 * https://minitest.rubystyle.guide#refute-nil
 
+== Minitest/RefutePathExists
+
+|===
+| Enabled by default | Safe | Supports autocorrection | VersionAdded | VersionChanged
+
+| Pending
+| Yes
+| Yes
+| 0.10
+| -
+|===
+
+This cop enforces the test to use `refute_path_exists`
+instead of using `refute(File.exist?(path))`.
+
+=== Examples
+
+[source,ruby]
+----
+# bad
+refute(File.exist?(path))
+refute(File.exist?(path), 'message')
+
+# good
+refute_path_exists(path)
+refute_path_exists(path, 'message')
+----
+
+=== References
+
+* https://minitest.rubystyle.guide/#refute-path-exists
+
 == Minitest/RefuteRespondTo
 
 |===

lib/rubocop/cop/minitest/assert_path_exists.rb

@@ -0,0 +1,67 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Minitest
+      # This cop enforces the test to use `assert_path_exists`
+      # instead of using `assert(File.exist?(path))`.
+      #
+      # @example
+      #   # bad
+      #   assert(File.exist?(path))
+      #   assert(File.exist?(path), 'message')
+      #
+      #   # good
+      #   assert_path_exists(path)
+      #   assert_path_exists(path, 'message')
+      #
+      class AssertPathExists < Cop
+        MSG = 'Prefer using `%<good_method>s` over `%<bad_method>s`.'
+
+        def_node_matcher :assert_file_exists, <<~PATTERN
+          (send nil? :assert
+            (send
+              (const _ :File) ${:exist? :exists?} $_)
+              $...)
+        PATTERN
+
+        def on_send(node)
+          assert_file_exists(node) do |method_name, path, message|
+            message = message.first
+
+            add_offense(node,
+                        message: format(MSG, good_method: build_good_method(path, message),
+                                             bad_method: build_bad_method(method_name, path, message)))
+          end
+        end
+
+        def autocorrect(node)
+          assert_file_exists(node) do |_method_name, path, message|
+            message = message.first
+
+            lambda do |corrector|
+              replacement = build_good_method(path, message)
+              corrector.replace(node, replacement)
+            end
+          end
+        end
+
+        private
+
+        def build_good_method(path, message)
+          args = [path.source, message&.source].compact.join(', ')
+          "assert_path_exists(#{args})"
+        end
+
+        def build_bad_method(method_name, path, message)
+          path_arg = "File.#{method_name}(#{path.source})"
+          if message
+            "assert(#{path_arg}, #{message.source})"
+          else
+            "assert(#{path_arg})"
+          end
+        end
+      end
+    end
+  end
+end

lib/rubocop/cop/minitest/refute_path_exists.rb

@@ -0,0 +1,67 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Minitest
+      # This cop enforces the test to use `refute_path_exists`
+      # instead of using `refute(File.exist?(path))`.
+      #
+      # @example
+      #   # bad
+      #   refute(File.exist?(path))
+      #   refute(File.exist?(path), 'message')
+      #
+      #   # good
+      #   refute_path_exists(path)
+      #   refute_path_exists(path, 'message')
+      #
+      class RefutePathExists < Cop
+        MSG = 'Prefer using `%<good_method>s` over `%<bad_method>s`.'
+
+        def_node_matcher :refute_file_exists, <<~PATTERN
+          (send nil? :refute
+            (send
+              (const _ :File) ${:exist? :exists?} $_)
+              $...)
+        PATTERN
+
+        def on_send(node)
+          refute_file_exists(node) do |method_name, path, message|
+            message = message.first
+
+            add_offense(node,
+                        message: format(MSG, good_method: build_good_method(path, message),
+                                             bad_method: build_bad_method(method_name, path, message)))
+          end
+        end
+
+        def autocorrect(node)
+          refute_file_exists(node) do |_method_name, path, message|
+            message = message.first
+
+            lambda do |corrector|
+              replacement = build_good_method(path, message)
+              corrector.replace(node, replacement)
+            end
+          end
+        end
+
+        private
+
+        def build_good_method(path, message)
+          args = [path.source, message&.source].compact.join(', ')
+          "refute_path_exists(#{args})"
+        end
+
+        def build_bad_method(method_name, path, message)
+          path_arg = "File.#{method_name}(#{path.source})"
+          if message
+            "refute(#{path_arg}, #{message.source})"
+          else
+            "refute(#{path_arg})"
+          end
+        end
+      end
+    end
+  end
+end

lib/rubocop/cop/minitest_cops.rb

@@ -10,6 +10,7 @@
 require_relative 'minitest/assert_includes'
 require_relative 'minitest/assert_instance_of'
 require_relative 'minitest/assert_match'
+require_relative 'minitest/assert_path_exists'
 require_relative 'minitest/assert_respond_to'
 require_relative 'minitest/assert_silent'
 require_relative 'minitest/assert_truthy'
@@ -22,4 +23,5 @@
 require_relative 'minitest/refute_includes'
 require_relative 'minitest/refute_match'
 require_relative 'minitest/refute_instance_of'
+require_relative 'minitest/refute_path_exists'
 require_relative 'minitest/refute_respond_to'

test/rubocop/cop/minitest/assert_path_exists_test.rb

@@ -0,0 +1,53 @@
+# frozen_string_literal: true
+
+require 'test_helper'
+
+class AssertPathExistsTest < Minitest::Test
+  def test_registers_offense_when_using_assert_file_exist
+    assert_offense(<<~RUBY)
+      class FooTest < Minitest::Test
+        def test_do_something
+          assert(File.exist?(path))
+          ^^^^^^^^^^^^^^^^^^^^^^^^^ Prefer using `assert_path_exists(path)` over `assert(File.exist?(path))`.
+        end
+      end
+    RUBY
+
+    assert_correction(<<~RUBY)
+      class FooTest < Minitest::Test
+        def test_do_something
+          assert_path_exists(path)
+        end
+      end
+    RUBY
+  end
+
+  def test_registers_offense_when_using_assert_file_exist_and_message
+    assert_offense(<<~RUBY)
+      class FooTest < Minitest::Test
+        def test_do_something
+          assert(File.exist?(path), 'message')
+          ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ Prefer using `assert_path_exists(path, 'message')` over `assert(File.exist?(path), 'message')`.
+        end
+      end
+    RUBY
+
+    assert_correction(<<~RUBY)
+      class FooTest < Minitest::Test
+        def test_do_something
+          assert_path_exists(path, 'message')
+        end
+      end
+    RUBY
+  end
+
+  def test_does_not_register_offense_when_using_assert_path_exists_method
+    assert_no_offenses(<<~RUBY)
+      class FooTest < Minitest::Test
+        def test_do_something
+          assert_path_exists(path)
+        end
+      end
+    RUBY
+  end
+end

test/rubocop/cop/minitest/refute_path_exists_test.rb

@@ -0,0 +1,53 @@
+# frozen_string_literal: true
+
+require 'test_helper'
+
+class RefutePathExistsTest < Minitest::Test
+  def test_registers_offense_when_using_refute_file_exist
+    assert_offense(<<~RUBY)
+      class FooTest < Minitest::Test
+        def test_do_something
+          refute(File.exist?(path))
+          ^^^^^^^^^^^^^^^^^^^^^^^^^ Prefer using `refute_path_exists(path)` over `refute(File.exist?(path))`.
+        end
+      end
+    RUBY
+
+    assert_correction(<<~RUBY)
+      class FooTest < Minitest::Test
+        def test_do_something
+          refute_path_exists(path)
+        end
+      end
+    RUBY
+  end
+
+  def test_registers_offense_when_using_refute_file_exist_and_message
+    assert_offense(<<~RUBY)
+      class FooTest < Minitest::Test
+        def test_do_something
+          refute(File.exist?(path), 'message')
+          ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ Prefer using `refute_path_exists(path, 'message')` over `refute(File.exist?(path), 'message')`.
+        end
+      end
+    RUBY
+
+    assert_correction(<<~RUBY)
+      class FooTest < Minitest::Test
+        def test_do_something
+          refute_path_exists(path, 'message')
+        end
+      end
+    RUBY
+  end
+
+  def test_does_not_register_offense_when_using_refute_path_exists_method
+    assert_no_offenses(<<~RUBY)
+      class FooTest < Minitest::Test
+        def test_do_something
+          refute_path_exists(path)
+        end
+      end
+    RUBY
+  end
+end