rubocop-minitest 0.22.2 → 0.32.2

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

@@ -27,24 +27,35 @@ module RuboCop
         def on_send(node)
           return unless node.method?(:assert_equal)
 
-          expected, actual, message = *node.arguments
+          expected, actual, _message = *node.arguments
           return unless actual&.recursive_basic_literal?
           return if expected.recursive_basic_literal?
 
           add_offense(all_arguments_range(node)) do |corrector|
-            autocorrect(corrector, node, expected, actual, message)
+            autocorrect(corrector, node, expected, actual)
           end
         end
 
-        def autocorrect(corrector, node, expected, actual, message)
+        private
+
+        def autocorrect(corrector, node, expected, actual)
           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})")
+          corrector.replace(expected, new_actual_source)
+          corrector.replace(actual, expected.source)
+
+          wrap_with_parentheses(corrector, node) if !node.parenthesized? && actual.hash_type?
+        end
+
+        def wrap_with_parentheses(corrector, node)
+          range = node.loc.selector.end.join(node.first_argument.source_range.begin)
+
+          corrector.replace(range, '(')
+          corrector.insert_after(node, ')')
         end
       end
     end

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

@@ -3,7 +3,8 @@
 module RuboCop
   module Cop
     module Minitest
-      # Checks if test cases contain too many assertion calls.
+      # Checks if test cases contain too many assertion calls. If conditional code with assertions
+      # is used, the branch with maximum assertions is counted.
       # The maximum allowed assertion calls is configurable.
       #
       # @example Max: 1
@@ -36,7 +37,7 @@ module RuboCop
           return unless test_class?(class_node)
 
           test_cases(class_node).each do |node|
-            assertions_count = assertions_count(node)
+            assertions_count = assertions_count(node.body)
 
             next unless assertions_count > max_assertions
 
@@ -50,8 +51,26 @@ module RuboCop
         private
 
         def assertions_count(node)
-          base = assertion_method?(node) ? 1 : 0
-          base + node.each_child_node.sum { |c| assertions_count(c) }
+          return 0 unless node.is_a?(RuboCop::AST::Node)
+
+          assertions =
+            case node.type
+            when :if, :case, :case_match
+              assertions_count_in_branches(node.branches)
+            when :rescue
+              assertions_count(node.body) + assertions_count_in_branches(node.branches)
+            when :block, :numblock
+              assertions_count(node.body)
+            else
+              node.each_child_node.sum { |child| assertions_count(child) }
+            end
+
+          assertions += 1 if assertion_method?(node)
+          assertions
+        end
+
+        def assertions_count_in_branches(branches)
+          branches.map { |branch| assertions_count(branch) }.max
         end
 
         def max_assertions

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

@@ -32,16 +32,9 @@ module RuboCop
 
             next if assertions_count.positive?
 
-            add_offense(node.block_type? ? node.loc.expression : node.loc.name)
+            add_offense(node.block_type? ? node.source_range : node.loc.name)
           end
         end
-
-        private
-
-        def assertions_count(node)
-          base = assertion_method?(node) ? 1 : 0
-          base + node.each_child_node.sum { |c| assertions_count(c) }
-        end
       end
     end
   end

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

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Minitest
+      # Checks if test class contains any test cases.
+      #
+      # @example
+      #   # bad
+      #   class FooTest < Minitest::Test
+      #     def do_something
+      #     end
+      #   end
+      #
+      #   # good
+      #   class FooTest < Minitest::Test
+      #     def test_something
+      #       assert true
+      #     end
+      #   end
+      #
+      class NoTestCases < Base
+        include MinitestExplorationHelpers
+
+        MSG = 'Test class should have test cases.'
+
+        def on_class(node)
+          return unless test_class?(node)
+
+          add_offense(node) if test_cases(node).empty?
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,55 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Minitest
+      # Detects non `public` (marked as `private` or `protected`) test methods.
+      # Minitest runs only test methods which are `public`.
+      #
+      # @example
+      #   # bad
+      #   class FooTest
+      #     private # or protected
+      #     def test_does_something
+      #       assert_equal 42, do_something
+      #     end
+      #   end
+      #
+      #   # good
+      #   class FooTest
+      #     def test_does_something
+      #       assert_equal 42, do_something
+      #     end
+      #   end
+      #
+      #   # good (not a test case name)
+      #   class FooTest
+      #     private # or protected
+      #     def does_something
+      #       assert_equal 42, do_something
+      #     end
+      #   end
+      #
+      #   # good (no assertions)
+      #   class FooTest
+      #     private # or protected
+      #     def test_does_something
+      #       do_something
+      #     end
+      #   end
+      #
+      class NonPublicTestMethod < Base
+        include MinitestExplorationHelpers
+        include DefNode
+
+        MSG = 'Non `public` test method detected. Make it `public` for it to run.'
+
+        def on_class(node)
+          test_cases(node, visibility_check: false).each do |test_case|
+            add_offense(test_case) if non_public?(test_case) && assertions(test_case).any?
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -9,7 +9,6 @@ module RuboCop
       # @example
       #   # bad
       #   assert("rubocop-minitest" != actual)
-      #   assert(! "rubocop-minitest" == actual)
       #
       #   # good
       #   refute_equal("rubocop-minitest", actual)
@@ -22,7 +21,7 @@ module RuboCop
         RESTRICT_ON_SEND = %i[assert].freeze
 
         def_node_matcher :assert_not_equal, <<~PATTERN
-          (send nil? :assert {(send $_ :!= $_) (send (send $_ :! ) :== $_) } $... )
+          (send nil? :assert (send $_ :!= $_) $... )
         PATTERN
 
         def on_send(node)
@@ -36,7 +35,7 @@ module RuboCop
               corrector.replace(node.loc.selector, 'refute_equal')
 
               replacement = [expected, actual].map(&:source).join(', ')
-              corrector.replace(first_argument_range(node), replacement)
+              corrector.replace(node.first_argument, replacement)
             end
           end
         end

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

@@ -5,6 +5,16 @@ module RuboCop
     module Minitest
       # Enforces the use of `refute(object)` over `assert_equal(false, object)`.
       #
+      # @safety
+      #   This cop is unsafe because it cannot detect failure when second argument is `nil`.
+      #   False positives cannot be prevented when this is a variable or method return value.
+      #
+      #   [source,ruby]
+      #   ----
+      #   assert_equal(false, nil) # failure
+      #   refute(nil)              # success
+      #   ----
+      #
       # @example
       #   # bad
       #   assert_equal(false, actual)
@@ -56,7 +66,7 @@ module RuboCop
           if node.method?(:assert_equal)
             corrector.replace(first_and_second_arguments_range(node), actual.source)
           else
-            corrector.replace(first_argument_range(node), actual.source)
+            corrector.replace(node.first_argument, actual.source)
           end
         end
       end

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

@@ -11,14 +11,30 @@ module RuboCop
       #   refute(object.instance_of?(Class))
       #   refute(object.instance_of?(Class), 'message')
       #
+      #   # bad
+      #   refute_equal(Class, object.class)
+      #   refute_equal(Class, object.class, 'message')
+      #
       #   # good
       #   refute_instance_of(Class, object)
       #   refute_instance_of(Class, object, 'message')
       #
       class RefuteInstanceOf < Base
-        extend MinitestCopRule
+        include InstanceOfAssertionHandleable
+        extend AutoCorrector
+
+        RESTRICT_ON_SEND = %i[refute refute_equal].freeze
+
+        def_node_matcher :instance_of_assertion?, <<~PATTERN
+          {
+            (send nil? :refute (send $_ :instance_of? $const) $_?)
+            (send nil? :refute_equal $const (send $_ :class) $_?)
+          }
+        PATTERN
 
-        define_rule :refute, target_method: :instance_of?, inverse: true
+        def on_send(node)
+          investigate(node, :refute)
+        end
       end
     end
   end

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

@@ -9,6 +9,8 @@ module RuboCop
       # @example
       #   # bad
       #   refute(matcher.match(string))
+      #   refute(matcher.match?(string))
+      #   refute(matcher =~ string)
       #   refute(matcher.match(string), 'message')
       #
       #   # good
@@ -18,7 +20,8 @@ module RuboCop
       class RefuteMatch < Base
         extend MinitestCopRule
 
-        define_rule :refute, target_method: :match, inverse: 'regexp_type?'
+        define_rule :refute, target_method: %i[match match? =~],
+                             preferred_method: :refute_match, inverse: 'regexp_type?'
       end
     end
   end

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

@@ -0,0 +1,58 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Minitest
+      # Enforces the use of `refute_operator(expected, :<, actual)` over `refute(expected < actual)`.
+      #
+      # @example
+      #
+      #   # bad
+      #   refute(expected < actual)
+      #
+      #   # good
+      #   refute_operator(expected, :<, actual)
+      #
+      class RefuteOperator < Base
+        extend AutoCorrector
+
+        MSG = 'Prefer using `refute_operator(%<new_arguments>s)`.'
+        RESTRICT_ON_SEND = %i[refute].freeze
+        ALLOWED_OPERATORS = [:[]].freeze
+
+        def on_send(node)
+          first_argument = node.first_argument
+          return unless first_argument.respond_to?(:binary_operation?) && first_argument.binary_operation?
+
+          operator = first_argument.to_a[1]
+          return if ALLOWED_OPERATORS.include?(operator)
+
+          new_arguments = build_new_arguments(node)
+
+          add_offense(node, message: format(MSG, new_arguments: new_arguments)) do |corrector|
+            corrector.replace(node.loc.selector, 'refute_operator')
+
+            corrector.replace(range_of_arguments(node), new_arguments)
+          end
+        end
+
+        private
+
+        def build_new_arguments(node)
+          lhs, op, rhs = *node.first_argument
+          new_arguments = "#{lhs.source}, :#{op}, #{rhs.source}"
+
+          if node.arguments.count == 2
+            new_arguments << ", #{node.last_argument.source}"
+          else
+            new_arguments
+          end
+        end
+
+        def range_of_arguments(node)
+          node.first_argument.source_range.begin.join(node.last_argument.source_range.end)
+        end
+      end
+    end
+  end
+end

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

@@ -30,20 +30,25 @@ module RuboCop
         def on_send(node)
           refute_file_exists(node) do |path, failure_message|
             failure_message = failure_message.first
-            good_method = build_good_method(path, failure_message)
+            good_method = build_good_method(node, path, failure_message)
             message = format(MSG, good_method: good_method)
 
             add_offense(node, message: message) do |corrector|
-              corrector.replace(node, good_method)
+              corrector.replace(node.loc.selector, 'refute_path_exists')
+              corrector.replace(node.first_argument, path.source)
             end
           end
         end
 
         private
 
-        def build_good_method(path, message)
+        def build_good_method(node, path, message)
           args = [path.source, message&.source].compact.join(', ')
-          "refute_path_exists(#{args})"
+          if node.parenthesized?
+            "refute_path_exists(#{args})"
+          else
+            "refute_path_exists #{args}"
+          end
         end
       end
     end

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

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Minitest
+      # Enforces the use of `refute_same(expected, object)`
+      # over `refute(expected.equal?(actual))`.
+      #
+      # NOTE: Use `refute_same` only when there is a need to compare by identity.
+      #       Otherwise, use `refute_equal`.
+      #
+      # @example
+      #   # bad
+      #   refute(expected.equal?(actual))
+      #
+      #   # good
+      #   refute_same(expected, actual)
+      #
+      class RefuteSame < Base
+        extend MinitestCopRule
+
+        define_rule :refute, target_method: :equal?, preferred_method: :refute_same
+      end
+    end
+  end
+end

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

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Minitest
+      # Enforces the use of `skip` instead of `return` in test methods.
+      #
+      # @example
+      #   # bad
+      #   def test_something
+      #     return if condition?
+      #     assert_equal(42, something)
+      #   end
+      #
+      #   # good
+      #   def test_something
+      #     skip if condition?
+      #     assert_equal(42, something)
+      #   end
+      #
+      class ReturnInTestMethod < Base
+        include MinitestExplorationHelpers
+        extend AutoCorrector
+
+        MSG = 'Use `skip` instead of `return`.'
+
+        def on_return(node)
+          return unless node.ancestors.any? { |parent| test_case?(parent) }
+          return if inside_block?(node)
+
+          add_offense(node) do |corrector|
+            corrector.replace(node, 'skip')
+          end
+        end
+
+        private
+
+        def inside_block?(node)
+          node.ancestors.any?(&:block_type?) || node.ancestors.any?(&:numblock_type?)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,66 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Minitest
+      # Checks for skipped tests missing the skipping reason.
+      #
+      # @example
+      #   # bad
+      #   skip
+      #   skip('')
+      #
+      #   # bad
+      #   if condition?
+      #     skip
+      #   else
+      #     skip
+      #   end
+      #
+      #   # good
+      #   skip("Reason why the test was skipped")
+      #
+      #   # good
+      #   skip if condition?
+      #
+      class SkipWithoutReason < Base
+        MSG = 'Add a reason explaining why the test is skipped.'
+
+        RESTRICT_ON_SEND = %i[skip].freeze
+
+        def on_send(node)
+          return if node.receiver || !blank_argument?(node)
+
+          conditional_node = conditional_parent(node)
+          return if conditional_node && !only_skip_branches?(conditional_node)
+
+          return if node.parent&.resbody_type?
+
+          add_offense(node)
+        end
+
+        private
+
+        def blank_argument?(node)
+          message = node.first_argument
+          message.nil? || (message.str_type? && message.value == '')
+        end
+
+        def conditional_parent(node)
+          return unless (parent = node.parent)
+
+          if parent.if_type? || parent.case_type?
+            parent
+          elsif parent.when_type?
+            parent.parent
+          end
+        end
+
+        def only_skip_branches?(node)
+          branches = node.branches.compact
+          branches.size > 1 && branches.all? { |branch| branch.send_type? && branch.method?(:skip) }
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Minitest
+      # Checks if test file names start with `test_` or end with `_test.rb`.
+      # Files which define classes having names ending with `Test` are checked.
+      # Not following this convention may result in tests not being run.
+      #
+      # @example
+      #   # bad
+      #   my_class.rb
+      #
+      #   # good
+      #   my_class_test.rb
+      #   test_my_class.rb
+      #
+      class TestFileName < Base
+        include MinitestExplorationHelpers
+
+        MSG = 'Test file path should start with `test_` or end with `_test.rb`.'
+
+        def on_new_investigation
+          return unless (ast = processed_source.ast)
+          return unless test_file?(ast)
+
+          add_global_offense(MSG) unless valid_file_name?
+        end
+
+        private
+
+        def test_file?(node)
+          return true if node.class_type? && test_class?(node)
+
+          node.each_descendant(:class).any? { |class_node| test_class?(class_node) }
+        end
+
+        def valid_file_name?
+          basename = File.basename(processed_source.file_path)
+
+          basename.start_with?('test_') || basename.end_with?('_test.rb')
+        end
+      end
+    end
+  end
+end

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

@@ -37,7 +37,7 @@ module RuboCop
         def on_class(class_node)
           return unless test_class?(class_node)
 
-          class_elements(class_node).each do |node|
+          class_def_nodes(class_node).each do |node|
             next unless offense?(node)
 
             test_method_name = node.loc.name
@@ -50,17 +50,6 @@ module RuboCop
 
         private
 
-        def class_elements(class_node)
-          class_def = class_node.body
-          return [] unless class_def
-
-          if class_def.def_type?
-            [class_def]
-          else
-            class_def.each_child_node(:def).to_a
-          end
-        end
-
         def offense?(node)
           return false if assertions(node).none?
 

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

@@ -0,0 +1,75 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Minitest
+      # Detects useless assertions (assertions that either always pass or always fail).
+      #
+      # @example
+      #   # bad
+      #   assert true
+      #   assert_equal @foo, @foo
+      #   assert_nil [foo, bar]
+      #
+      #   # good
+      #   assert something
+      #   assert_equal foo, bar
+      #   assert_nil foo
+      #   assert false, "My message"
+      #
+      class UselessAssertion < Base
+        MSG = 'Useless assertion detected.'
+
+        SINGLE_ASSERTION_ARGUMENT_METHODS = %i[
+          assert refute assert_nil refute_nil assert_not assert_empty refute_empty
+        ].freeze
+        TWO_ASSERTION_ARGUMENTS_METHODS = %i[
+          assert_equal refute_equal assert_in_delta refute_in_delta
+          assert_in_epsilon refute_in_epsilon assert_same refute_same
+        ].freeze
+
+        RESTRICT_ON_SEND = SINGLE_ASSERTION_ARGUMENT_METHODS +
+                           TWO_ASSERTION_ARGUMENTS_METHODS +
+                           %i[assert_includes refute_includes assert_silent]
+
+        def on_send(node)
+          return if node.receiver
+
+          add_offense(node) if offense?(node)
+        end
+
+        private
+
+        # rubocop:disable Metrics
+        def offense?(node)
+          expected, actual, = node.arguments
+
+          case node.method_name
+          when *SINGLE_ASSERTION_ARGUMENT_METHODS
+            actual.nil? && expected&.literal? && !expected.xstr_type?
+          when *TWO_ASSERTION_ARGUMENTS_METHODS
+            return false unless expected || actual
+            return false if expected.source != actual.source
+
+            (expected.variable? && actual.variable?) ||
+              (empty_composite?(expected) && empty_composite?(actual))
+          when :assert_includes, :refute_includes
+            expected && empty_composite?(expected)
+          when :assert_silent
+            block_node = node.parent
+            block_node&.body.nil?
+          else
+            false
+          end
+        end
+        # rubocop:enable Metrics
+
+        def empty_composite?(node)
+          return true if node.str_type? && node.value.empty?
+
+          (node.array_type? || node.hash_type?) && node.children.empty?
+        end
+      end
+    end
+  end
+end