rubocop-minitest 0.6.2 → 0.10.0

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

@@ -14,38 +14,9 @@ module RuboCop
       #   assert_equal("rubocop-minitest", actual)
       #
       class AssertEqual < Cop
-        include ArgumentRangeHelper
+        extend MinitestCopRule
 
-        MSG = 'Prefer using `assert_equal(%<preferred>s)` over ' \
-              '`assert(%<over>s)`.'
-
-        def_node_matcher :assert_equal, <<~PATTERN
-          (send nil? :assert $(send $_ :== $_) $...)
-        PATTERN
-
-        def on_send(node)
-          assert_equal(node) do |first_receiver_arg, expected, actual, rest_receiver_arg|
-            message = rest_receiver_arg.first
-            preferred = [expected.source, actual.source, message&.source]
-                        .compact.join(', ')
-            over = [first_receiver_arg.source, message&.source].compact.join(', ')
-
-            offense_message = format(MSG, preferred: preferred, over: over)
-
-            add_offense(node, message: offense_message)
-          end
-        end
-
-        def autocorrect(node)
-          lambda do |corrector|
-            assert_equal(node) do |_, expected, actual|
-              corrector.replace(node.loc.selector, 'assert_equal')
-
-              replacement = [expected, actual].map(&:source).join(', ')
-              corrector.replace(first_argument_range(node), replacement)
-            end
-          end
-        end
+        define_rule :assert, target_method: :==, preferred_method: :assert_equal
       end
     end
   end

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

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Minitest
+      # This cop enforces the test to use `assert_in_delta`
+      # instead of using `assert_equal` to compare floats.
+      #
+      # @example
+      #   # bad
+      #   assert_equal(0.2, actual)
+      #   assert_equal(0.2, actual, 'message')
+      #
+      #   # good
+      #   assert_in_delta(0.2, actual)
+      #   assert_in_delta(0.2, actual, 0.001, 'message')
+      #
+      class AssertInDelta < Cop
+        include InDeltaMixin
+
+        def_node_matcher :equal_floats_call, <<~PATTERN
+          (send nil? :assert_equal $_ $_ $...)
+        PATTERN
+      end
+    end
+  end
+end

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

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

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

@@ -9,50 +9,16 @@ module RuboCop
       # @example
       #   # bad
       #   assert(object.instance_of?(Class))
-      #   assert(object.instance_of?(Class), 'the message')
+      #   assert(object.instance_of?(Class), 'message')
       #
       #   # good
       #   assert_instance_of(Class, object)
-      #   assert_instance_of(Class, object, 'the message')
+      #   assert_instance_of(Class, object, 'message')
       #
       class AssertInstanceOf < Cop
-        include ArgumentRangeHelper
+        extend MinitestCopRule
 
-        MSG = 'Prefer using `assert_instance_of(%<arguments>s)` over ' \
-              '`assert(%<receiver>s)`.'
-
-        def_node_matcher :assert_with_instance_of, <<~PATTERN
-          (send nil? :assert $(send $_ :instance_of? $_) $...)
-        PATTERN
-
-        def on_send(node)
-          assert_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|
-            assert_with_instance_of(node) do |_, object, method|
-              corrector.replace(node.loc.selector, 'assert_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 :assert, target_method: :instance_of?, inverse: true
       end
     end
   end

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

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

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

@@ -9,51 +9,16 @@ module RuboCop
       # @example
       #   # bad
       #   assert(matcher.match(string))
-      #   assert(matcher.match(string), 'the message')
+      #   assert(matcher.match(string), 'message')
       #
       #   # good
       #   assert_match(regex, string)
-      #   assert_match(matcher, string, 'the message')
+      #   assert_match(matcher, string, 'message')
       #
       class AssertMatch < Cop
-        include ArgumentRangeHelper
+        extend MinitestCopRule
 
-        MSG = 'Prefer using `assert_match(%<arguments>s)` over ' \
-              '`assert(%<receiver>s)`.'
-
-        def_node_matcher :assert_with_match, <<~PATTERN
-          (send nil? :assert $(send $_ :match $_) $...)
-        PATTERN
-
-        def on_send(node)
-          assert_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|
-            assert_with_match(node) do |_, matcher, actual|
-              corrector.replace(node.loc.selector, 'assert_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 :assert, target_method: :match
       end
     end
   end

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

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

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

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Minitest
+      # This cop checks for opportunities to use `assert_output`.
+      #
+      # @example
+      #   # bad
+      #   $stdout = StringIO.new
+      #   puts object.method
+      #   $stdout.rewind
+      #   assert_match expected, $stdout.read
+      #
+      #   # good
+      #   assert_output(expected) { puts object.method }
+      #
+      class AssertOutput < Cop
+        include MinitestExplorationHelpers
+
+        MSG = 'Use `assert_output` instead of mutating %<name>s.'
+        OUTPUT_GLOBAL_VARIABLES = %i[$stdout $stderr].freeze
+
+        def on_gvasgn(node)
+          test_case_node = find_test_case(node)
+          return unless test_case_node
+
+          gvar_name = node.children.first
+          return unless OUTPUT_GLOBAL_VARIABLES.include?(gvar_name)
+
+          assertions(test_case_node).each do |assertion|
+            add_offense(assertion, message: format(MSG, name: gvar_name)) if references_gvar?(assertion, gvar_name)
+          end
+        end
+
+        private
+
+        def find_test_case(node)
+          def_ancestor = node.each_ancestor(:def).first
+          def_ancestor if test_case?(def_ancestor)
+        end
+
+        def references_gvar?(assertion, gvar_name)
+          assertion.each_descendant(:gvar).any? { |d| d.children.first == gvar_name }
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,58 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Minitest
+      # This cop enforces the test to use `assert_path_exists`
+      # instead of using `assert(File.exist?(path))`.
+      #
+      # @example
+      #   # bad
+      #   assert(File.exist?(path))
+      #   assert(File.exist?(path), 'message')
+      #
+      #   # good
+      #   assert_path_exists(path)
+      #   assert_path_exists(path, 'message')
+      #
+      class AssertPathExists < Cop
+        MSG = 'Prefer using `%<good_method>s` over `%<bad_method>s`.'
+
+        def_node_matcher :assert_file_exists, <<~PATTERN
+          (send nil? :assert
+            (send
+              (const _ :File) {:exist? :exists?} $_)
+              $...)
+        PATTERN
+
+        def on_send(node)
+          assert_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)
+          assert_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(', ')
+          "assert_path_exists(#{args})"
+        end
+      end
+    end
+  end
+end

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

@@ -3,59 +3,24 @@
 module RuboCop
   module Cop
     module Minitest
-      # This cop enforces the use of `assert_respond_to(object, :some_method)`
-      # over `assert(object.respond_to?(:some_method))`.
+      # This cop enforces the use of `assert_respond_to(object, :do_something)`
+      # over `assert(object.respond_to?(:do_something))`.
       #
       # @example
       #   # bad
-      #   assert(object.respond_to?(:some_method))
-      #   assert(object.respond_to?(:some_method), 'the message')
-      #   assert(respond_to?(:some_method))
+      #   assert(object.respond_to?(:do_something))
+      #   assert(object.respond_to?(:do_something), 'message')
+      #   assert(respond_to?(:do_something))
       #
       #   # good
-      #   assert_respond_to(object, :some_method)
-      #   assert_respond_to(object, :some_method, 'the message')
-      #   assert_respond_to(self, some_method)
+      #   assert_respond_to(object, :do_something)
+      #   assert_respond_to(object, :do_something, 'message')
+      #   assert_respond_to(self, :do_something)
       #
       class AssertRespondTo < Cop
-        include ArgumentRangeHelper
+        extend MinitestCopRule
 
-        MSG = 'Prefer using `assert_respond_to(%<preferred>s)` over ' \
-              '`assert(%<over>s)`.'
-
-        def_node_matcher :assert_with_respond_to, <<~PATTERN
-          (send nil? :assert $(send $_ :respond_to? $_) $...)
-        PATTERN
-
-        def on_send(node)
-          assert_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|
-            assert_with_respond_to(node) do |_, object, method|
-              corrector.replace(node.loc.selector, 'assert_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 :assert, target_method: :respond_to?
       end
     end
   end

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