rubocop-minitest 0.33.0 → 0.34.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: e9952135d079a3cd02bea1c521f30f9a15eca9614caa6730c84d0afce7fca845
-  data.tar.gz: a11c62c0872b7abb891151770cc9008e1c43f0e8753b8371b85ba8c47142bd05
+  metadata.gz: 8e59babe7e9ae552aee440a3e5eb5767af585357899d8f4fbac8f54247494b87
+  data.tar.gz: 4f61d9b471cdda223fbd1fe239656b2a47e5216a2903588ce05f5a4909d5fb21
 SHA512:
-  metadata.gz: 16fb13dc153d36bd4479690fc2be96dcfc119e9430271231266ba8b150c79871ce1ee417020c9af9a13c31928ea3afd97f23156c975d17ca1be1e2f9f9937770
-  data.tar.gz: f8bd286ee337818358b5e87bb5f375a6d03f2028de3f55481f0a8788013fe4f32314e90985fe967d7a83218dd3c8da0684cdc3b5e998a96f662e644e93c4afd8
+  metadata.gz: 7d14b60b50dacf5f28470b18ea5d03c19507e21063bf54a971b67a5b4d10255e048bcf75052f4645aa049a25ff54dd6f8022255b5c11bdef650c63f84fa4ed1f
+  data.tar.gz: 3e3389f3ba19ea5a8c08ee1b57c5eb9d8da15b17c1b80d36c21470bd096a6753e9108c7de8d84ebb0f702b797310af241e401a16ea2207dc12d4891135c5efa9

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_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_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

@@ -99,7 +99,9 @@ module RuboCop
         end
       end
 
+      # rubocop:disable Metrics/CyclomaticComplexity
       def assertion_method?(node)
+        return assertion_method?(node.expression) if node.assignment? && node.respond_to?(:expression)
         return false if !node.send_type? && !node.block_type? && !node.numblock_type?
 
         ASSERTION_PREFIXES.any? do |prefix|
@@ -108,6 +110,7 @@ module RuboCop
           method_name.start_with?(prefix) || node.method?(:flunk)
         end
       end
+      # rubocop:enable Metrics/CyclomaticComplexity
 
       def lifecycle_hook_method?(node)
         node.def_type? && LIFECYCLE_HOOK_METHODS.include?(node.method_name)

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.33.0'
+      STRING = '0.34.1'
 
       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.33.0
+  version: 0.34.1
 platform: ruby
 authors:
 - Bozhidar Batsov
@@ -10,7 +10,7 @@ authors:
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2023-10-21 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.33
+  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.