rubocop-minitest 0.6.2 → 0.10.0

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

@@ -9,11 +9,11 @@ module RuboCop
       # @example
       #   # bad
       #   assert_equal(true, actual)
-      #   assert_equal(true, actual, 'the message')
+      #   assert_equal(true, actual, 'message')
       #
       #   # good
       #   assert(actual)
-      #   assert(actual, 'the message')
+      #   assert(actual, 'message')
       #
       class AssertTruthy < Cop
         include ArgumentRangeHelper

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

@@ -0,0 +1,95 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Minitest
+      # This cop checks for deprecated global expectations
+      # and autocorrects them to use expect format.
+      #
+      # @example
+      #   # bad
+      #   musts.must_equal expected_musts
+      #   wonts.wont_match expected_wonts
+      #   musts.must_raise TypeError
+      #
+      #   # good
+      #   _(musts).must_equal expected_musts
+      #   _(wonts).wont_match expected_wonts
+      #   _ { musts }.must_raise TypeError
+      class GlobalExpectations < Cop
+        MSG = 'Use `%<preferred>s` instead.'
+
+        VALUE_MATCHERS = %i[
+          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_be_silent must_throw].freeze
+
+        VALUE_MATCHERS_STR = VALUE_MATCHERS.map do |m|
+          ":#{m}"
+        end.join(' ').freeze
+
+        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 value_global_expectation?(node) || block_global_expectation?(node)
+
+          message = format(MSG, preferred: preferred_receiver(node))
+          add_offense(node, location: node.receiver.source_range, message: message)
+        end
+
+        def autocorrect(node)
+          return unless value_global_expectation?(node) || block_global_expectation?(node)
+
+          lambda do |corrector|
+            receiver = node.receiver.source_range
+
+            if BLOCK_MATCHERS.include?(node.method_name)
+              corrector.wrap(receiver, '_ { ', ' }')
+            else
+              corrector.wrap(receiver, '_(', ')')
+            end
+          end
+        end
+
+        private
+
+        def preferred_receiver(node)
+          source = node.receiver.source
+          if BLOCK_MATCHERS.include?(node.method_name)
+            "_ { #{source} }"
+          else
+            "_(#{source})"
+          end
+        end
+      end
+    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_empty.rb

@@ -9,42 +9,16 @@ module RuboCop
       # @example
       #   # bad
       #   refute(object.empty?)
-      #   refute(object.empty?, 'the message')
+      #   refute(object.empty?, 'message')
       #
       #   # good
       #   refute_empty(object)
-      #   refute_empty(object, 'the message')
+      #   refute_empty(object, 'message')
       #
       class RefuteEmpty < Cop
-        include ArgumentRangeHelper
+        extend MinitestCopRule
 
-        MSG = 'Prefer using `refute_empty(%<arguments>s)` over ' \
-              '`refute(%<receiver>s)`.'
-
-        def_node_matcher :refute_with_empty, <<~PATTERN
-          (send nil? :refute $(send $_ :empty?) $...)
-        PATTERN
-
-        def on_send(node)
-          refute_with_empty(node) do |first_receiver_arg, object, rest_receiver_arg|
-            message = rest_receiver_arg.first
-
-            arguments = [object.source, message&.source].compact.join(', ')
-            receiver = [first_receiver_arg.source, message&.source].compact.join(', ')
-
-            offense_message = format(MSG, arguments: arguments, receiver: receiver)
-            add_offense(node, message: offense_message)
-          end
-        end
-
-        def autocorrect(node)
-          lambda do |corrector|
-            refute_with_empty(node) do |_, actual_arg|
-              corrector.replace(node.loc.selector, 'refute_empty')
-              corrector.replace(first_argument_range(node), actual_arg.source)
-            end
-          end
-        end
+        define_rule :refute, target_method: :empty?
       end
     end
   end

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

@@ -9,14 +9,14 @@ module RuboCop
       # @example
       #   # bad
       #   assert_equal(false, actual)
-      #   assert_equal(false, actual, 'the message')
+      #   assert_equal(false, actual, 'message')
       #
       #   assert(!test)
-      #   assert(!test, 'the message')
+      #   assert(!test, 'message')
       #
       #   # good
       #   refute(actual)
-      #   refute(actual, 'the message')
+      #   refute(actual, 'message')
       #
       class RefuteFalse < Cop
         include ArgumentRangeHelper

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_includes.rb

@@ -9,16 +9,16 @@ module RuboCop
       # @example
       #   # bad
       #   refute(collection.include?(object))
-      #   refute(collection.include?(object), 'the message')
+      #   refute(collection.include?(object), 'message')
       #
       #   # good
       #   refute_includes(collection, object)
-      #   refute_includes(collection, object, 'the message')
+      #   refute_includes(collection, object, 'message')
       #
       class RefuteIncludes < Cop
-        extend IncludesCopRule
+        extend MinitestCopRule
 
-        rule target_method: :refute, prefer_method: :refute_includes
+        define_rule :refute, target_method: :include?, preferred_method: :refute_includes
       end
     end
   end

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

@@ -9,50 +9,16 @@ module RuboCop
       # @example
       #   # bad
       #   refute(object.instance_of?(Class))
-      #   refute(object.instance_of?(Class), 'the message')
+      #   refute(object.instance_of?(Class), 'message')
       #
       #   # good
       #   refute_instance_of(Class, object)
-      #   refute_instance_of(Class, object, 'the message')
+      #   refute_instance_of(Class, object, 'message')
       #
       class RefuteInstanceOf < Cop
-        include ArgumentRangeHelper
+        extend MinitestCopRule
 
-        MSG = 'Prefer using `refute_instance_of(%<arguments>s)` over ' \
-              '`refute(%<receiver>s)`.'
-
-        def_node_matcher :refute_with_instance_of, <<~PATTERN
-          (send nil? :refute $(send $_ :instance_of? $_) $...)
-        PATTERN
-
-        def on_send(node)
-          refute_with_instance_of(node) do |first_receiver_arg, object, method, rest_args|
-            message = rest_args.first
-            arguments = node_arguments(object, method, message)
-            receiver = [first_receiver_arg.source, message&.source].compact.join(', ')
-
-            offense_message = format(MSG, arguments: arguments, receiver: receiver)
-
-            add_offense(node, message: offense_message)
-          end
-        end
-
-        def autocorrect(node)
-          lambda do |corrector|
-            refute_with_instance_of(node) do |_, object, method|
-              corrector.replace(node.loc.selector, 'refute_instance_of')
-
-              replacement = [method, object].map(&:source).join(', ')
-              corrector.replace(first_argument_range(node), replacement)
-            end
-          end
-        end
-
-        private
-
-        def node_arguments(object, method, message)
-          [method, object, message].compact.map(&:source).join(', ')
-        end
+        define_rule :refute, target_method: :instance_of?, inverse: true
       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