rubocop-minitest 0.11.0 → 0.14.0

data/lib/rubocop/cop/minitest/assert_truthy.rb

@@ -15,8 +15,9 @@ module RuboCop
       #   assert(actual)
       #   assert(actual, 'message')
       #
-      class AssertTruthy < Cop
+      class AssertTruthy < Base
         include ArgumentRangeHelper
+        extend AutoCorrector
 
         MSG = 'Prefer using `assert(%<arguments>s)` over ' \
               '`assert_equal(true, %<arguments>s)`.'
@@ -32,17 +33,9 @@ module RuboCop
 
             arguments = [actual.source, message&.source].compact.join(', ')
 
-            add_offense(node, message: format(MSG, arguments: arguments))
-          end
-        end
-
-        def autocorrect(node)
-          lambda do |corrector|
-            assert_equal_with_truthy(node) do |actual|
+            add_offense(node, message: format(MSG, arguments: arguments)) do |corrector|
               corrector.replace(node.loc.selector, 'assert')
-              corrector.replace(
-                first_and_second_arguments_range(node), actual.source
-              )
+              corrector.replace(first_and_second_arguments_range(node), actual.source)
             end
           end
         end

data/lib/rubocop/cop/minitest/assert_with_expected_argument.rb

@@ -6,6 +6,9 @@ module RuboCop
       # This cop tries to detect when a user accidentally used
       # `assert` when they meant to use `assert_equal`.
       #
+      # It is marked as unsafe because it is not possible to determine
+      # whether the second argument of `assert` is a message or not.
+      #
       # @example
       #   # bad
       #   assert(3, my_list.length)
@@ -16,7 +19,7 @@ module RuboCop
       #   assert_equal(expected, actual)
       #   assert(foo, 'message')
       #
-      class AssertWithExpectedArgument < Cop
+      class AssertWithExpectedArgument < Base
         MSG = 'Did you mean to use `assert_equal(%<arguments>s)`?'
         RESTRICT_ON_SEND = %i[assert].freeze
 

data/lib/rubocop/cop/minitest/assertion_in_lifecycle_hook.rb

@@ -20,7 +20,7 @@ module RuboCop
       #     end
       #   end
       #
-      class AssertionInLifecycleHook < Cop
+      class AssertionInLifecycleHook < Base
         include MinitestExplorationHelpers
 
         MSG = 'Do not use `%<assertion>s` in `%<hook>s` hook.'

data/lib/rubocop/cop/minitest/global_expectations.rb

@@ -16,7 +16,9 @@ module RuboCop
       #   _(musts).must_equal expected_musts
       #   _(wonts).wont_match expected_wonts
       #   _ { musts }.must_raise TypeError
-      class GlobalExpectations < Cop
+      class GlobalExpectations < Base
+        extend AutoCorrector
+
         MSG = 'Use `%<preferred>s` instead.'
 
         VALUE_MATCHERS = %i[
@@ -64,13 +66,8 @@ module RuboCop
           return unless value_global_expectation?(node) || block_global_expectation?(node)
 
           message = format(MSG, preferred: preferred_receiver(node))
-          add_offense(node, location: node.receiver.source_range, message: message)
-        end
-
-        def autocorrect(node)
-          return unless value_global_expectation?(node) || block_global_expectation?(node)
 
-          lambda do |corrector|
+          add_offense(node.receiver.source_range, message: message) do |corrector|
             receiver = node.receiver.source_range
 
             if BLOCK_MATCHERS.include?(node.method_name)

data/lib/rubocop/cop/minitest/literal_as_actual_argument.rb

@@ -17,8 +17,9 @@ module RuboCop
       #   assert_equal [1, 2], foo
       #   assert_equal [1, 2], foo, 'message'
       #
-      class LiteralAsActualArgument < Cop
+      class LiteralAsActualArgument < Base
         include ArgumentRangeHelper
+        extend AutoCorrector
 
         MSG = 'Replace the literal with the first argument.'
         RESTRICT_ON_SEND = %i[assert_equal].freeze
@@ -27,25 +28,24 @@ module RuboCop
           return unless node.method?(:assert_equal)
 
           actual = node.arguments[1]
-          return unless actual
+          return unless actual&.recursive_basic_literal?
 
-          add_offense(node, location: all_arguments_range(node)) if actual.recursive_basic_literal?
+          add_offense(all_arguments_range(node)) do |corrector|
+            autocorrect(corrector, node)
+          end
         end
 
-        def autocorrect(node)
+        def autocorrect(corrector, node)
           expected, actual, message = *node.arguments
 
-          lambda do |corrector|
-            new_actual_source =
-              if actual.hash_type? && !actual.braces?
-                "{#{actual.source}}"
-              else
-                actual.source
-              end
-            arguments = [new_actual_source, expected.source, message&.source].compact.join(', ')
+          new_actual_source = if actual.hash_type? && !actual.braces?
+                                "{#{actual.source}}"
+                              else
+                                actual.source
+                              end
+          arguments = [new_actual_source, expected.source, message&.source].compact.join(', ')
 
-            corrector.replace(node, "assert_equal(#{arguments})")
-          end
+          corrector.replace(node, "assert_equal(#{arguments})")
         end
       end
     end

data/lib/rubocop/cop/minitest/multiple_assertions.rb

@@ -26,7 +26,7 @@ module RuboCop
       #     end
       #   end
       #
-      class MultipleAssertions < Cop
+      class MultipleAssertions < Base
         include ConfigurableMax
         include MinitestExplorationHelpers
 
@@ -43,7 +43,7 @@ module RuboCop
             self.max = assertions_count
 
             message = format(MSG, total: assertions_count, max: max_assertions)
-            add_offense(node, location: :name, message: message)
+            add_offense(node, message: message)
           end
         end
 

data/lib/rubocop/cop/minitest/no_assertions.rb

@@ -0,0 +1,48 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Minitest
+      # This cop checks if test cases contain any assertion calls.
+      #
+      # @example
+      #   # bad
+      #   class FooTest < Minitest::Test
+      #     def test_the_truth
+      #     end
+      #   end
+      #
+      #   # good
+      #   class FooTest < Minitest::Test
+      #     def test_the_truth
+      #       assert true
+      #     end
+      #   end
+      #
+      class NoAssertions < Base
+        include MinitestExplorationHelpers
+
+        MSG = 'Test case has no assertions.'
+
+        def on_class(class_node)
+          return unless test_class?(class_node)
+
+          test_cases(class_node).each do |node|
+            assertions_count = assertions_count(node)
+
+            next if assertions_count.positive?
+
+            add_offense(node.block_type? ? node.loc.expression : node.loc.name)
+          end
+        end
+
+        private
+
+        def assertions_count(node)
+          base = assertion?(node) ? 1 : 0
+          base + node.each_child_node.sum { |c| assertions_count(c) }
+        end
+      end
+    end
+  end
+end

data/lib/rubocop/cop/minitest/refute_empty.rb

@@ -15,7 +15,7 @@ module RuboCop
       #   refute_empty(object)
       #   refute_empty(object, 'message')
       #
-      class RefuteEmpty < Cop
+      class RefuteEmpty < Base
         extend MinitestCopRule
 
         define_rule :refute, target_method: :empty?

data/lib/rubocop/cop/minitest/refute_equal.rb

@@ -14,8 +14,9 @@ module RuboCop
       #   # good
       #   refute_equal("rubocop-minitest", actual)
       #
-      class RefuteEqual < Cop
+      class RefuteEqual < Base
         include ArgumentRangeHelper
+        extend AutoCorrector
 
         MSG = 'Prefer using `refute_equal(%<preferred>s)` over ' \
               '`assert(%<over>s)`.'
@@ -29,13 +30,10 @@ module RuboCop
           preferred, over = process_not_equal(node)
           return unless preferred && over
 
-          message = format(MSG, preferred: preferred, over: over)
-          add_offense(node, message: message)
-        end
+          assert_not_equal(node) do |_, expected, actual|
+            message = format(MSG, preferred: preferred, over: over)
 
-        def autocorrect(node)
-          lambda do |corrector|
-            assert_not_equal(node) do |_, expected, actual|
+            add_offense(node, message: message) do |corrector|
               corrector.replace(node.loc.selector, 'refute_equal')
 
               replacement = [expected, actual].map(&:source).join(', ')

data/lib/rubocop/cop/minitest/refute_false.rb

@@ -18,13 +18,12 @@ module RuboCop
       #   refute(actual)
       #   refute(actual, 'message')
       #
-      class RefuteFalse < Cop
+      class RefuteFalse < Base
         include ArgumentRangeHelper
+        extend AutoCorrector
 
-        MSG_FOR_ASSERT_EQUAL = 'Prefer using `refute(%<arguments>s)` over ' \
-              '`assert_equal(false, %<arguments>s)`.'
-        MSG_FOR_ASSERT = 'Prefer using `refute(%<arguments>s)` over ' \
-              '`assert(!%<arguments>s)`.'
+        MSG_FOR_ASSERT_EQUAL = 'Prefer using `refute(%<arguments>s)` over `assert_equal(false, %<arguments>s)`.'
+        MSG_FOR_ASSERT = 'Prefer using `refute(%<arguments>s)` over `assert(!%<arguments>s)`.'
         RESTRICT_ON_SEND = %i[assert_equal assert].freeze
 
         def_node_matcher :assert_equal_with_false, <<~PATTERN
@@ -36,38 +35,29 @@ module RuboCop
         PATTERN
 
         def on_send(node)
-          actual, rest_receiver_arg = assert_equal_with_false(node) ||
-                                      assert_with_bang_argument(node)
+          actual, rest_receiver_arg = assert_equal_with_false(node) || assert_with_bang_argument(node)
           return unless actual
 
           message_argument = rest_receiver_arg.first
 
           arguments = [actual.source, message_argument&.source].compact.join(', ')
 
-          message = if node.method?(:assert_equal)
-                      MSG_FOR_ASSERT_EQUAL
-                    else
-                      MSG_FOR_ASSERT
-                    end
+          message = node.method?(:assert_equal) ? MSG_FOR_ASSERT_EQUAL : MSG_FOR_ASSERT
 
-          add_offense(node, message: format(message, arguments: arguments))
+          add_offense(node, message: format(message, arguments: arguments)) do |corrector|
+            autocorrect(corrector, node, actual)
+          end
         end
 
-        def autocorrect(node)
-          lambda do |corrector|
-            corrector.replace(node.loc.selector, 'refute')
+        private
 
-            assert_equal_with_false(node) do |actual|
-              corrector.replace(
-                first_and_second_arguments_range(node), actual.source
-              )
-            end
+        def autocorrect(corrector, node, actual)
+          corrector.replace(node.loc.selector, 'refute')
 
-            assert_with_bang_argument(node) do |actual|
-              corrector.replace(
-                first_argument_range(node), actual.source
-              )
-            end
+          if node.method?(:assert_equal)
+            corrector.replace(first_and_second_arguments_range(node), actual.source)
+          else
+            corrector.replace(first_argument_range(node), actual.source)
           end
         end
       end

data/lib/rubocop/cop/minitest/refute_in_delta.rb

@@ -15,8 +15,9 @@ module RuboCop
       #   refute_in_delta(0.2, actual)
       #   refute_in_delta(0.2, actual, 0.001, 'message')
       #
-      class RefuteInDelta < Cop
+      class RefuteInDelta < Base
         include InDeltaMixin
+        extend AutoCorrector
 
         RESTRICT_ON_SEND = %i[refute_equal].freeze
 

data/lib/rubocop/cop/minitest/refute_includes.rb

@@ -15,7 +15,7 @@ module RuboCop
       #   refute_includes(collection, object)
       #   refute_includes(collection, object, 'message')
       #
-      class RefuteIncludes < Cop
+      class RefuteIncludes < Base
         extend MinitestCopRule
 
         define_rule :refute, target_method: :include?, preferred_method: :refute_includes

data/lib/rubocop/cop/minitest/refute_instance_of.rb

@@ -15,7 +15,7 @@ module RuboCop
       #   refute_instance_of(Class, object)
       #   refute_instance_of(Class, object, 'message')
       #
-      class RefuteInstanceOf < Cop
+      class RefuteInstanceOf < Base
         extend MinitestCopRule
 
         define_rule :refute, target_method: :instance_of?, inverse: true

data/lib/rubocop/cop/minitest/refute_kind_of.rb

@@ -15,7 +15,7 @@ module RuboCop
       #   refute_kind_of(Class, object)
       #   refute_kind_of(Class, object, 'message')
       #
-      class RefuteKindOf < Cop
+      class RefuteKindOf < Base
         extend MinitestCopRule
 
         define_rule :refute, target_method: :kind_of?, inverse: true

data/lib/rubocop/cop/minitest/refute_match.rb

@@ -15,7 +15,7 @@ module RuboCop
       #   refute_match(matcher, string)
       #   refute_match(matcher, string, 'message')
       #
-      class RefuteMatch < Cop
+      class RefuteMatch < Base
         extend MinitestCopRule
 
         define_rule :refute, target_method: :match

data/lib/rubocop/cop/minitest/refute_nil.rb

@@ -15,8 +15,9 @@ module RuboCop
       #   refute_nil(actual)
       #   refute_nil(actual, 'message')
       #
-      class RefuteNil < Cop
+      class RefuteNil < Base
         include ArgumentRangeHelper
+        extend AutoCorrector
 
         MSG = 'Prefer using `refute_nil(%<arguments>s)` over ' \
               '`refute_equal(nil, %<arguments>s)`.'
@@ -32,13 +33,7 @@ module RuboCop
 
             arguments = [actual.source, message&.source].compact.join(', ')
 
-            add_offense(node, message: format(MSG, arguments: arguments))
-          end
-        end
-
-        def autocorrect(node)
-          lambda do |corrector|
-            refute_equal_with_nil(node) do |actual|
+            add_offense(node, message: format(MSG, arguments: arguments)) do |corrector|
               corrector.replace(node.loc.selector, 'refute_nil')
               corrector.replace(
                 first_and_second_arguments_range(node), actual.source

data/lib/rubocop/cop/minitest/refute_path_exists.rb

@@ -15,7 +15,9 @@ module RuboCop
       #   refute_path_exists(path)
       #   refute_path_exists(path, 'message')
       #
-      class RefutePathExists < Cop
+      class RefutePathExists < Base
+        extend AutoCorrector
+
         MSG = 'Prefer using `%<good_method>s` over `%<bad_method>s`.'
         RESTRICT_ON_SEND = %i[refute].freeze
 
@@ -32,17 +34,8 @@ module RuboCop
             good_method = build_good_method(path, failure_message)
             message = format(MSG, good_method: good_method, bad_method: node.source)
 
-            add_offense(node, message: message)
-          end
-        end
-
-        def autocorrect(node)
-          refute_file_exists(node) do |path, failure_message|
-            failure_message = failure_message.first
-
-            lambda do |corrector|
-              replacement = build_good_method(path, failure_message)
-              corrector.replace(node, replacement)
+            add_offense(node, message: message) do |corrector|
+              corrector.replace(node, good_method)
             end
           end
         end

data/lib/rubocop/cop/minitest/refute_respond_to.rb

@@ -17,7 +17,7 @@ module RuboCop
       #   refute_respond_to(object, :do_something, 'message')
       #   refute_respond_to(self, :do_something)
       #
-      class RefuteRespondTo < Cop
+      class RefuteRespondTo < Base
         extend MinitestCopRule
 
         define_rule :refute, target_method: :respond_to?

data/lib/rubocop/cop/minitest/test_method_name.rb

@@ -27,9 +27,10 @@ module RuboCop
       #     end
       #   end
       #
-      class TestMethodName < Cop
+      class TestMethodName < Base
         include MinitestExplorationHelpers
         include DefNode
+        extend AutoCorrector
 
         MSG = 'Test method name should start with `test_` prefix.'
 
@@ -37,13 +38,13 @@ module RuboCop
           return unless test_class?(class_node)
 
           class_elements(class_node).each do |node|
-            add_offense(node, location: :name) if offense?(node)
-          end
-        end
+            next unless offense?(node)
+
+            test_method_name = node.loc.name
 
-        def autocorrect(node)
-          lambda do |corrector|
-            corrector.replace(node.loc.name, "test_#{node.method_name}")
+            add_offense(test_method_name) do |corrector|
+              corrector.replace(test_method_name, "test_#{node.method_name}")
+            end
           end
         end