rubocop-minitest 0.6.2 → 0.10.0

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

@@ -9,51 +9,16 @@ module RuboCop
       # @example
       #   # bad
       #   refute(matcher.match(string))
-      #   refute(matcher.match(string), 'the message')
+      #   refute(matcher.match(string), 'message')
       #
       #   # good
       #   refute_match(matcher, string)
-      #   refute_match(matcher, string, 'the message')
+      #   refute_match(matcher, string, 'message')
       #
       class RefuteMatch < Cop
-        include ArgumentRangeHelper
+        extend MinitestCopRule
 
-        MSG = 'Prefer using `refute_match(%<arguments>s)` over ' \
-              '`refute(%<receiver>s)`.'
-
-        def_node_matcher :refute_with_match, <<~PATTERN
-          (send nil? :refute $(send $_ :match $_) $...)
-        PATTERN
-
-        def on_send(node)
-          refute_with_match(node) do
-            |first_receiver_arg, matcher, actual, rest_receiver_arg|
-            message = rest_receiver_arg.first
-            arguments = node_arguments(matcher, actual, 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_match(node) do |_, matcher, actual|
-              corrector.replace(node.loc.selector, 'refute_match')
-
-              replacement = [matcher, actual].map(&:source).join(', ')
-              corrector.replace(first_argument_range(node), replacement)
-            end
-          end
-        end
-
-        private
-
-        def node_arguments(matcher, actual, message)
-          [matcher.source, actual.source, message&.source].compact.join(', ')
-        end
+        define_rule :refute, target_method: :match
       end
     end
   end

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

@@ -9,11 +9,11 @@ module RuboCop
       # @example
       #   # bad
       #   refute_equal(nil, actual)
-      #   refute_equal(nil, actual, 'the message')
+      #   refute_equal(nil, actual, 'message')
       #
       #   # good
       #   refute_nil(actual)
-      #   refute_nil(actual, 'the message')
+      #   refute_nil(actual, 'message')
       #
       class RefuteNil < Cop
         include ArgumentRangeHelper

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/refute_respond_to.rb

@@ -3,59 +3,24 @@
 module RuboCop
   module Cop
     module Minitest
-      # This cop enforces the test to use `refute_respond_to(object, :some_method)`
-      # over `refute(object.respond_to?(:some_method))`.
+      # This cop enforces the test to use `refute_respond_to(object, :do_something)`
+      # over `refute(object.respond_to?(:do_something))`.
       #
       # @example
       #   # bad
-      #   refute(object.respond_to?(:some_method))
-      #   refute(object.respond_to?(:some_method), 'the message')
-      #   refute(respond_to?(:some_method))
+      #   refute(object.respond_to?(:do_something))
+      #   refute(object.respond_to?(:do_something), 'message')
+      #   refute(respond_to?(:do_something))
       #
       #   # good
-      #   refute_respond_to(object, :some_method)
-      #   refute_respond_to(object, :some_method, 'the message')
-      #   refute_respond_to(self, :some_method)
+      #   refute_respond_to(object, :do_something)
+      #   refute_respond_to(object, :do_something, 'message')
+      #   refute_respond_to(self, :do_something)
       #
       class RefuteRespondTo < Cop
-        include ArgumentRangeHelper
+        extend MinitestCopRule
 
-        MSG = 'Prefer using `refute_respond_to(%<preferred>s)` over ' \
-              '`refute(%<over>s)`.'
-
-        def_node_matcher :refute_with_respond_to, <<~PATTERN
-          (send nil? :refute $(send $_ :respond_to? $_) $...)
-        PATTERN
-
-        def on_send(node)
-          refute_with_respond_to(node) do |over, object, method, rest_args|
-            custom_message = rest_args.first
-            preferred = build_preferred_arguments(object, method, custom_message)
-            over = [over, custom_message].compact.map(&:source).join(', ')
-            message = format(MSG, preferred: preferred, over: over)
-            add_offense(node, message: message)
-          end
-        end
-
-        def autocorrect(node)
-          lambda do |corrector|
-            refute_with_respond_to(node) do |_, object, method|
-              corrector.replace(node.loc.selector, 'refute_respond_to')
-
-              object = object ? object.source : 'self'
-              replacement = [object, method.source].join(', ')
-              corrector.replace(first_argument_range(node), replacement)
-            end
-          end
-        end
-
-        private
-
-        def build_preferred_arguments(receiver, method, message)
-          receiver = receiver ? receiver.source : 'self'
-
-          [receiver, method.source, message&.source].compact.join(', ')
-        end
+        define_rule :refute, target_method: :respond_to?
       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

data/lib/rubocop/cop/minitest_cops.rb

@@ -1,21 +1,37 @@
 # frozen_string_literal: true
 
 require_relative 'mixin/argument_range_helper'
-require_relative 'mixin/includes_cop_rule'
+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

@@ -0,0 +1,102 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    # Provide a method to define offense rule for Minitest cops.
+    module MinitestCopRule
+      #
+      # Define offense rule for Minitest cops.
+      #
+      # @example
+      #   define_rule :assert, target_method: :match
+      #   define_rule :refute, target_method: :match
+      #   define_rule :assert, target_method: :include?, preferred_method: :assert_includes
+      #   define_rule :assert, target_method: :instance_of?, inverse: true
+      #
+      # @param assertion_method [Symbol] Assertion method like `assert` or `refute`.
+      # @param target_method [Symbol] Method name offensed by assertion method arguments.
+      # @param preferred_method [Symbol] An optional param. Custom method name replaced by
+      #                                  auto-correction. The preferred method name that connects
+      #                                  `assertion_method` and `target_method` with `_` is
+      #                                  the default name.
+      # @param inverse [Boolean] An optional param. Order of arguments replaced by auto-correction.
+      #
+      def define_rule(assertion_method, target_method:, preferred_method: nil, inverse: false)
+        preferred_method = "#{assertion_method}_#{target_method.to_s.delete('?')}" if preferred_method.nil?
+
+        class_eval(<<~RUBY, __FILE__, __LINE__ + 1)
+          include ArgumentRangeHelper
+
+          MSG = 'Prefer using `#{preferred_method}(%<new_arguments>s)` over ' \
+                '`#{assertion_method}(%<original_arguments>s)`.'
+
+          def on_send(node)
+            return unless node.method?(:#{assertion_method})
+            return unless (arguments = peel_redundant_parentheses_from(node.arguments))
+            return unless arguments.first.respond_to?(:method?) && arguments.first.method?(:#{target_method})
+
+            add_offense(node, message: offense_message(arguments))
+          end
+
+          def autocorrect(node)
+            lambda do |corrector|
+              corrector.replace(node.loc.selector, '#{preferred_method}')
+
+              arguments = peel_redundant_parentheses_from(node.arguments)
+
+              new_arguments = new_arguments(arguments).join(', ')
+
+              if enclosed_in_redundant_parentheses?(node)
+                new_arguments = '(' + new_arguments + ')'
+              end
+
+              corrector.replace(first_argument_range(node), new_arguments)
+            end
+          end
+
+          private
+
+          def peel_redundant_parentheses_from(arguments)
+            return arguments unless arguments.first.begin_type?
+
+            peel_redundant_parentheses_from(arguments.first.children)
+          end
+
+          def offense_message(arguments)
+            message_argument = arguments.last if arguments.first != arguments.last
+
+            new_arguments = [
+              new_arguments(arguments),
+              message_argument&.source
+            ].flatten.compact.join(', ')
+
+            original_arguments = arguments.map(&:source).join(', ')
+
+            format(
+              MSG,
+              new_arguments: new_arguments,
+              original_arguments: original_arguments
+            )
+          end
+
+          def new_arguments(arguments)
+            receiver = correct_receiver(arguments.first.receiver)
+            method_argument = arguments.first.arguments.first&.source
+
+            new_arguments = [receiver, method_argument].compact
+            new_arguments.reverse! if #{inverse}
+            new_arguments
+          end
+
+          def enclosed_in_redundant_parentheses?(node)
+            node.arguments.first.begin_type?
+          end
+
+          def correct_receiver(receiver)
+            receiver ? receiver.source : 'self'
+          end
+        RUBY
+      end
+    end
+  end
+end