rubocop-minitest 0.2.0 → 0.5.0

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

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

@@ -0,0 +1,59 @@
+# 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
+        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, rest_args|
+              custom_message = rest_args.first
+              preferred = build_preferred_arguments(object, method, custom_message)
+              replacement = "assert_respond_to(#{preferred})"
+              corrector.replace(node.loc.expression, 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

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
+        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 |_first_receiver_arg, object, rest_receiver_arg|
+              message = rest_receiver_arg.first
+
+              replacement = [object.source, message&.source].compact.join(', ')
+              corrector.replace(node.loc.expression, "refute_empty(#{replacement})")
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,69 @@
+# 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
+        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 |_, first_arg, second_arg, rest_args|
+              autocorrect_node(node, corrector, first_arg, second_arg, rest_args)
+            end
+          end
+        end
+
+        private
+
+        def autocorrect_node(node, corrector, first_arg, second_arg, rest_args)
+          custom_message = rest_args.first
+          replacement = preferred_usage(first_arg, second_arg, custom_message)
+          corrector.replace(node.loc.expression, "refute_equal(#{replacement})")
+        end
+
+        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,46 @@
+# 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
+        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|
+            arguments = node.arguments.reject(&:false_type?)
+            replacement = arguments.map(&:source).join(', ')
+            corrector.replace(node.loc.expression, "refute(#{replacement})")
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,60 @@
+# 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
+        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
+              |_receiver, collection, object, rest_receiver_arg|
+
+              message = rest_receiver_arg.first
+              replacement = node_arguments(collection, object, message)
+              corrector.replace(node.loc.expression, "refute_includes(#{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,60 @@
+# 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
+        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, rest_args|
+              message = rest_args.first
+              arguments = node_arguments(object, method, message)
+
+              replacement = "refute_instance_of(#{arguments})"
+              corrector.replace(node.loc.expression, 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

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

@@ -0,0 +1,59 @@
+# frozen_string_literal: true
+
+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))`.
+      #
+      # @example
+      #   # bad
+      #   refute(object.respond_to?(:some_method))
+      #   refute(object.respond_to?(:some_method), 'the message')
+      #   refute(respond_to?(:some_method))
+      #
+      #   # good
+      #   refute_respond_to(object, :some_method)
+      #   refute_respond_to(object, :some_method, 'the message')
+      #   refute_respond_to(self, :some_method)
+      #
+      class RefuteRespondTo < Cop
+        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, rest_args|
+              custom_message = rest_args.first
+              preferred = build_preferred_arguments(object, method, custom_message)
+              replacement = "refute_respond_to(#{preferred})"
+              corrector.replace(node.loc.expression, 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_cops.rb

@@ -1,7 +1,17 @@
 # frozen_string_literal: true
 
 require_relative 'minitest/assert_empty'
+require_relative 'minitest/assert_empty_literal'
+require_relative 'minitest/assert_equal'
 require_relative 'minitest/assert_nil'
 require_relative 'minitest/assert_includes'
+require_relative 'minitest/assert_instance_of'
+require_relative 'minitest/assert_respond_to'
 require_relative 'minitest/assert_truthy'
+require_relative 'minitest/refute_empty'
+require_relative 'minitest/refute_false'
+require_relative 'minitest/refute_equal'
 require_relative 'minitest/refute_nil'
+require_relative 'minitest/refute_includes'
+require_relative 'minitest/refute_instance_of'
+require_relative 'minitest/refute_respond_to'