rubocop-minitest 0.32.2 → 0.34.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: ce290f7a13faed25c00a17d9daf8bcaf17e187599a075323fc99f8494c29c2bb
-  data.tar.gz: 9def860d52f65aed4e8923bcf2fd851a5188485986c7ad5bce44a9dc0d79b2d3
+  metadata.gz: 571b1db9fefc76fa80002c19d3717b845d1db2233f4e42334be77c000e6e4c97
+  data.tar.gz: 9e415cf5f10bd9fe304cf4e7e06ddc8e429fd44f8f81736db6399ff49e159014
 SHA512:
-  metadata.gz: 8db20fcf7d8e58b564da63b85f6692c4a2be189ffeacdc654f4b18ea689416688442df945606c84f55e63b9007c8df51b4f173004a7ae145603733f6bac62c61
-  data.tar.gz: 41232dfbabd012e4edbe1e78b49f1846004246950773a6f06c50fff358cb71a79fbdcd95ed0657690387801331093606c2dabb376788368cf51438ff84846be4
+  metadata.gz: c4e0adcffeec5f46c694480f7a4d99c04f76545694318c1b660f5dcde4eb6e0626f07bd2d25a9d1042019223cc393fae17555a98fe9d6fbcc567c790cc3aee4d
+  data.tar.gz: 4ba96bd280bec762d6256e40f16e40c2831cddb78c7df75ef172c0ca50d6d55ab8ec61499f05cc613cdc9925ab3f370c21bf8bb6f047591b3aae9db45f8117cd

data/README.md

@@ -53,6 +53,8 @@ $ rubocop --require rubocop-minitest
 ### Rake task
 
 ```ruby
+require 'rubocop/rake_task'
+
 RuboCop::RakeTask.new do |task|
   task.requires << 'rubocop-minitest'
 end

data/config/default.yml

@@ -192,12 +192,23 @@ Minitest/NoTestCases:
   Enabled: false
   VersionAdded: '0.30'
 
+Minitest/NonExecutableTestMethod:
+  Description: 'Checks uses of test methods outside test class.'
+  Enabled: pending
+  Severity: warning
+  VersionAdded: '0.34'
+
 Minitest/NonPublicTestMethod:
   Description: 'Detects non `public` (marked as `private` or `protected`) test methods.'
   Enabled: pending
   Severity: warning
   VersionAdded: '0.27'
 
+Minitest/RedundantMessageArgument:
+  Description: 'Detects redundant message argument in assertion methods.'
+  Enabled: pending
+  VersionAdded: '0.34'
+
 Minitest/RefuteEmpty:
   Description: 'This cop enforces to use `refute_empty` instead of using `refute(object.empty?)`.'
   StyleGuide: 'https://minitest.rubystyle.guide#refute-empty'

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

@@ -22,12 +22,11 @@ module RuboCop
         remove_method :on_send
         def on_send(node)
           return unless node.method?(:assert)
-          return unless (arguments = peel_redundant_parentheses_from(node.arguments))
-          return unless arguments.first.respond_to?(:method?) && arguments.first.method?(:empty?)
-          return unless arguments.first.arguments.empty?
+          return unless node.first_argument.respond_to?(:method?) && node.first_argument.method?(:empty?)
+          return unless node.first_argument.arguments.empty?
 
-          add_offense(node, message: offense_message(arguments)) do |corrector|
-            autocorrect(corrector, node, arguments)
+          add_offense(node, message: offense_message(node.arguments)) do |corrector|
+            autocorrect(corrector, node, node.arguments)
           end
         end
       end

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

@@ -9,14 +9,46 @@ module RuboCop
       # @example
       #   # bad
       #   assert("rubocop-minitest" == actual)
+      #   assert_operator("rubocop-minitest", :==, actual)
       #
       #   # good
       #   assert_equal("rubocop-minitest", actual)
       #
       class AssertEqual < Base
-        extend MinitestCopRule
+        include ArgumentRangeHelper
+        extend AutoCorrector
 
-        define_rule :assert, target_method: :==, preferred_method: :assert_equal
+        MSG = 'Prefer using `assert_equal(%<preferred>s)`.'
+        RESTRICT_ON_SEND = %i[assert assert_operator].freeze
+
+        def_node_matcher :assert_equal, <<~PATTERN
+          {
+            (send nil? :assert (send $_ :== $_) $...)
+            (send nil? :assert_operator $_ (sym :==) $_ $...)
+          }
+        PATTERN
+
+        # rubocop:disable Metrics/AbcSize
+        def on_send(node)
+          assert_equal(node) do |expected, actual, rest_args|
+            basic_arguments = "#{expected.source}, #{actual.source}"
+            preferred = (message_arg = rest_args.first) ? "#{basic_arguments}, #{message_arg.source}" : basic_arguments
+            message = format(MSG, preferred: preferred)
+
+            add_offense(node, message: message) do |corrector|
+              corrector.replace(node.loc.selector, 'assert_equal')
+
+              range = if node.method?(:assert)
+                        node.first_argument
+                      else
+                        node.first_argument.source_range.begin.join(node.arguments[2].source_range.end)
+                      end
+
+              corrector.replace(range, basic_arguments)
+            end
+          end
+        end
+        # rubocop:enable Metrics/AbcSize
       end
     end
   end

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

@@ -11,6 +11,7 @@ module RuboCop
       #   assert(matcher.match(string))
       #   assert(matcher.match?(string))
       #   assert(matcher =~ string)
+      #   assert_operator(matcher, :=~, string)
       #   assert(matcher.match(string), 'message')
       #
       #   # good
@@ -18,10 +19,50 @@ module RuboCop
       #   assert_match(matcher, string, 'message')
       #
       class AssertMatch < Base
-        extend MinitestCopRule
+        include ArgumentRangeHelper
+        extend AutoCorrector
 
-        define_rule :assert, target_method: %i[match match? =~],
-                             preferred_method: :assert_match, inverse: 'regexp_type?'
+        MSG = 'Prefer using `assert_match(%<preferred>s)`.'
+        RESTRICT_ON_SEND = %i[assert assert_operator].freeze
+
+        def_node_matcher :assert_match, <<~PATTERN
+          {
+            (send nil? :assert (send $_ {:match :match? :=~} $_) $...)
+            (send nil? :assert_operator $_ (sym :=~) $_ $...)
+          }
+        PATTERN
+
+        # rubocop:disable Metrics/AbcSize
+        def on_send(node)
+          assert_match(node) do |expected, actual, rest_args|
+            basic_arguments = order_expected_and_actual(expected, actual)
+            preferred = (message_arg = rest_args.first) ? "#{basic_arguments}, #{message_arg.source}" : basic_arguments
+            message = format(MSG, preferred: preferred)
+
+            add_offense(node, message: message) do |corrector|
+              corrector.replace(node.loc.selector, 'assert_match')
+
+              range = if node.method?(:assert)
+                        node.first_argument
+                      else
+                        node.first_argument.source_range.begin.join(node.arguments[2].source_range.end)
+                      end
+
+              corrector.replace(range, basic_arguments)
+            end
+          end
+        end
+        # rubocop:enable Metrics/AbcSize
+
+        private
+
+        def order_expected_and_actual(expected, actual)
+          if actual.regexp_type?
+            [actual, expected]
+          else
+            [expected, actual]
+          end.map(&:source).join(', ')
+        end
       end
     end
   end

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

@@ -40,7 +40,7 @@ module RuboCop
 
         def build_new_arguments(node)
           lhs, op, rhs = *node.first_argument
-          new_arguments = "#{lhs.source}, :#{op}, #{rhs.source}"
+          new_arguments = +"#{lhs.source}, :#{op}, #{rhs.source}"
 
           if node.arguments.count == 2
             new_arguments << ", #{node.last_argument.source}"

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

@@ -12,14 +12,58 @@ module RuboCop
       # @example
       #   # bad
       #   assert(expected.equal?(actual))
+      #   assert_equal(expected.object_id, actual.object_id)
       #
       #   # good
       #   assert_same(expected, actual)
       #
       class AssertSame < Base
-        extend MinitestCopRule
+        extend AutoCorrector
 
-        define_rule :assert, target_method: :equal?, preferred_method: :assert_same
+        MSG = 'Prefer using `assert_same(%<new_arguments>s)`.'
+        RESTRICT_ON_SEND = %i[assert assert_equal].freeze
+
+        def_node_matcher :assert_with_equal?, <<~PATTERN
+          (send nil? :assert
+            $(send $_ :equal? $_)
+            $_?)
+        PATTERN
+
+        def_node_matcher :assert_equal_with_object_id?, <<~PATTERN
+          (send nil? :assert_equal
+            (send $_ :object_id)
+            (send $_ :object_id)
+            $_?)
+        PATTERN
+
+        # rubocop:disable Metrics/AbcSize
+        def on_send(node)
+          if (equal_node, expected_node, actual_node, message_node = assert_with_equal?(node))
+            add_offense(node, message: message(expected_node, actual_node, message_node.first)) do |corrector|
+              corrector.replace(node.loc.selector, 'assert_same')
+              corrector.replace(equal_node, "#{expected_node.source}, #{actual_node.source}")
+            end
+          elsif (expected_node, actual_node, message_node = assert_equal_with_object_id?(node))
+            add_offense(node, message: message(expected_node, actual_node, message_node.first)) do |corrector|
+              corrector.replace(node.loc.selector, 'assert_same')
+              remove_method_call(expected_node.parent, corrector)
+              remove_method_call(actual_node.parent, corrector)
+            end
+          end
+        end
+        # rubocop:enable Metrics/AbcSize
+
+        private
+
+        def message(expected_node, actual_node, message_node)
+          arguments = [expected_node, actual_node, message_node].compact.map(&:source).join(', ')
+          format(MSG, new_arguments: arguments)
+        end
+
+        def remove_method_call(send_node, corrector)
+          range = send_node.loc.dot.join(send_node.loc.selector)
+          corrector.remove(range)
+        end
       end
     end
   end

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

@@ -30,7 +30,7 @@ module RuboCop
           return if node.parent.resbody_type?
           return if accept_previous_line?(previous_line_node, assertion_method)
 
-          previous_line_node = previous_line_node.arguments.last if use_heredoc_argument?(previous_line_node)
+          previous_line_node = previous_line_node.last_argument if use_heredoc_argument?(previous_line_node)
           return if use_assertion_method_at_last_of_block?(previous_line_node)
           return unless no_empty_line?(previous_line_node, assertion_method)
 
@@ -57,7 +57,7 @@ module RuboCop
         end
 
         def use_heredoc_argument?(node)
-          node.respond_to?(:arguments) && heredoc?(node.arguments.last)
+          node.respond_to?(:arguments) && heredoc?(node.last_argument)
         end
 
         def use_assertion_method_at_last_of_block?(node)

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

@@ -0,0 +1,51 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Minitest
+      # Checks for the use of test methods outside of a test class.
+      #
+      # Test methods should be defined within a test class to ensure their execution.
+      #
+      # NOTE: This cop assumes that classes whose superclass name includes the word
+      # "`Test`" are test classes, in order to prevent false positives.
+      #
+      # @example
+      #
+      #   # bad
+      #   class FooTest < Minitest::Test
+      #   end
+      #   def test_method_should_be_inside_test_class
+      #   end
+      #
+      #   # good
+      #   class FooTest < Minitest::Test
+      #     def test_method_should_be_inside_test_class
+      #     end
+      #   end
+      #
+      class NonExecutableTestMethod < Base
+        include MinitestExplorationHelpers
+
+        MSG = 'Test method should be defined inside a test class to ensure execution.'
+
+        def on_def(node)
+          return if !test_method?(node) || !use_test_class?
+          return if node.left_siblings.none? { |sibling| possible_test_class?(sibling) }
+
+          add_offense(node)
+        end
+
+        def use_test_class?
+          root_node = processed_source.ast
+
+          root_node.each_descendant(:class).any? { |class_node| test_class?(class_node) }
+        end
+
+        def possible_test_class?(node)
+          node.is_a?(AST::ClassNode) && test_class?(node) && node.parent_class.source.include?('Test')
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,88 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Minitest
+      # Detects redundant message argument in assertion methods.
+      # The message argument `nil` is redundant because it is the default value.
+      #
+      # @example
+      #
+      #   # bad
+      #   assert_equal(expected, actual, nil)
+      #
+      #   # good
+      #   assert_equal(expected, actual)
+      #   assert_equal(expected, actual, 'message')
+      #
+      class RedundantMessageArgument < Base
+        extend AutoCorrector
+
+        MSG = 'Remove the redundant message argument.'
+
+        RESTRICT_ON_SEND = %i[
+          assert assert_empty assert_equal assert_same assert_in_delta assert_in_epsilon assert_includes
+          assert_instance_of assert_kind_of assert_match assert_nil assert_operator assert_path_exists
+          assert_predicate assert_respond_to assert_same assert_throws
+          flunk
+          refute refute_empty refute_equal refute_in_delta refute_in_epsilon refute_includes
+          refute_instance_of refute_kind_of refute_match refute_nil refute_operator refute_path_exists
+          refute_predicate refute_respond_to refute_same
+        ].freeze
+
+        # @!method bad_method?(node)
+        def_node_matcher :redundant_message_argument, <<~PATTERN
+          {
+            (send nil? :assert _ $nil)
+            (send nil? :assert_empty _ $nil)
+            (send nil? :assert_equal _ _ $nil)
+            (send nil? :assert_in_delta _ _ _ $nil)
+            (send nil? :assert_in_epsilon _ _ _ $nil)
+            (send nil? :assert_includes _ _ $nil)
+            (send nil? :assert_instance_of _ _ $nil)
+            (send nil? :assert_kind_of _ _ $nil)
+            (send nil? :assert_match _ _ $nil)
+            (send nil? :assert_nil _ $nil)
+            (send nil? :assert_operator _ _ _ $nil)
+            (send nil? :assert_path_exists _ $nil)
+            (send nil? :assert_predicate _ _ $nil)
+            (send nil? :assert_respond_to _ _ $nil)
+            (send nil? :assert_same _ _ $nil)
+            (send nil? :assert_throws _ $nil)
+            (send nil? :flunk $nil)
+            (send nil? :refute _ $nil)
+            (send nil? :refute_empty _ $nil)
+            (send nil? :refute_equal _ _ $nil)
+            (send nil? :refute_in_delta _ _ _ $nil)
+            (send nil? :refute_in_epsilon _ _ _ $nil)
+            (send nil? :refute_includes _ _ $nil)
+            (send nil? :refute_instance_of _ _ $nil)
+            (send nil? :refute_kind_of _ _ $nil)
+            (send nil? :refute_match _ _ $nil)
+            (send nil? :refute_nil _ $nil)
+            (send nil? :refute_operator _ _ _ $nil)
+            (send nil? :refute_path_exists _ $nil)
+            (send nil? :refute_predicate _ _ $nil)
+            (send nil? :refute_respond_to _ _ $nil)
+            (send nil? :refute_same _ _ $nil)
+          }
+        PATTERN
+
+        def on_send(node)
+          return unless (redundant_message_argument = redundant_message_argument(node))
+
+          add_offense(redundant_message_argument) do |corrector|
+            if node.arguments.one?
+              range = redundant_message_argument
+            else
+              index = node.arguments.index(redundant_message_argument)
+              range = node.arguments[index - 1].source_range.end.join(redundant_message_argument.source_range.end)
+            end
+
+            corrector.remove(range)
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -22,12 +22,11 @@ module RuboCop
         remove_method :on_send
         def on_send(node)
           return unless node.method?(:refute)
-          return unless (arguments = peel_redundant_parentheses_from(node.arguments))
-          return unless arguments.first.respond_to?(:method?) && arguments.first.method?(:empty?)
-          return unless arguments.first.arguments.empty?
+          return unless node.first_argument.respond_to?(:method?) && node.first_argument.method?(:empty?)
+          return unless node.first_argument.arguments.empty?
 
-          add_offense(node, message: offense_message(arguments)) do |corrector|
-            autocorrect(corrector, node, arguments)
+          add_offense(node, message: offense_message(node.arguments)) do |corrector|
+            autocorrect(corrector, node, node.arguments)
           end
         end
       end

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

@@ -9,6 +9,9 @@ module RuboCop
       # @example
       #   # bad
       #   assert("rubocop-minitest" != actual)
+      #   refute("rubocop-minitest" == actual)
+      #   assert_operator("rubocop-minitest", :!=, actual)
+      #   refute_operator("rubocop-minitest", :==, actual)
       #
       #   # good
       #   refute_equal("rubocop-minitest", actual)
@@ -18,45 +21,38 @@ module RuboCop
         extend AutoCorrector
 
         MSG = 'Prefer using `refute_equal(%<preferred>s)`.'
-        RESTRICT_ON_SEND = %i[assert].freeze
-
-        def_node_matcher :assert_not_equal, <<~PATTERN
-          (send nil? :assert (send $_ :!= $_) $... )
+        RESTRICT_ON_SEND = %i[assert refute assert_operator refute_operator].freeze
+
+        def_node_matcher :refute_equal, <<~PATTERN
+          {
+            (send nil? :assert (send $_ :!= $_) $...)
+            (send nil? :refute (send $_ :== $_) $...)
+            (send nil? :assert_operator $_ (sym :!=) $_ $...)
+            (send nil? :refute_operator $_ (sym :==) $_ $...)
+          }
         PATTERN
 
+        # rubocop:disable Metrics/AbcSize
         def on_send(node)
-          preferred = process_not_equal(node)
-          return unless preferred
-
-          assert_not_equal(node) do |expected, actual|
+          refute_equal(node) do |expected, actual, rest_args|
+            basic_arguments = "#{expected.source}, #{actual.source}"
+            preferred = (message_arg = rest_args.first) ? "#{basic_arguments}, #{message_arg.source}" : basic_arguments
             message = format(MSG, preferred: preferred)
 
             add_offense(node, message: message) do |corrector|
               corrector.replace(node.loc.selector, 'refute_equal')
 
-              replacement = [expected, actual].map(&:source).join(', ')
-              corrector.replace(node.first_argument, replacement)
-            end
-          end
-        end
-
-        private
+              range = if node.method?(:assert) || node.method?(:refute)
+                        node.first_argument
+                      else
+                        node.first_argument.source_range.begin.join(node.arguments[2].source_range.end)
+                      end
 
-        def preferred_usage(first_arg, second_arg, custom_message = nil)
-          [first_arg, second_arg, custom_message].compact.map(&:source).join(', ')
-        end
-
-        def original_usage(first_part, custom_message)
-          [first_part, custom_message].compact.join(', ')
-        end
-
-        def process_not_equal(node)
-          assert_not_equal(node) do |first_arg, second_arg, rest_args|
-            custom_message = rest_args.first
-
-            preferred_usage(first_arg, second_arg, custom_message)
+              corrector.replace(range, basic_arguments)
+            end
           end
         end
+        # rubocop:enable Metrics/AbcSize
       end
     end
   end

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

@@ -11,6 +11,8 @@ module RuboCop
       #   refute(matcher.match(string))
       #   refute(matcher.match?(string))
       #   refute(matcher =~ string)
+      #   refute_operator(matcher, :=~, string)
+      #   assert_operator(matcher, :!~, string)
       #   refute(matcher.match(string), 'message')
       #
       #   # good
@@ -18,10 +20,51 @@ module RuboCop
       #   refute_match(matcher, string, 'message')
       #
       class RefuteMatch < Base
-        extend MinitestCopRule
+        include ArgumentRangeHelper
+        extend AutoCorrector
 
-        define_rule :refute, target_method: %i[match match? =~],
-                             preferred_method: :refute_match, inverse: 'regexp_type?'
+        MSG = 'Prefer using `refute_match(%<preferred>s)`.'
+        RESTRICT_ON_SEND = %i[refute refute_operator assert_operator].freeze
+
+        def_node_matcher :refute_match, <<~PATTERN
+          {
+            (send nil? :refute (send $_ {:match :match? :=~} $_) $...)
+            (send nil? :refute_operator $_ (sym :=~) $_ $...)
+            (send nil? :assert_operator $_ (sym :!~) $_ $...)
+          }
+        PATTERN
+
+        # rubocop:disable Metrics/AbcSize
+        def on_send(node)
+          refute_match(node) do |expected, actual, rest_args|
+            basic_arguments = order_expected_and_actual(expected, actual)
+            preferred = (message_arg = rest_args.first) ? "#{basic_arguments}, #{message_arg.source}" : basic_arguments
+            message = format(MSG, preferred: preferred)
+
+            add_offense(node, message: message) do |corrector|
+              corrector.replace(node.loc.selector, 'refute_match')
+
+              range = if node.method?(:refute)
+                        node.first_argument
+                      else
+                        node.first_argument.source_range.begin.join(node.arguments[2].source_range.end)
+                      end
+
+              corrector.replace(range, basic_arguments)
+            end
+          end
+        end
+        # rubocop:enable Metrics/AbcSize
+
+        private
+
+        def order_expected_and_actual(expected, actual)
+          if actual.regexp_type?
+            [actual, expected]
+          else
+            [expected, actual]
+          end.map(&:source).join(', ')
+        end
       end
     end
   end

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

@@ -40,7 +40,7 @@ module RuboCop
 
         def build_new_arguments(node)
           lhs, op, rhs = *node.first_argument
-          new_arguments = "#{lhs.source}, :#{op}, #{rhs.source}"
+          new_arguments = +"#{lhs.source}, :#{op}, #{rhs.source}"
 
           if node.arguments.count == 2
             new_arguments << ", #{node.last_argument.source}"

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

@@ -12,14 +12,58 @@ module RuboCop
       # @example
       #   # bad
       #   refute(expected.equal?(actual))
+      #   refute_equal(expected.object_id, actual.object_id)
       #
       #   # good
       #   refute_same(expected, actual)
       #
       class RefuteSame < Base
-        extend MinitestCopRule
+        extend AutoCorrector
 
-        define_rule :refute, target_method: :equal?, preferred_method: :refute_same
+        MSG = 'Prefer using `refute_same(%<new_arguments>s)`.'
+        RESTRICT_ON_SEND = %i[refute refute_equal].freeze
+
+        def_node_matcher :refute_with_equal?, <<~PATTERN
+          (send nil? :refute
+            $(send $_ :equal? $_)
+            $_?)
+        PATTERN
+
+        def_node_matcher :refute_equal_with_object_id?, <<~PATTERN
+          (send nil? :refute_equal
+            (send $_ :object_id)
+            (send $_ :object_id)
+            $_?)
+        PATTERN
+
+        # rubocop:disable Metrics/AbcSize
+        def on_send(node)
+          if (equal_node, expected_node, actual_node, message_node = refute_with_equal?(node))
+            add_offense(node, message: message(expected_node, actual_node, message_node.first)) do |corrector|
+              corrector.replace(node.loc.selector, 'refute_same')
+              corrector.replace(equal_node, "#{expected_node.source}, #{actual_node.source}")
+            end
+          elsif (expected_node, actual_node, message_node = refute_equal_with_object_id?(node))
+            add_offense(node, message: message(expected_node, actual_node, message_node.first)) do |corrector|
+              corrector.replace(node.loc.selector, 'refute_same')
+              remove_method_call(expected_node.parent, corrector)
+              remove_method_call(actual_node.parent, corrector)
+            end
+          end
+        end
+        # rubocop:enable Metrics/AbcSize
+
+        private
+
+        def message(expected_node, actual_node, message_node)
+          arguments = [expected_node, actual_node, message_node].compact.map(&:source).join(', ')
+          format(MSG, new_arguments: arguments)
+        end
+
+        def remove_method_call(send_node, corrector)
+          range = send_node.loc.dot.join(send_node.loc.selector)
+          corrector.remove(range)
+        end
       end
     end
   end

data/lib/rubocop/cop/minitest_cops.rb

@@ -30,6 +30,8 @@ require_relative 'minitest/assert_silent'
 require_relative 'minitest/assert_truthy'
 require_relative 'minitest/duplicate_test_run'
 require_relative 'minitest/empty_line_before_assertion_methods'
+require_relative 'minitest/non_executable_test_method'
+require_relative 'minitest/redundant_message_argument'
 require_relative 'minitest/return_in_test_method'
 require_relative 'minitest/test_file_name'
 require_relative 'minitest/global_expectations'

data/lib/rubocop/cop/mixin/argument_range_helper.rb

@@ -18,7 +18,7 @@ module RuboCop
 
       def all_arguments_range(node)
         first_argument = node.first_argument
-        last_argument = node.arguments.last
+        last_argument = node.last_argument
 
         range_between(first_argument.source_range.begin_pos, last_argument.source_range.end_pos)
       end

data/lib/rubocop/cop/mixin/minitest_cop_rule.rb

@@ -45,13 +45,12 @@ module RuboCop
 
           def on_send(node)
             return unless node.method?(:#{assertion_method})
-            return unless (arguments = peel_redundant_parentheses_from(node.arguments))
-            return unless arguments.first&.call_type?
-            return if arguments.first.arguments.empty? ||
-                      #{target_methods}.none? { |target_method| arguments.first.method?(target_method) }
+            return unless node.arguments.first&.call_type?
+            return if node.arguments.first.arguments.empty? ||
+                      #{target_methods}.none? { |target_method| node.arguments.first.method?(target_method) }
 
-            add_offense(node, message: offense_message(arguments)) do |corrector|
-              autocorrect(corrector, node, arguments)
+            add_offense(node, message: offense_message(node.arguments)) do |corrector|
+              autocorrect(corrector, node, node.arguments)
             end
           end
 
@@ -60,21 +59,11 @@ module RuboCop
 
             new_arguments = new_arguments(arguments).join(', ')
 
-            if enclosed_in_redundant_parentheses?(node)
-              new_arguments = '(' + new_arguments + ')'
-            end
-
             corrector.replace(node.first_argument, new_arguments)
           end
 
           private
 
-          def peel_redundant_parentheses_from(arguments)
-            return arguments unless arguments.first&.begin_type?
-
-            peel_redundant_parentheses_from(arguments.first.children)
-          end
-
           def offense_message(arguments)
             message_argument = arguments.last if arguments.first != arguments.last
 
@@ -103,10 +92,6 @@ module RuboCop
             new_arguments
           end
 
-          def enclosed_in_redundant_parentheses?(node)
-            node.arguments.first.begin_type?
-          end
-
           def correct_receiver(receiver)
             receiver ? receiver.source : 'self'
           end

data/lib/rubocop/cop/mixin/minitest_exploration_helpers.rb

@@ -100,6 +100,7 @@ module RuboCop
       end
 
       def assertion_method?(node)
+        return assertion_method?(node.expression) if node.assignment?
         return false if !node.send_type? && !node.block_type? && !node.numblock_type?
 
         ASSERTION_PREFIXES.any? do |prefix|

data/lib/rubocop/cop/mixin/predicate_assertion_handleable.rb

@@ -9,17 +9,13 @@ module RuboCop
         MSG = 'Prefer using `%<assertion_type>s_predicate(%<new_arguments>s)`.'
 
         def on_send(node)
-          return unless (arguments = peel_redundant_parentheses_from(node.arguments))
+          return unless node.first_argument
+          return if node.first_argument.block_type? || node.first_argument.numblock_type?
+          return unless predicate_method?(node.first_argument)
+          return unless node.first_argument.arguments.count.zero?
 
-          first_argument = arguments.first
-
-          return unless first_argument
-          return if first_argument.block_type? || first_argument.numblock_type?
-          return unless predicate_method?(first_argument)
-          return unless first_argument.arguments.count.zero?
-
-          add_offense(node, message: offense_message(arguments)) do |corrector|
-            autocorrect(corrector, node, arguments)
+          add_offense(node, message: offense_message(node.arguments)) do |corrector|
+            autocorrect(corrector, node, node.arguments)
           end
         end
 
@@ -33,12 +29,6 @@ module RuboCop
 
         private
 
-        def peel_redundant_parentheses_from(arguments)
-          return arguments unless arguments.first&.begin_type?
-
-          peel_redundant_parentheses_from(arguments.first.children)
-        end
-
         def predicate_method?(first_argument)
           first_argument.respond_to?(:predicate_method?) && first_argument.predicate_method?
         end

data/lib/rubocop/minitest/version.rb

@@ -4,7 +4,7 @@ module RuboCop
   module Minitest
     # This module holds the RuboCop Minitest version information.
     module Version
-      STRING = '0.32.2'
+      STRING = '0.34.0'
 
       def self.document_version
         STRING.match('\d+\.\d+').to_s

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: rubocop-minitest
 version: !ruby/object:Gem::Version
-  version: 0.32.2
+  version: 0.34.0
 platform: ruby
 authors:
 - Bozhidar Batsov
@@ -10,7 +10,7 @@ authors:
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2023-09-27 00:00:00.000000000 Z
+date: 2023-12-16 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rubocop
@@ -32,6 +32,26 @@ dependencies:
     - - "<"
       - !ruby/object:Gem::Version
         version: '2.0'
+- !ruby/object:Gem::Dependency
+  name: rubocop-ast
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 1.30.0
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '2.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 1.30.0
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '2.0'
 description: |
   Automatic Minitest code style checking tool.
   A RuboCop extension focused on enforcing Minitest best practices and coding conventions.
@@ -74,7 +94,9 @@ files:
 - lib/rubocop/cop/minitest/multiple_assertions.rb
 - lib/rubocop/cop/minitest/no_assertions.rb
 - lib/rubocop/cop/minitest/no_test_cases.rb
+- lib/rubocop/cop/minitest/non_executable_test_method.rb
 - lib/rubocop/cop/minitest/non_public_test_method.rb
+- lib/rubocop/cop/minitest/redundant_message_argument.rb
 - lib/rubocop/cop/minitest/refute_empty.rb
 - lib/rubocop/cop/minitest/refute_equal.rb
 - lib/rubocop/cop/minitest/refute_false.rb
@@ -117,7 +139,7 @@ metadata:
   homepage_uri: https://docs.rubocop.org/rubocop-minitest/
   changelog_uri: https://github.com/rubocop/rubocop-minitest/blob/master/CHANGELOG.md
   source_code_uri: https://github.com/rubocop/rubocop-minitest
-  documentation_uri: https://docs.rubocop.org/rubocop-minitest/0.32
+  documentation_uri: https://docs.rubocop.org/rubocop-minitest/0.34
   bug_tracker_uri: https://github.com/rubocop/rubocop-minitest/issues
   rubygems_mfa_required: 'true'
 post_install_message:
@@ -135,7 +157,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.4.19
+rubygems_version: 3.1.6
 signing_key:
 specification_version: 4
 summary: Automatic Minitest code style checking tool.