rubocop-minitest 0.8.1 → 0.10.3

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

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,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 node.each_child_node(:send).none? { |send_node| assertion_method?(send_node.method_name) }
+
+          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

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

data/lib/rubocop/cop/minitest_cops.rb

@@ -1,22 +1,37 @@
 # frozen_string_literal: true
 
 require_relative 'mixin/argument_range_helper'
+require_relative 'mixin/in_delta_mixin'
 require_relative 'mixin/minitest_cop_rule'
+require_relative 'mixin/minitest_exploration_helpers'
 require_relative 'minitest/assert_empty'
 require_relative 'minitest/assert_empty_literal'
 require_relative 'minitest/assert_equal'
+require_relative 'minitest/assert_in_delta'
+require_relative 'minitest/assertion_in_lifecycle_hook'
+require_relative 'minitest/assert_kind_of'
 require_relative 'minitest/assert_nil'
 require_relative 'minitest/assert_includes'
 require_relative 'minitest/assert_instance_of'
 require_relative 'minitest/assert_match'
+require_relative 'minitest/assert_output'
+require_relative 'minitest/assert_path_exists'
 require_relative 'minitest/assert_respond_to'
+require_relative 'minitest/assert_silent'
 require_relative 'minitest/assert_truthy'
 require_relative 'minitest/global_expectations'
+require_relative 'minitest/literal_as_actual_argument'
+require_relative 'minitest/multiple_assertions'
 require_relative 'minitest/refute_empty'
 require_relative 'minitest/refute_false'
 require_relative 'minitest/refute_equal'
+require_relative 'minitest/refute_in_delta'
+require_relative 'minitest/refute_kind_of'
 require_relative 'minitest/refute_nil'
 require_relative 'minitest/refute_includes'
 require_relative 'minitest/refute_match'
 require_relative 'minitest/refute_instance_of'
+require_relative 'minitest/refute_path_exists'
 require_relative 'minitest/refute_respond_to'
+require_relative 'minitest/test_method_name'
+require_relative 'minitest/unspecified_exception'

data/lib/rubocop/cop/mixin/argument_range_helper.rb

@@ -26,6 +26,16 @@ module RuboCop
           second_argument.source_range.end_pos
         )
       end
+
+      def all_arguments_range(node)
+        first_argument = node.first_argument
+        last_argument = node.arguments.last
+
+        range_between(
+          first_argument.source_range.begin_pos,
+          last_argument.source_range.end_pos
+        )
+      end
     end
   end
 end

data/lib/rubocop/cop/mixin/in_delta_mixin.rb

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    # Common functionality for `AssertInDelta` and `RefuteInDelta` cops.
+    module InDeltaMixin
+      MSG = 'Prefer using `%<good_method>s` over `%<bad_method>s`.'
+
+      def on_send(node)
+        equal_floats_call(node) do |expected, actual, message|
+          message = message.first
+
+          if expected.float_type? || actual.float_type?
+            message = format(MSG,
+                             good_method: build_good_method(expected, actual, message),
+                             bad_method: node.source)
+
+            add_offense(node, message: message)
+          end
+        end
+      end
+
+      def autocorrect(node)
+        equal_floats_call(node) do |expected, actual, message|
+          message = message.first
+          replacement = build_good_method(expected, actual, message)
+
+          lambda do |corrector|
+            corrector.replace(node, replacement)
+          end
+        end
+      end
+
+      private
+
+      def build_good_method(expected, actual, message)
+        if message
+          "#{assertion_method}_in_delta(#{expected.source}, #{actual.source}, 0.001, #{message.source})"
+        else
+          "#{assertion_method}_in_delta(#{expected.source}, #{actual.source})"
+        end
+      end
+
+      def assertion_method
+        class_name = self.class.name.split('::').last
+        class_name[/\A[[:upper:]][[:lower:]]+/].downcase
+      end
+    end
+  end
+end

data/lib/rubocop/cop/mixin/minitest_cop_rule.rb

@@ -57,7 +57,7 @@ module RuboCop
           private
 
           def peel_redundant_parentheses_from(arguments)
-            return arguments unless arguments.first.begin_type?
+            return arguments unless arguments.first&.begin_type?
 
             peel_redundant_parentheses_from(arguments.first.children)
           end

data/lib/rubocop/cop/mixin/minitest_exploration_helpers.rb

@@ -0,0 +1,97 @@
+# frozen_string_literal: true
+
+require 'set'
+
+module RuboCop
+  module Cop
+    # Helper methods for different explorations against test files and test cases.
+    module MinitestExplorationHelpers
+      extend NodePattern::Macros
+
+      ASSERTION_PREFIXES = %w[assert refute].freeze
+
+      ASSERTION_METHODS = %i[
+        assert assert_empty assert_equal assert_in_delta assert_in_epsilon assert_includes assert_instance_of
+        assert_kind_of assert_match assert_nil assert_operator assert_output assert_path_exists assert_predicate
+        assert_raises assert_respond_to assert_same assert_send assert_silent assert_throws
+        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
+
+      LIFECYCLE_HOOK_METHODS = %i[
+        before_setup
+        setup
+        after_setup
+        before_teardown
+        teardown
+        after_teardown
+      ].to_set.freeze
+
+      private
+
+      def test_class?(class_node)
+        class_node.parent_class && class_node.identifier.source.end_with?('Test')
+      end
+
+      def test_case?(node)
+        return false unless node&.def_type? && test_case_name?(node.method_name)
+
+        class_ancestor = node.each_ancestor(:class).first
+        test_class?(class_ancestor)
+      end
+
+      def test_cases(class_node)
+        class_def_nodes(class_node)
+          .select { |def_node| test_case_name?(def_node.method_name) }
+      end
+
+      def lifecycle_hooks(class_node)
+        class_def_nodes(class_node)
+          .select { |def_node| lifecycle_hook_method?(def_node) }
+      end
+
+      def class_def_nodes(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 test_case_name?(name)
+        name.to_s.start_with?('test_')
+      end
+
+      def assertions(def_node)
+        method_def = def_node.body
+        return [] unless method_def
+
+        send_nodes =
+          if method_def.send_type?
+            [method_def]
+          else
+            method_def.each_child_node(:send)
+          end
+
+        send_nodes.select { |send_node| assertion?(send_node) }
+      end
+
+      def assertion?(node)
+        node.send_type? &&
+          ASSERTION_PREFIXES.any? { |prefix| node.method_name.to_s.start_with?(prefix) }
+      end
+
+      def assertion_method?(method_name)
+        ASSERTION_METHODS.include?(method_name)
+      end
+
+      def lifecycle_hook_method?(node)
+        node.def_type? && LIFECYCLE_HOOK_METHODS.include?(node.method_name)
+      end
+    end
+  end
+end