rubocop-minitest 0.6.2 → 0.7.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
-SHA1:
-  metadata.gz: fc4f5cfff2920e3509292c6ff6fc813e67bf0fd4
-  data.tar.gz: 0b84a930fc18cd0872fc26795d03e2579bc2c43f
+SHA256:
+  metadata.gz: 2fe4a7de0dfd13839c19db673fa07861a917a78e2558fae305131eeb852ccb89
+  data.tar.gz: 6c2c47e6ecf6260635e87d86cbda171d4716a581fef79786af619b97b76a8dc4
 SHA512:
-  metadata.gz: 011aadcd866b0ad8dafd2dc7d08bb0902f00080c26fd36aef654bc5326b82a9ff8a961a540e05d87474b388c817ae472575046ea747e4093f15d6b468b4c4bfb
-  data.tar.gz: 75d3ef888f72db5d40bfdd7a33619c2280d69709ba633cfde388433c9b2b8757d727b710e169c86aaa2e612ef629bf815c2802fd22a2bb12274afb5a99479d20
+  metadata.gz: 9cf68be606a67b36392817fcf1436f5eb6b7c1b4bf1ea5c35516384dde2ff8a2a1b370bdbf900d3c58b96f0e4d0f5ae9c70084864ca08ef3fdbe0a8bf6a50a1d
+  data.tar.gz: 0f88de02da060b0b05c2ff6cb14d37989c1ca0d63b7c298809dda8fad8fb9271d41c98c816f90dff0282198a40096523c5a70151b7551fec0c4c6790a689bdfd

data/.gitattributes

@@ -0,0 +1 @@
+CHANGELOG.md merge=union

data/.rubocop_todo.yml

@@ -20,4 +20,4 @@ Metrics/MethodLength:
 # Configuration parameters: AutoCorrect, AllowHeredoc, AllowURI, URISchemes, IgnoreCopDirectives, IgnoredPatterns.
 # URISchemes: http, https
 Layout/LineLength:
-  Max: 90
+  Max: 100

data/CHANGELOG.md

@@ -2,6 +2,19 @@
 
 ## master (unreleased)
 
+## 0.7.0 (2020-03-09)
+
+### New features
+
+* [#60](https://github.com/rubocop-hq/rubocop-minitest/issues/60): Add new cop `Minitest/GlobalExpectations` to check for deprecated global expectations. ([@tejasbubane][])
+
+### 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][])
+* [#61](https://github.com/rubocop-hq/rubocop-minitest/pull/61): Fix a false negative for `Minitest/AssertInstanceOf` and `Minitest/RefuteInstanceOf` when an argument is enclosed in redundant parentheses. ([@koic][])
+* [#62](https://github.com/rubocop-hq/rubocop-minitest/pull/62): Fix a false negative for `Minitest/AssertEmpty` and `Minitest/RefuteEmpty` when an argument is enclosed in redundant parentheses. ([@koic][])
+
 ## 0.6.2 (2020-02-19)
 
 ### Bug fixes

data/README.md

@@ -73,6 +73,10 @@ Minitest/AssertNil:
     - test/my_file_to_ignore_test.rb
 ```
 
+## Documentation
+
+You can read a lot more about RuboCop Minitest in its [official docs](https://docs.rubocop.org/projects/minitest/).
+
 ## Contributing
 
 Checkout the [contribution guidelines](CONTRIBUTING.md).

data/config/default.yml

@@ -45,7 +45,7 @@ Minitest/AssertNil:
   VersionAdded: '0.1'
 
 Minitest/AssertRespondTo:
-  Description: 'This cop enforces the test to use `assert_respond_to(object, :some_method)` over `assert(object.respond_to?(:some_method))`.'
+  Description: 'This cop enforces the test to use `assert_respond_to(object, :do_something)` over `assert(object.respond_to?(:do_something))`.'
   StyleGuide: 'https://github.com/rubocop-hq/minitest-style-guide#assert-responds-to-method'
   Enabled: true
   VersionAdded: '0.3'
@@ -56,6 +56,11 @@ Minitest/AssertTruthy:
   Enabled: true
   VersionAdded: '0.2'
 
+Minitest/GlobalExpectations:
+  Description: 'This cop checks for deprecated global expectations.'
+  Enabled: true
+  VersionAdded: '0.7'
+
 Minitest/RefuteEmpty:
   Description: 'This cop enforces to use `refute_empty` instead of using `refute(object.empty?)`.'
   StyleGuide: 'https://github.com/rubocop-hq/minitest-style-guide#refute-empty'
@@ -99,7 +104,7 @@ Minitest/RefuteNil:
   VersionAdded: '0.2'
 
 Minitest/RefuteRespondTo:
-  Description: 'This cop enforces the test to use `refute_respond_to(object, :some_method)` over `refute(object.respond_to?(:some_method))`.'
+  Description: 'This cop enforces the test to use `refute_respond_to(object, :do_something)` over `refute(object.respond_to?(:do_something))`.'
   StyleGuide: 'https://github.com/rubocop-hq/minitest-style-guide#refute-respond-to'
   Enabled: true
   VersionAdded: '0.4'

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

@@ -9,42 +9,16 @@ module RuboCop
       # @example
       #   # bad
       #   assert(object.empty?)
-      #   assert(object.empty?, 'the message')
+      #   assert(object.empty?, 'message')
       #
       #   # good
       #   assert_empty(object)
-      #   assert_empty(object, 'the message')
+      #   assert_empty(object, 'message')
       #
       class AssertEmpty < Cop
-        include ArgumentRangeHelper
+        extend MinitestCopRule
 
-        MSG = 'Prefer using `assert_empty(%<arguments>s)` over ' \
-              '`assert(%<receiver>s)`.'
-
-        def_node_matcher :assert_with_empty, <<~PATTERN
-          (send nil? :assert $(send $_ :empty?) $...)
-        PATTERN
-
-        def on_send(node)
-          assert_with_empty(node) do |first_receiver_arg, actual, rest_receiver_arg|
-            message = rest_receiver_arg.first
-
-            arguments = [actual.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|
-            assert_with_empty(node) do |_, actual_arg|
-              corrector.replace(node.loc.selector, 'assert_empty')
-              corrector.replace(first_argument_range(node), actual_arg.source)
-            end
-          end
-        end
+        define_rule :assert, target_method: :empty?
       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_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_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_truthy.rb

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

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

@@ -0,0 +1,74 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Minitest
+      # This Cop checks for deprecated global expectations
+      # and autocorrects them to use expect format.
+      #
+      # @example
+      #   # bad
+      #   n.must_equal 42
+      #   n.wont_match b
+      #
+      #   # good
+      #   _(n).must_equal 42
+      #   _(n).wont_match b
+      class GlobalExpectations < Cop
+        MSG = 'Prefer using `%<corrected>s`.'
+
+        VALUE_MATCHERS = %i[
+          be be_close_to be_empty be_instance_of be_kind_of
+          be_nil be_same_as be_silent be_within_epsilon equal
+          include match respond_to must_exist
+        ].map do |matcher|
+          [:"must_#{matcher}", :"wont_#{matcher}"]
+        end.flatten.freeze
+
+        BLOCK_MATCHERS = %i[must_output must_raise must_throw].freeze
+
+        MATCHERS_STR = (VALUE_MATCHERS + BLOCK_MATCHERS).map do |m|
+          ":#{m}"
+        end.join(' ').freeze
+
+        def_node_matcher :global_expectation?, <<~PATTERN
+          (send (send _ _) {#{MATCHERS_STR}} ...)
+        PATTERN
+
+        def on_send(node)
+          return unless global_expectation?(node)
+
+          message = format(MSG, corrected: correct_suggestion(node))
+          add_offense(node, message: message)
+        end
+
+        def autocorrect(node)
+          return unless global_expectation?(node)
+
+          lambda do |corrector|
+            receiver = node.receiver.loc.selector
+
+            if BLOCK_MATCHERS.include?(node.method_name)
+              corrector.insert_before(receiver, '_ { ')
+              corrector.insert_after(receiver, ' }')
+            else
+              corrector.insert_before(receiver, '_(')
+              corrector.insert_after(receiver, ')')
+            end
+          end
+        end
+
+        private
+
+        def correct_suggestion(node)
+          source = node.receiver.source
+          if BLOCK_MATCHERS.include?(node.method_name)
+            node.source.sub(source, "_ { #{source} }")
+          else
+            node.source.sub(source, "_(#{source})")
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -9,42 +9,16 @@ module RuboCop
       # @example
       #   # bad
       #   refute(object.empty?)
-      #   refute(object.empty?, 'the message')
+      #   refute(object.empty?, 'message')
       #
       #   # good
       #   refute_empty(object)
-      #   refute_empty(object, 'the message')
+      #   refute_empty(object, 'message')
       #
       class RefuteEmpty < Cop
-        include ArgumentRangeHelper
+        extend MinitestCopRule
 
-        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
+        define_rule :refute, target_method: :empty?
       end
     end
   end