rubocop-minitest 0.9.0 → 0.11.0

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

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Minitest
+      # This cop enforces the test to use `assert_silent { ... }`
+      # instead of using `assert_output('', '') { ... }`.
+      #
+      # @example
+      #   # bad
+      #   assert_output('', '') { puts object.do_something }
+      #
+      #   # good
+      #   assert_silent { puts object.do_something }
+      #
+      class AssertSilent < Cop
+        MSG = 'Prefer using `assert_silent` over `assert_output("", "")`.'
+
+        def_node_matcher :assert_silent_candidate?, <<~PATTERN
+          (block
+            (send nil? :assert_output
+              #empty_string?
+              #empty_string?)
+            ...)
+        PATTERN
+
+        def on_block(node)
+          add_offense(node.send_node) if assert_silent_candidate?(node)
+        end
+
+        def autocorrect(node)
+          lambda do |corrector|
+            corrector.replace(node, 'assert_silent')
+          end
+        end
+
+        private
+
+        def empty_string?(node)
+          node.str_type? && node.value.empty?
+        end
+      end
+    end
+  end
+end

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

@@ -20,6 +20,7 @@ module RuboCop
 
         MSG = 'Prefer using `assert(%<arguments>s)` over ' \
               '`assert_equal(true, %<arguments>s)`.'
+        RESTRICT_ON_SEND = %i[assert_equal].freeze
 
         def_node_matcher :assert_equal_with_truthy, <<~PATTERN
           (send nil? :assert_equal true $_ $...)

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

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Minitest
+      # This cop tries to detect when a user accidentally used
+      # `assert` when they meant to use `assert_equal`.
+      #
+      # @example
+      #   # bad
+      #   assert(3, my_list.length)
+      #   assert(expected, actual)
+      #
+      #   # good
+      #   assert_equal(3, my_list.length)
+      #   assert_equal(expected, actual)
+      #   assert(foo, 'message')
+      #
+      class AssertWithExpectedArgument < Cop
+        MSG = 'Did you mean to use `assert_equal(%<arguments>s)`?'
+        RESTRICT_ON_SEND = %i[assert].freeze
+
+        def_node_matcher :assert_with_two_arguments?, <<~PATTERN
+          (send nil? :assert $_ $_)
+        PATTERN
+
+        def on_send(node)
+          assert_with_two_arguments?(node) do |_expected, message|
+            return if message.str_type? || message.dstr_type?
+
+            arguments = node.arguments.map(&:source).join(', ')
+            add_offense(node, message: format(MSG, arguments: arguments))
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Minitest
+      # This cop checks for usage of assertions in lifecycle hooks.
+      #
+      # @example
+      #   # bad
+      #   class FooTest < Minitest::Test
+      #     def setup
+      #       assert_equal(foo, bar)
+      #     end
+      #   end
+      #
+      #   # good
+      #   class FooTest < Minitest::Test
+      #     def test_something
+      #       assert_equal(foo, bar)
+      #     end
+      #   end
+      #
+      class AssertionInLifecycleHook < Cop
+        include MinitestExplorationHelpers
+
+        MSG = 'Do not use `%<assertion>s` in `%<hook>s` hook.'
+
+        def on_class(class_node)
+          return unless test_class?(class_node)
+
+          lifecycle_hooks(class_node).each do |hook_node|
+            hook_node.each_descendant(:send) do |node|
+              if assertion?(node)
+                message = format(MSG, assertion: node.method_name, hook: hook_node.method_name)
+                add_offense(node, message: message)
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -30,6 +30,8 @@ module RuboCop
 
         BLOCK_MATCHERS = %i[must_output must_raise must_be_silent must_throw].freeze
 
+        RESTRICT_ON_SEND = VALUE_MATCHERS + BLOCK_MATCHERS
+
         VALUE_MATCHERS_STR = VALUE_MATCHERS.map do |m|
           ":#{m}"
         end.join(' ').freeze
@@ -72,11 +74,9 @@ module RuboCop
             receiver = node.receiver.source_range
 
             if BLOCK_MATCHERS.include?(node.method_name)
-              corrector.insert_before(receiver, '_ { ')
-              corrector.insert_after(receiver, ' }')
+              corrector.wrap(receiver, '_ { ', ' }')
             else
-              corrector.insert_before(receiver, '_(')
-              corrector.insert_after(receiver, ')')
+              corrector.wrap(receiver, '_(', ')')
             end
           end
         end

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

@@ -0,0 +1,53 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Minitest
+      # This cop enforces correct order of expected and
+      # actual arguments for `assert_equal`.
+      #
+      # @example
+      #   # bad
+      #   assert_equal foo, 2
+      #   assert_equal foo, [1, 2]
+      #   assert_equal foo, [1, 2], 'message'
+      #
+      #   # good
+      #   assert_equal 2, foo
+      #   assert_equal [1, 2], foo
+      #   assert_equal [1, 2], foo, 'message'
+      #
+      class LiteralAsActualArgument < Cop
+        include ArgumentRangeHelper
+
+        MSG = 'Replace the literal with the first argument.'
+        RESTRICT_ON_SEND = %i[assert_equal].freeze
+
+        def on_send(node)
+          return unless node.method?(:assert_equal)
+
+          actual = node.arguments[1]
+          return unless actual
+
+          add_offense(node, location: all_arguments_range(node)) if actual.recursive_basic_literal?
+        end
+
+        def autocorrect(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(', ')
+
+            corrector.replace(node, "assert_equal(#{arguments})")
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,63 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Minitest
+      # This cop checks if test cases contain too many assertion calls.
+      # The maximum allowed assertion calls is configurable.
+      #
+      # @example Max: 1
+      #   # bad
+      #   class FooTest < Minitest::Test
+      #     def test_asserts_twice
+      #       assert_equal(42, do_something)
+      #       assert_empty(array)
+      #     end
+      #   end
+      #
+      #   # good
+      #   class FooTest < Minitest::Test
+      #     def test_asserts_once
+      #       assert_equal(42, do_something)
+      #     end
+      #
+      #     def test_another_asserts_once
+      #       assert_empty(array)
+      #     end
+      #   end
+      #
+      class MultipleAssertions < Cop
+        include ConfigurableMax
+        include MinitestExplorationHelpers
+
+        MSG = 'Test case has too many assertions [%<total>d/%<max>d].'
+
+        def on_class(class_node)
+          return unless test_class?(class_node)
+
+          test_cases(class_node).each do |node|
+            assertions_count = assertions_count(node)
+
+            next unless assertions_count > max_assertions
+
+            self.max = assertions_count
+
+            message = format(MSG, total: assertions_count, max: max_assertions)
+            add_offense(node, location: :name, message: message)
+          end
+        end
+
+        private
+
+        def assertions_count(node)
+          base = assertion?(node) ? 1 : 0
+          base + node.each_child_node.sum { |c| assertions_count(c) }
+        end
+
+        def max_assertions
+          Integer(cop_config.fetch('Max', 3))
+        end
+      end
+    end
+  end
+end

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

@@ -4,7 +4,7 @@ module RuboCop
   module Cop
     module Minitest
       # This cop enforces the use of `refute_equal(expected, object)`
-      # over `assert_equal(expected != actual)` or `assert(! expected == actual)`.
+      # over `assert(expected != actual)` or `assert(! expected == actual)`.
       #
       # @example
       #   # bad
@@ -19,6 +19,7 @@ module RuboCop
 
         MSG = 'Prefer using `refute_equal(%<preferred>s)` over ' \
               '`assert(%<over>s)`.'
+        RESTRICT_ON_SEND = %i[assert].freeze
 
         def_node_matcher :assert_not_equal, <<~PATTERN
           (send nil? :assert ${(send $_ :!= $_) (send (send $_ :! ) :== $_) } $... )

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

@@ -25,6 +25,7 @@ module RuboCop
               '`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
           (send nil? :assert_equal false $_ $...)

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

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Minitest
+      # This cop enforces the test to use `refute_in_delta`
+      # instead of using `refute_equal` to compare floats.
+      #
+      # @example
+      #   # bad
+      #   refute_equal(0.2, actual)
+      #   refute_equal(0.2, actual, 'message')
+      #
+      #   # good
+      #   refute_in_delta(0.2, actual)
+      #   refute_in_delta(0.2, actual, 0.001, 'message')
+      #
+      class RefuteInDelta < Cop
+        include InDeltaMixin
+
+        RESTRICT_ON_SEND = %i[refute_equal].freeze
+
+        def_node_matcher :equal_floats_call, <<~PATTERN
+          (send nil? :refute_equal $_ $_ $...)
+        PATTERN
+      end
+    end
+  end
+end

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

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Minitest
+      # This cop enforces the use of `refute_kind_of(Class, object)`
+      # over `refute(object.kind_of?(Class))`.
+      #
+      # @example
+      #   # bad
+      #   refute(object.kind_of?(Class))
+      #   refute(object.kind_of?(Class), 'message')
+      #
+      #   # good
+      #   refute_kind_of(Class, object)
+      #   refute_kind_of(Class, object, 'message')
+      #
+      class RefuteKindOf < Cop
+        extend MinitestCopRule
+
+        define_rule :refute, target_method: :kind_of?, inverse: true
+      end
+    end
+  end
+end

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

@@ -20,6 +20,7 @@ module RuboCop
 
         MSG = 'Prefer using `refute_nil(%<arguments>s)` over ' \
               '`refute_equal(nil, %<arguments>s)`.'
+        RESTRICT_ON_SEND = %i[refute_equal].freeze
 
         def_node_matcher :refute_equal_with_nil, <<~PATTERN
           (send nil? :refute_equal nil $_ $...)

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

@@ -0,0 +1,59 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Minitest
+      # This cop enforces the test to use `refute_path_exists`
+      # instead of using `refute(File.exist?(path))`.
+      #
+      # @example
+      #   # bad
+      #   refute(File.exist?(path))
+      #   refute(File.exist?(path), 'message')
+      #
+      #   # good
+      #   refute_path_exists(path)
+      #   refute_path_exists(path, 'message')
+      #
+      class RefutePathExists < Cop
+        MSG = 'Prefer using `%<good_method>s` over `%<bad_method>s`.'
+        RESTRICT_ON_SEND = %i[refute].freeze
+
+        def_node_matcher :refute_file_exists, <<~PATTERN
+          (send nil? :refute
+            (send
+              (const _ :File) {:exist? :exists?} $_)
+              $...)
+        PATTERN
+
+        def on_send(node)
+          refute_file_exists(node) do |path, failure_message|
+            failure_message = failure_message.first
+            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)
+            end
+          end
+        end
+
+        private
+
+        def build_good_method(path, message)
+          args = [path.source, message&.source].compact.join(', ')
+          "refute_path_exists(#{args})"
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,79 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Minitest
+      # This cop enforces that test method names start with `test_` prefix.
+      # It aims to prevent tests that aren't executed by forgetting to start test method name with `test_`.
+      #
+      # @example
+      #   # bad
+      #   class FooTest < Minitest::Test
+      #     def does_something
+      #       assert_equal 42, do_something
+      #     end
+      #   end
+      #
+      #   # good
+      #   class FooTest < Minitest::Test
+      #     def test_does_something
+      #       assert_equal 42, do_something
+      #     end
+      #   end
+      #
+      #   # good
+      #   class FooTest < Minitest::Test
+      #     def helper_method(argument)
+      #     end
+      #   end
+      #
+      class TestMethodName < Cop
+        include MinitestExplorationHelpers
+        include DefNode
+
+        MSG = 'Test method name should start with `test_` prefix.'
+
+        def on_class(class_node)
+          return unless test_class?(class_node)
+
+          class_elements(class_node).each do |node|
+            add_offense(node, location: :name) if offense?(node)
+          end
+        end
+
+        def autocorrect(node)
+          lambda do |corrector|
+            corrector.replace(node.loc.name, "test_#{node.method_name}")
+          end
+        end
+
+        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?
+
+          public?(node) && node.arguments.empty? && !test_method_name?(node) && !lifecycle_hook_method?(node)
+        end
+
+        def public?(node)
+          !non_public?(node)
+        end
+
+        def test_method_name?(node)
+          node.method_name.to_s.start_with?('test_')
+        end
+      end
+    end
+  end
+end