rubocop-minitest 0.2.1 → 0.5.1

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

@@ -3,7 +3,8 @@
 module RuboCop
   module Cop
     module Minitest
-      # Check if your test uses `assert_nil` instead of `assert_equal(nil, something)`.
+      # This cop enforces the test to use `assert_nil`
+      # instead of using `assert_equal(nil, something)`.
       #
       # @example
       #   # bad
@@ -15,6 +16,8 @@ module RuboCop
       #   assert_nil(actual, 'the message')
       #
       class AssertNil < Cop
+        include ArgumentRangeHelper
+
         MSG = 'Prefer using `assert_nil(%<arguments>s)` over ' \
               '`assert_equal(nil, %<arguments>s)`.'
 
@@ -34,9 +37,12 @@ module RuboCop
 
         def autocorrect(node)
           lambda do |corrector|
-            arguments = node.arguments.reject(&:nil_type?)
-            replacement = arguments.map(&:source).join(', ')
-            corrector.replace(node.loc.expression, "assert_nil(#{replacement})")
+            assert_equal_with_nil(node) do |actual|
+              corrector.replace(node.loc.selector, 'assert_nil')
+              corrector.replace(
+                first_and_second_arguments_range(node), actual.source
+              )
+            end
           end
         end
       end

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

@@ -0,0 +1,62 @@
+# frozen_string_literal: true
+
+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))`.
+      #
+      # @example
+      #   # bad
+      #   assert(object.respond_to?(:some_method))
+      #   assert(object.respond_to?(:some_method), 'the message')
+      #   assert(respond_to?(:some_method))
+      #
+      #   # good
+      #   assert_respond_to(object, :some_method)
+      #   assert_respond_to(object, :some_method, 'the message')
+      #   assert_respond_to(self, some_method)
+      #
+      class AssertRespondTo < Cop
+        include ArgumentRangeHelper
+
+        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
+      end
+    end
+  end
+end

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

@@ -3,8 +3,8 @@
 module RuboCop
   module Cop
     module Minitest
-      # Check if your test uses `assert(actual)`
-      # instead of `assert_equal(true, actual)`.
+      # This cop enforces the test to use `assert(actual)`
+      # instead of using `assert_equal(true, actual)`.
       #
       # @example
       #   # bad
@@ -16,6 +16,8 @@ module RuboCop
       #   assert(actual, 'the message')
       #
       class AssertTruthy < Cop
+        include ArgumentRangeHelper
+
         MSG = 'Prefer using `assert(%<arguments>s)` over ' \
               '`assert_equal(true, %<arguments>s)`.'
 
@@ -35,9 +37,12 @@ module RuboCop
 
         def autocorrect(node)
           lambda do |corrector|
-            arguments = node.arguments.reject(&:true_type?)
-            replacement = arguments.map(&:source).join(', ')
-            corrector.replace(node.loc.expression, "assert(#{replacement})")
+            assert_equal_with_truthy(node) do |actual|
+              corrector.replace(node.loc.selector, 'assert')
+              corrector.replace(
+                first_and_second_arguments_range(node), actual.source
+              )
+            end
           end
         end
       end

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

@@ -0,0 +1,51 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Minitest
+      # This cop enforces to use `refute_empty` instead of
+      # using `refute(object.empty?)`.
+      #
+      # @example
+      #   # bad
+      #   refute(object.empty?)
+      #   refute(object.empty?, 'the message')
+      #
+      #   # good
+      #   refute_empty(object)
+      #   refute_empty(object, 'the message')
+      #
+      class RefuteEmpty < Cop
+        include ArgumentRangeHelper
+
+        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
+      end
+    end
+  end
+end

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

@@ -0,0 +1,68 @@
+# frozen_string_literal: true
+
+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)`.
+      #
+      # @example
+      #   # bad
+      #   assert("rubocop-minitest" != actual)
+      #   assert(! "rubocop-minitest" == actual)
+      #
+      #   # good
+      #   refute_equal("rubocop-minitest", actual)
+      #
+      class RefuteEqual < Cop
+        include ArgumentRangeHelper
+
+        MSG = 'Prefer using `refute_equal(%<preferred>s)` over ' \
+              '`assert(%<over>s)`.'
+
+        def_node_matcher :assert_not_equal, <<~PATTERN
+          (send nil? :assert ${(send $_ :!= $_) (send (send $_ :! ) :== $_) } $... )
+        PATTERN
+
+        def on_send(node)
+          preferred, over = process_not_equal(node)
+          return unless preferred && over
+
+          message = format(MSG, preferred: preferred, over: over)
+          add_offense(node, message: message)
+        end
+
+        def autocorrect(node)
+          lambda do |corrector|
+            assert_not_equal(node) do |_, expected, actual|
+              corrector.replace(node.loc.selector, 'refute_equal')
+
+              replacement = [expected, actual].map(&:source).join(', ')
+              corrector.replace(first_argument_range(node), replacement)
+            end
+          end
+        end
+
+        private
+
+        def preferred_usage(first_arg, second_arg, custom_message = nil)
+          [first_arg, second_arg, custom_message]
+            .compact.map(&:source).join(', ')
+        end
+
+        def original_usage(first_part, custom_message)
+          [first_part, custom_message].compact.join(', ')
+        end
+
+        def process_not_equal(node)
+          assert_not_equal(node) do |over, first_arg, second_arg, rest_args|
+            custom_message = rest_args.first
+            preferred = preferred_usage(first_arg, second_arg, custom_message)
+            over = original_usage(over.source, custom_message&.source)
+            return [preferred, over]
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,51 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Minitest
+      # This cop enforces the use of `refute(object)`
+      # over `assert_equal(false, object)`.
+      #
+      # @example
+      #   # bad
+      #   assert_equal(false, actual)
+      #   assert_equal(false, actual, 'the message')
+      #
+      #   # good
+      #   refute(actual)
+      #   refute(actual, 'the message')
+      #
+      class RefuteFalse < Cop
+        include ArgumentRangeHelper
+
+        MSG = 'Prefer using `refute(%<arguments>s)` over ' \
+              '`assert_equal(false, %<arguments>s)`.'
+
+        def_node_matcher :assert_equal_with_false, <<~PATTERN
+          (send nil? :assert_equal false $_ $...)
+        PATTERN
+
+        def on_send(node)
+          assert_equal_with_false(node) do |actual, rest_receiver_arg|
+            message = rest_receiver_arg.first
+
+            arguments = [actual.source, message&.source].compact.join(', ')
+
+            add_offense(node, message: format(MSG, arguments: arguments))
+          end
+        end
+
+        def autocorrect(node)
+          lambda do |corrector|
+            assert_equal_with_false(node) do |actual|
+              corrector.replace(node.loc.selector, 'refute')
+              corrector.replace(
+                first_and_second_arguments_range(node), actual.source
+              )
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,61 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Minitest
+      # This cop enforces the test to use `refute_includes`
+      # instead of using `refute(collection.include?(object))`.
+      #
+      # @example
+      #   # bad
+      #   refute(collection.include?(object))
+      #   refute(collection.include?(object), 'the message')
+      #
+      #   # good
+      #   refute_includes(collection, object)
+      #   refute_includes(collection, object, 'the message')
+      #
+      class RefuteIncludes < Cop
+        include ArgumentRangeHelper
+
+        MSG = 'Prefer using `refute_includes(%<arguments>s)` over ' \
+              '`refute(%<receiver>s)`.'
+
+        def_node_matcher :refute_with_includes, <<~PATTERN
+          (send nil? :refute $(send $_ :include? $_) $...)
+        PATTERN
+
+        def on_send(node)
+          refute_with_includes(node) do
+            |first_receiver_arg, collection, object, rest_receiver_arg|
+
+            message = rest_receiver_arg.first
+            arguments = node_arguments(collection, object, 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_includes(node) do |_, collection, actual|
+              corrector.replace(node.loc.selector, 'refute_includes')
+
+              replacement = [collection, actual].map(&:source).join(', ')
+              corrector.replace(first_argument_range(node), replacement)
+            end
+          end
+        end
+
+        private
+
+        def node_arguments(collection, object, message)
+          [collection.source, object.source, message&.source].compact.join(', ')
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,59 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Minitest
+      # This cop enforces the use of `refute_instance_of(Class, object)`
+      # over `refute(object.instance_of?(Class))`.
+      #
+      # @example
+      #   # bad
+      #   refute(object.instance_of?(Class))
+      #   refute(object.instance_of?(Class), 'the message')
+      #
+      #   # good
+      #   refute_instance_of(Class, object)
+      #   refute_instance_of(Class, object, 'the message')
+      #
+      class RefuteInstanceOf < Cop
+        include ArgumentRangeHelper
+
+        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
+      end
+    end
+  end
+end

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

@@ -3,7 +3,8 @@
 module RuboCop
   module Cop
     module Minitest
-      # Check if your test uses `refute_nil` instead of `refute_equal(nil, something)`.
+      # This cop enforces the test to use `refute_nil`
+      # instead of using `refute_equal(nil, something)`.
       #
       # @example
       #   # bad
@@ -15,6 +16,8 @@ module RuboCop
       #   refute_nil(actual, 'the message')
       #
       class RefuteNil < Cop
+        include ArgumentRangeHelper
+
         MSG = 'Prefer using `refute_nil(%<arguments>s)` over ' \
               '`refute_equal(nil, %<arguments>s)`.'
 
@@ -34,9 +37,12 @@ module RuboCop
 
         def autocorrect(node)
           lambda do |corrector|
-            arguments = node.arguments.reject(&:nil_type?)
-            replacement = arguments.map(&:source).join(', ')
-            corrector.replace(node.loc.expression, "refute_nil(#{replacement})")
+            refute_equal_with_nil(node) do |actual|
+              corrector.replace(node.loc.selector, 'refute_nil')
+              corrector.replace(
+                first_and_second_arguments_range(node), actual.source
+              )
+            end
           end
         end
       end