Fix a false negative for Minitest/AssertRespondTo

CHANGELOG.md

@@ -5,6 +5,7 @@
 ### Bug fixes
 
 * [#58](https://github.com/rubocop-hq/rubocop-minitest/pull/58): Fix a false negative for `Minitest/AssertMatch` and `Minitest/RefuteMatch` when an argument is enclosed in redundant parentheses. ([@koic][])
+* [#59](https://github.com/rubocop-hq/rubocop-minitest/pull/59): Fix a false negative for `Minitest/AssertRespondTo` and `Minitest/RefuteRespondTo` when an argument is enclosed in redundant parentheses. ([@koic][])
 
 ## 0.6.2 (2020-02-19)
 

lib/rubocop/cop/minitest/assert_respond_to.rb

@@ -18,44 +18,9 @@ module Minitest
       #   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
+        rule :assert, target_method: :respond_to?, prefer_method: :assert_respond_to
       end
     end
   end

lib/rubocop/cop/minitest/refute_respond_to.rb

@@ -18,44 +18,9 @@ module Minitest
       #   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
+        rule :refute, target_method: :respond_to?, prefer_method: :refute_respond_to
       end
     end
   end

lib/rubocop/cop/mixin/minitest_cop_rule.rb

@@ -24,9 +24,10 @@ def autocorrect(node)
               corrector.replace(node.loc.selector, '#{prefer_method}')
 
               arguments = peel_redundant_parentheses_from(node.arguments)
+              receiver = correct_receiver(arguments.first.receiver)
 
               new_arguments = [
-                arguments.first.receiver.source,
+                receiver,
                 arguments.first.arguments.map(&:source)
               ].join(', ')
 
@@ -59,18 +60,23 @@ def offense_message(arguments)
           end
 
           def new_arguments(arguments)
+            receiver = correct_receiver(arguments.first.receiver)
             message_argument = arguments.last if arguments.first != arguments.last
 
             [
-              arguments.first.receiver,
-              arguments.first.arguments.first,
-              message_argument
-            ].compact.map(&:source).join(', ')
+              receiver,
+              arguments.first.arguments.first.source,
+              message_argument&.source
+            ].compact.join(', ')
           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

test/rubocop/cop/minitest/assert_respond_to_test.rb

@@ -85,6 +85,25 @@ def test_do_something
     RUBY
   end
 
+  def test_registers_offense_when_using_assert_with_respond_to_in_redundant_parentheses
+    assert_offense(<<~RUBY)
+      class FooTest < Minitest::Test
+        def test_do_something
+          assert((object.respond_to?(:do_something)))
+          ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ Prefer using `assert_respond_to(object, :do_something)` over `assert(object.respond_to?(:do_something))`.
+        end
+      end
+    RUBY
+
+    assert_correction(<<~RUBY)
+      class FooTest < Minitest::Test
+        def test_do_something
+          assert_respond_to((object, :do_something))
+        end
+      end
+    RUBY
+  end
+
   def test_does_not_register_offense_when_using_assert_respond_to
     assert_no_offenses(<<~RUBY)
       class FooTest < Minitest::Test

test/rubocop/cop/minitest/refute_respond_to_test.rb

@@ -85,6 +85,25 @@ def test_do_something
     RUBY
   end
 
+  def test_registers_offense_when_using_refute_with_respond_to_in_redundant_parentheses
+    assert_offense(<<~RUBY)
+      class FooTest < Minitest::Test
+        def test_do_something
+          refute((object.respond_to?(:do_something)))
+          ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ Prefer using `refute_respond_to(object, :do_something)` over `refute(object.respond_to?(:do_something))`.
+        end
+      end
+    RUBY
+
+    assert_correction(<<~RUBY)
+      class FooTest < Minitest::Test
+        def test_do_something
+          refute_respond_to((object, :do_something))
+        end
+      end
+    RUBY
+  end
+
   def test_does_not_register_offense_when_using_assert_respond_to
     assert_no_offenses(<<~RUBY)
       class FooTest < Minitest::Test