rubocop-minitest 0.7.0 → 0.10.1

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

@@ -3,69 +3,90 @@
 module RuboCop
   module Cop
     module Minitest
-      # This Cop checks for deprecated global expectations
+      # This cop checks for deprecated global expectations
       # and autocorrects them to use expect format.
       #
       # @example
       #   # bad
-      #   n.must_equal 42
-      #   n.wont_match b
+      #   musts.must_equal expected_musts
+      #   wonts.wont_match expected_wonts
+      #   musts.must_raise TypeError
       #
       #   # good
-      #   _(n).must_equal 42
-      #   _(n).wont_match b
+      #   _(musts).must_equal expected_musts
+      #   _(wonts).wont_match expected_wonts
+      #   _ { musts }.must_raise TypeError
       class GlobalExpectations < Cop
-        MSG = 'Prefer using `%<corrected>s`.'
+        MSG = 'Use `%<preferred>s` instead.'
 
         VALUE_MATCHERS = %i[
-          be be_close_to be_empty be_instance_of be_kind_of
-          be_nil be_same_as be_silent be_within_epsilon equal
-          include match respond_to must_exist
-        ].map do |matcher|
-          [:"must_#{matcher}", :"wont_#{matcher}"]
-        end.flatten.freeze
+          must_be_empty must_equal must_be_close_to must_be_within_delta
+          must_be_within_epsilon must_include must_be_instance_of must_be_kind_of
+          must_match must_be_nil must_be must_respond_to must_be_same_as
+          path_must_exist path_wont_exist wont_be_empty wont_equal wont_be_close_to
+          wont_be_within_delta wont_be_within_epsilon wont_include wont_be_instance_of
+          wont_be_kind_of wont_match wont_be_nil wont_be wont_respond_to wont_be_same_as
+        ].freeze
 
-        BLOCK_MATCHERS = %i[must_output must_raise must_throw].freeze
+        BLOCK_MATCHERS = %i[must_output must_raise must_be_silent must_throw].freeze
 
-        MATCHERS_STR = (VALUE_MATCHERS + BLOCK_MATCHERS).map do |m|
+        VALUE_MATCHERS_STR = VALUE_MATCHERS.map do |m|
           ":#{m}"
         end.join(' ').freeze
 
-        def_node_matcher :global_expectation?, <<~PATTERN
-          (send (send _ _) {#{MATCHERS_STR}} ...)
+        BLOCK_MATCHERS_STR = BLOCK_MATCHERS.map do |m|
+          ":#{m}"
+        end.join(' ').freeze
+
+        # There are aliases for the `_` method - `expect` and `value`
+        DSL_METHODS_LIST = %w[_ value expect].map do |n|
+          ":#{n}"
+        end.join(' ').freeze
+
+        def_node_matcher :value_global_expectation?, <<~PATTERN
+          (send !(send nil? {#{DSL_METHODS_LIST}} _) {#{VALUE_MATCHERS_STR}} ...)
+        PATTERN
+
+        def_node_matcher :block_global_expectation?, <<~PATTERN
+          (send
+            [
+              !(send nil? {#{DSL_METHODS_LIST}} _)
+              !(block (send nil? {#{DSL_METHODS_LIST}}) _ _)
+            ]
+            {#{BLOCK_MATCHERS_STR}}
+            _
+          )
         PATTERN
 
         def on_send(node)
-          return unless global_expectation?(node)
+          return unless value_global_expectation?(node) || block_global_expectation?(node)
 
-          message = format(MSG, corrected: correct_suggestion(node))
-          add_offense(node, message: message)
+          message = format(MSG, preferred: preferred_receiver(node))
+          add_offense(node, location: node.receiver.source_range, message: message)
         end
 
         def autocorrect(node)
-          return unless global_expectation?(node)
+          return unless value_global_expectation?(node) || block_global_expectation?(node)
 
           lambda do |corrector|
-            receiver = node.receiver.loc.selector
+            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
 
         private
 
-        def correct_suggestion(node)
+        def preferred_receiver(node)
           source = node.receiver.source
           if BLOCK_MATCHERS.include?(node.method_name)
-            node.source.sub(source, "_ { #{source} }")
+            "_ { #{source} }"
           else
-            node.source.sub(source, "_(#{source})")
+            "_(#{source})"
           end
         end
       end

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

@@ -0,0 +1,52 @@
+# 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.'
+
+        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_in_delta.rb

@@ -0,0 +1,27 @@
+# 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
+
+        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_path_exists.rb

@@ -0,0 +1,58 @@
+# 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`.'
+
+        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,70 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Minitest
+      # This cop enforces that test method names start with `test_` prefix.
+      #
+      # @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
+      #
+      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)
+          public?(node) && !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

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

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Minitest
+      # This cop checks for a specified error in `assert_raises`.
+      #
+      # @example
+      #   # bad
+      #   assert_raises { raise FooException }
+      #   assert_raises('This should have raised') { raise FooException }
+      #
+      #   # good
+      #   assert_raises(FooException) { raise FooException }
+      #   assert_raises(FooException, 'This should have raised') { raise FooException }
+      #
+      class UnspecifiedException < Cop
+        MSG = 'Specify the exception being captured.'
+
+        def on_block(block_node)
+          node = block_node.send_node
+          return unless node.method?(:assert_raises)
+
+          add_offense(node) if unspecified_exception?(node)
+        end
+
+        private
+
+        def unspecified_exception?(node)
+          args = node.arguments
+          args.empty? || (args.size == 1 && args[0].str_type?)
+        end
+      end
+    end
+  end
+end