rubocop-minitest 0.2.1 → 0.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: dc2eabe582388a8716653ef64d84833b48547f2c0e84fd666c36ab59b773abdc
-  data.tar.gz: 726cd0a1cc2f11eee03f49278408b9eda29308d74641cdc8a562f84c063e4e8c
+  metadata.gz: 6971c190fb9bb75de58013b61826afebf8ff0213d6b4a82e215704baa655014d
+  data.tar.gz: 2a1abf652db222f834a3e400240d99e01edca9539de7024220598e03e75cea26
 SHA512:
-  metadata.gz: 60bec75d6fab0181c7f1ee5e664ca0a9dda0d8ba7d9a54d184a7f4573633e10fccef93719da3dead41c5919862f67aa0b66eb92f1dc933759c240e093ee93bd0
-  data.tar.gz: 28d6e3f708ce291589ff8e2b74a12792777dbc39e244309951ba21e1ffdd59ac982fed3f52af148acca2b8a96bc8f0158711c3e99f893f09d26ef74beb743d2e
+  metadata.gz: 8bc4d5b65791a48ffc5cfe2256b7496d6b99d750b331640bd8e2406c0cc030af2a9daf4a32671c81727a200ce6ba0d7601ab5752b84887d239f35204a8974a0d
+  data.tar.gz: 0b58903c1bf5ab77e2a5d27c0b318d4d917ab78bbebe9a42f5f8432e2116bce9ceec6c5efc09dc640cd6efc1399fab17ed65422ef0fbce6de3ab82fb99d2c84c

data/.github/FUNDING.yml

@@ -0,0 +1,6 @@
+# These are supported funding model platforms
+
+github: bbatsov
+patreon: bbatsov
+open_collective: rubocop
+custom: https://www.paypal.me/bbatsov

data/CHANGELOG.md

@@ -2,6 +2,20 @@
 
 ## master (unreleased)
 
+## 0.3.0 (2019-10-13)
+
+### New features
+
+* [#15](https://github.com/rubocop-hq/rubocop-minitest/pull/15): Add new `Minitest/RefuteIncludes` cop. ([@abhaynikam][])
+* [#18](https://github.com/rubocop-hq/rubocop-minitest/pull/18): Add new `Minitest/RefuteFalse` cop. ([@duduribeiro][])
+* [#20](https://github.com/rubocop-hq/rubocop-minitest/pull/20): Add new `Minitest/RefuteEmpty` cop. ([@abhaynikam][])
+* [#21](https://github.com/rubocop-hq/rubocop-minitest/pull/21): Add new `Minitest/RefuteEqual` cop. ([@duduribeiro][])
+* [#27](https://github.com/rubocop-hq/rubocop-minitest/pull/27): Add new `Minitest/AssertRespondTo` cop. ([@duduribeiro][])
+
+### Bug fixes
+
+* [#19](https://github.com/rubocop-hq/rubocop-minitest/pull/19): Fix a false negative for `Minitest/AssertIncludes` when using `include` method in arguments of `assert` method. ([@abhaynikam][])
+
 ## 0.2.1 (2019-09-24)
 
 ### Bug fixes

data/config/default.yml

@@ -3,31 +3,61 @@ Minitest:
     - '**/test/**/*'
 
 Minitest/AssertNil:
-  Description: 'Check if your test uses `assert_nil` instead of `assert_equal(nil, something)`.'
+  Description: 'This cop enforces the test to use `assert_nil` instead of using `assert_equal(nil, something)`.'
   StyleGuide: 'https://github.com/rubocop-hq/minitest-style-guide#assert-nil'
   Enabled: true
   VersionAdded: '0.1'
 
 Minitest/AssertEmpty:
-  Description: 'Check if your test uses `assert_empty` instead of `assert(actual.empty?)`.'
+  Description: 'This cop enforces the test to use `assert_empty` instead of using `assert(object.empty?)`.'
   StyleGuide: 'https://github.com/rubocop-hq/minitest-style-guide#assert-empty'
   Enabled: true
   VersionAdded: '0.2'
 
 Minitest/AssertIncludes:
-  Description: 'Check if your test uses `assert_includes` instead of `assert(collection.includes?(actual))`.'
+  Description: 'This cop enforces the test to use `assert_includes` instead of using `assert(collection.include?(object))`.'
   StyleGuide: 'https://github.com/rubocop-hq/minitest-style-guide#assert-includes'
   Enabled: true
   VersionAdded: '0.2'
 
+Minitest/AssertRespondTo:
+  Description: 'This cop enforces the test to use `assert_respond_to(object, :some_method)` over `assert(object.respond_to?(:some_method))`.'
+  StyleGuide: 'https://github.com/rubocop-hq/minitest-style-guide#assert-responds-to-method'
+  Enabled: true
+  VersionAdded: '0.3'
+
 Minitest/AssertTruthy:
-  Description: 'Check if your test uses `assert(actual)` instead of `assert_equal(true, actual)`.'
+  Description: 'This cop enforces the test to use `assert(actual)` instead of using `assert_equal(true, actual)`.'
   StyleGuide: 'https://github.com/rubocop-hq/minitest-style-guide#assert-truthy'
   Enabled: true
   VersionAdded: '0.2'
 
+Minitest/RefuteEqual:
+  Description: 'Check if your test uses `refute_equal` instead of `assert(expected != object)` or `assert(! expected == object))`.'
+  StyleGuide: 'https://github.com/rubocop-hq/minitest-style-guide#refute-equal'
+  Enabled: true
+  VersionAdded: '0.3'
+
 Minitest/RefuteNil:
-  Description: 'Check if your test uses `refute_nil` instead of `refute_equal(nil, something)`.'
+  Description: 'This cop enforces the test to use `refute_nil` instead of using `refute_equal(nil, something)`.'
   StyleGuide: 'https://github.com/rubocop-hq/minitest-style-guide#refute-nil'
   Enabled: true
   VersionAdded: '0.2'
+
+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'
+  Enabled: true
+  VersionAdded: '0.3'
+
+Minitest/RefuteIncludes:
+  Description: 'This cop enforces the test to use `refute_includes` instead of using `refute(collection.include?(object))`.'
+  StyleGuide: 'https://github.com/rubocop-hq/minitest-style-guide#refute-includes'
+  Enabled: true
+  VersionAdded: '0.3'
+
+Minitest/RefuteFalse:
+  Description: 'Check if your test uses `refute(actual)` instead of `assert_equal(false, actual)`.'
+  StyleGuide: 'https://github.com/rubocop-hq/minitest-style-guide#refute-false'
+  Enabled: true
+  VersionAdded: '0.3'

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

@@ -3,16 +3,17 @@
 module RuboCop
   module Cop
     module Minitest
-      # Check if your test uses `assert_empty` instead of `assert(actual.empty?)`.
+      # This cop enforces the test to use `assert_empty`
+      # instead of using `assert(object.empty?)`.
       #
       # @example
       #   # bad
-      #   assert(actual.empty?)
-      #   assert(actual.empty?, 'the message')
+      #   assert(object.empty?)
+      #   assert(object.empty?, 'the message')
       #
       #   # good
-      #   assert_empty(actual)
-      #   assert_empty(actual, 'the message')
+      #   assert_empty(object)
+      #   assert_empty(object, 'the message')
       #
       class AssertEmpty < Cop
         MSG = 'Prefer using `assert_empty(%<arguments>s)` over ' \

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

@@ -3,24 +3,24 @@
 module RuboCop
   module Cop
     module Minitest
-      # Check if your test uses `assert_includes`
-      # instead of `assert(collection.includes?(actual))`.
+      # This cop enforces the test to use `assert_includes`
+      # instead of using `assert(collection.include?(object))`.
       #
       # @example
       #   # bad
-      #   assert(collection.includes?(actual))
-      #   assert(collection.includes?(actual), 'the message')
+      #   assert(collection.include?(object))
+      #   assert(collection.include?(object), 'the message')
       #
       #   # good
-      #   assert_includes(collection, actual)
-      #   assert_includes(collection, actual, 'the message')
+      #   assert_includes(collection, object)
+      #   assert_includes(collection, object, 'the message')
       #
       class AssertIncludes < Cop
         MSG = 'Prefer using `assert_includes(%<arguments>s)` over ' \
               '`assert(%<receiver>s)`.'
 
         def_node_matcher :assert_with_includes, <<~PATTERN
-          (send nil? :assert $(send $_ :includes? $_) $...)
+          (send nil? :assert $(send $_ :include? $_) $...)
         PATTERN
 
         def on_send(node)

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,51 @@
+# 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')
+      #
+      #   # good
+      #   assert_respond_to(object, :some_method)
+      #   assert_respond_to(object, :some_method, 'the message')
+      #
+      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 = [object, method, custom_message]
+                        .compact.map(&:source).join(', ')
+            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 = [object, method, custom_message]
+                          .compact.map(&:source).join(', ')
+              replacement = "assert_respond_to(#{preferred})"
+              corrector.replace(node.loc.expression, replacement)
+            end
+          end
+        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_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_cops.rb

@@ -3,5 +3,10 @@
 require_relative 'minitest/assert_empty'
 require_relative 'minitest/assert_nil'
 require_relative 'minitest/assert_includes'
+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'

data/lib/rubocop/minitest/version.rb

@@ -2,6 +2,6 @@
 
 module RuboCop
   module Minitest
-    VERSION = '0.2.1'
+    VERSION = '0.3.0'
   end
 end

data/manual/cops.md

@@ -4,7 +4,12 @@
 * [Minitest/AssertEmpty](cops_minitest.md#minitestassertempty)
 * [Minitest/AssertIncludes](cops_minitest.md#minitestassertincludes)
 * [Minitest/AssertNil](cops_minitest.md#minitestassertnil)
+* [Minitest/AssertRespondTo](cops_minitest.md#minitestassertrespondto)
 * [Minitest/AssertTruthy](cops_minitest.md#minitestasserttruthy)
+* [Minitest/RefuteEmpty](cops_minitest.md#minitestrefuteempty)
+* [Minitest/RefuteEqual](cops_minitest.md#minitestrefuteequal)
+* [Minitest/RefuteFalse](cops_minitest.md#minitestrefutefalse)
+* [Minitest/RefuteIncludes](cops_minitest.md#minitestrefuteincludes)
 * [Minitest/RefuteNil](cops_minitest.md#minitestrefutenil)
 
 <!-- END_COP_LIST -->

data/manual/cops_minitest.md

@@ -6,18 +6,19 @@ Enabled by default | Safe | Supports autocorrection | VersionAdded | VersionChan
 --- | --- | --- | --- | ---
 Enabled | Yes | Yes  | 0.2 | -
 
-Check if your test uses `assert_empty` instead of `assert(actual.empty?)`.
+This cop enforces the test to use `assert_empty`
+instead of using `assert(object.empty?)`.
 
 ### Examples
 
 ```ruby
 # bad
-assert(actual.empty?)
-assert(actual.empty?, 'the message')
+assert(object.empty?)
+assert(object.empty?, 'the message')
 
 # good
-assert_empty(actual)
-assert_empty(actual, 'the message')
+assert_empty(object)
+assert_empty(object, 'the message')
 ```
 
 ### References
@@ -30,19 +31,19 @@ Enabled by default | Safe | Supports autocorrection | VersionAdded | VersionChan
 --- | --- | --- | --- | ---
 Enabled | Yes | Yes  | 0.2 | -
 
-Check if your test uses `assert_includes`
-instead of `assert(collection.includes?(actual))`.
+This cop enforces the test to use `assert_includes`
+instead of using `assert(collection.include?(object))`.
 
 ### Examples
 
 ```ruby
 # bad
-assert(collection.includes?(actual))
-assert(collection.includes?(actual), 'the message')
+assert(collection.include?(object))
+assert(collection.include?(object), 'the message')
 
 # good
-assert_includes(collection, actual)
-assert_includes(collection, actual, 'the message')
+assert_includes(collection, object)
+assert_includes(collection, object, 'the message')
 ```
 
 ### References
@@ -55,7 +56,8 @@ Enabled by default | Safe | Supports autocorrection | VersionAdded | VersionChan
 --- | --- | --- | --- | ---
 Enabled | Yes | Yes  | 0.1 | -
 
-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)`.
 
 ### Examples
 
@@ -73,14 +75,39 @@ assert_nil(actual, 'the message')
 
 * [https://github.com/rubocop-hq/minitest-style-guide#assert-nil](https://github.com/rubocop-hq/minitest-style-guide#assert-nil)
 
+## Minitest/AssertRespondTo
+
+Enabled by default | Safe | Supports autocorrection | VersionAdded | VersionChanged
+--- | --- | --- | --- | ---
+Enabled | Yes | Yes  | 0.3 | -
+
+This cop enforces the use of `assert_respond_to(object, :some_method)`
+over `assert(object.respond_to?(:some_method))`.
+
+### Examples
+
+```ruby
+# bad
+assert(object.respond_to?(:some_method))
+assert(object.respond_to?(:some_method), 'the message')
+
+# good
+assert_respond_to(object, :some_method)
+assert_respond_to(object, :some_method, 'the message')
+```
+
+### References
+
+* [https://github.com/rubocop-hq/minitest-style-guide#assert-responds-to-method](https://github.com/rubocop-hq/minitest-style-guide#assert-responds-to-method)
+
 ## Minitest/AssertTruthy
 
 Enabled by default | Safe | Supports autocorrection | VersionAdded | VersionChanged
 --- | --- | --- | --- | ---
 Enabled | Yes | Yes  | 0.2 | -
 
-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)`.
 
 ### Examples
 
@@ -98,13 +125,113 @@ assert(actual, 'the message')
 
 * [https://github.com/rubocop-hq/minitest-style-guide#assert-truthy](https://github.com/rubocop-hq/minitest-style-guide#assert-truthy)
 
+## Minitest/RefuteEmpty
+
+Enabled by default | Safe | Supports autocorrection | VersionAdded | VersionChanged
+--- | --- | --- | --- | ---
+Enabled | Yes | Yes  | 0.3 | -
+
+This cop enforces to use `refute_empty` instead of
+using `refute(object.empty?)`.
+
+### Examples
+
+```ruby
+# bad
+refute(object.empty?)
+refute(object.empty?, 'the message')
+
+# good
+refute_empty(object)
+refute_empty(object, 'the message')
+```
+
+### References
+
+* [https://github.com/rubocop-hq/minitest-style-guide#refute-empty](https://github.com/rubocop-hq/minitest-style-guide#refute-empty)
+
+## Minitest/RefuteEqual
+
+Enabled by default | Safe | Supports autocorrection | VersionAdded | VersionChanged
+--- | --- | --- | --- | ---
+Enabled | Yes | Yes  | 0.3 | -
+
+This cop enforces the use of `refute_equal(expected, object)`
+over `assert_equal(expected != actual)` or `assert(! expected -= actual)`.
+
+### Examples
+
+```ruby
+# bad
+assert("rubocop-minitest" != actual)
+assert(! "rubocop-minitest" == actual)
+
+# good
+refute_equal("rubocop-minitest", actual)
+```
+
+### References
+
+* [https://github.com/rubocop-hq/minitest-style-guide#refute-equal](https://github.com/rubocop-hq/minitest-style-guide#refute-equal)
+
+## Minitest/RefuteFalse
+
+Enabled by default | Safe | Supports autocorrection | VersionAdded | VersionChanged
+--- | --- | --- | --- | ---
+Enabled | Yes | Yes  | 0.3 | -
+
+This cop enforces the use of `refute(object)`
+over `assert_equal(false, object)`.
+
+### Examples
+
+```ruby
+# bad
+assert_equal(false, actual)
+assert_equal(false, actual, 'the message')
+
+# good
+refute(actual)
+refute(actual, 'the message')
+```
+
+### References
+
+* [https://github.com/rubocop-hq/minitest-style-guide#refute-false](https://github.com/rubocop-hq/minitest-style-guide#refute-false)
+
+## Minitest/RefuteIncludes
+
+Enabled by default | Safe | Supports autocorrection | VersionAdded | VersionChanged
+--- | --- | --- | --- | ---
+Enabled | Yes | Yes  | 0.3 | -
+
+This cop enforces the test to use `refute_includes`
+instead of using `refute(collection.include?(object))`.
+
+### Examples
+
+```ruby
+# bad
+refute(collection.include?(object))
+refute(collection.include?(object), 'the message')
+
+# good
+refute_includes(collection, object)
+refute_includes(collection, object, 'the message')
+```
+
+### References
+
+* [https://github.com/rubocop-hq/minitest-style-guide#refute-includes](https://github.com/rubocop-hq/minitest-style-guide#refute-includes)
+
 ## Minitest/RefuteNil
 
 Enabled by default | Safe | Supports autocorrection | VersionAdded | VersionChanged
 --- | --- | --- | --- | ---
 Enabled | Yes | Yes  | 0.2 | -
 
-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)`.
 
 ### Examples
 

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: rubocop-minitest
 version: !ruby/object:Gem::Version
-  version: 0.2.1
+  version: 0.3.0
 platform: ruby
 authors:
 - Bozhidar Batsov
@@ -10,7 +10,7 @@ authors:
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2019-09-24 00:00:00.000000000 Z
+date: 2019-10-13 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rubocop
@@ -49,6 +49,7 @@ extensions: []
 extra_rdoc_files: []
 files:
 - ".circleci/config.yml"
+- ".github/FUNDING.yml"
 - ".github/ISSUE_TEMPLATE/bug_report.md"
 - ".github/ISSUE_TEMPLATE/feature_request.md"
 - ".github/PULL_REQUEST_TEMPLATE.md"
@@ -68,7 +69,12 @@ files:
 - lib/rubocop/cop/minitest/assert_empty.rb
 - lib/rubocop/cop/minitest/assert_includes.rb
 - lib/rubocop/cop/minitest/assert_nil.rb
+- lib/rubocop/cop/minitest/assert_respond_to.rb
 - lib/rubocop/cop/minitest/assert_truthy.rb
+- lib/rubocop/cop/minitest/refute_empty.rb
+- lib/rubocop/cop/minitest/refute_equal.rb
+- lib/rubocop/cop/minitest/refute_false.rb
+- lib/rubocop/cop/minitest/refute_includes.rb
 - lib/rubocop/cop/minitest/refute_nil.rb
 - lib/rubocop/cop/minitest_cops.rb
 - lib/rubocop/minitest.rb
@@ -107,7 +113,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.0.6
+rubygems_version: 3.0.3
 signing_key: 
 specification_version: 4
 summary: Automatic Minitest code style checking tool.