rubocop-minitest 0.9.0 → 0.11.0

data/bin/console

@@ -2,6 +2,8 @@
 # frozen_string_literal: true
 
 require 'bundler/setup'
+require 'pathname'
+require 'yaml'
 require 'rubocop/minitest'
 
 # You can add fixtures and/or initialization code here to make experimenting

data/config/default.yml

@@ -6,106 +6,190 @@ Minitest:
 
 Minitest/AssertEmpty:
   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'
+  StyleGuide: 'https://minitest.rubystyle.guide#assert-empty'
   Enabled: true
   VersionAdded: '0.2'
 
 Minitest/AssertEmptyLiteral:
   Description: 'This cop enforces the test to use `assert_empty` instead of using `assert([], object)` or `assert({}, object)`.'
   Enabled: true
+  SafeAutoCorrect: false
   VersionAdded: '0.5'
+  VersionChanged: '0.11'
 
 Minitest/AssertEqual:
   Description: 'This cop enforces the test to use `assert_equal` instead of using `assert(expected == actual)`.'
-  StyleGuide: 'https://github.com/rubocop-hq/minitest-style-guide#assert-equal-arguments-order'
+  StyleGuide: 'https://minitest.rubystyle.guide#assert-equal-arguments-order'
   Enabled: true
   VersionAdded: '0.4'
 
+Minitest/AssertInDelta:
+  Description: 'This cop enforces the test to use `assert_in_delta` instead of using `assert_equal` to compare floats.'
+  StyleGuide: 'https://minitest.rubystyle.guide/#assert-in-delta'
+  Enabled: 'pending'
+  VersionAdded: '0.10'
+
+Minitest/AssertionInLifecycleHook:
+  Description: 'This cop checks for usage of assertions in lifecycle hooks.'
+  Enabled: 'pending'
+  VersionAdded: '0.10'
+
 Minitest/AssertMatch:
   Description: 'This cop enforces the test to use `assert_match` instead of using `assert(matcher.match(object))`.'
-  StyleGuide: 'https://github.com/rubocop-hq/minitest-style-guide#assert-match'
+  StyleGuide: 'https://minitest.rubystyle.guide#assert-match'
   Enabled: true
   VersionAdded: '0.6'
 
 Minitest/AssertIncludes:
   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'
+  StyleGuide: 'https://minitest.rubystyle.guide#assert-includes'
   Enabled: true
   VersionAdded: '0.2'
 
 Minitest/AssertInstanceOf:
   Description: 'This cop enforces the test to use `assert_instance_of(Class, object)` over `assert(object.instance_of?(Class))`'
-  StyleGuide: 'https://github.com/rubocop-hq/minitest-style-guide#assert-instance-of'
+  StyleGuide: 'https://minitest.rubystyle.guide#assert-instance-of'
   Enabled: true
   VersionAdded: '0.4'
 
+Minitest/AssertKindOf:
+  Description: 'This cop enforces the test to use `assert_kind_of(Class, object)` over `assert(object.kind_of?(Class))`'
+  StyleGuide: 'https://github.com/rubocop/minitest-style-guide#assert-kind-of'
+  Enabled: 'pending'
+  VersionAdded: '0.10'
+
 Minitest/AssertNil:
   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'
+  StyleGuide: 'https://minitest.rubystyle.guide#assert-nil'
   Enabled: true
   VersionAdded: '0.1'
 
+Minitest/AssertOutput:
+  Description: 'This cop checks for opportunities to use `assert_output`.'
+  StyleGuide: 'https://minitest.rubystyle.guide/#assert-output'
+  Enabled: 'pending'
+  VersionAdded: '0.10'
+
+Minitest/AssertPathExists:
+  Description: 'This cop enforces the test to use `assert_path_exists` instead of using `assert(File.exist?(path))`.'
+  StyleGuide: 'https://minitest.rubystyle.guide/#assert-path-exists'
+  Enabled: 'pending'
+  VersionAdded: '0.10'
+
 Minitest/AssertRespondTo:
   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'
+  StyleGuide: 'https://minitest.rubystyle.guide#assert-responds-to-method'
   Enabled: true
   VersionAdded: '0.3'
 
+Minitest/AssertSilent:
+  Description: "This cop enforces the test to use `assert_silent { ... }` instead of using `assert_output('', '') { ... }`."
+  StyleGuide: 'https://github.com/rubocop/minitest-style-guide#assert-silent'
+  Enabled: 'pending'
+  VersionAdded: '0.10'
+
 Minitest/AssertTruthy:
   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'
+  StyleGuide: 'https://minitest.rubystyle.guide#assert-truthy'
   Enabled: true
   VersionAdded: '0.2'
 
+Minitest/AssertWithExpectedArgument:
+  Description: 'This cop tries to detect when a user accidentally used `assert` when they meant to use `assert_equal`.'
+  Enabled: pending
+  VersionAdded: '0.11'
+
 Minitest/GlobalExpectations:
   Description: 'This cop checks for deprecated global expectations.'
+  StyleGuide: 'https://minitest.rubystyle.guide#global-expectations'
   Enabled: true
   VersionAdded: '0.7'
 
+Minitest/LiteralAsActualArgument:
+  Description: 'This cop enforces correct order of `expected` and `actual` arguments for `assert_equal`.'
+  StyleGuide: 'https://minitest.rubystyle.guide/#assert-equal-arguments-order'
+  Enabled: 'pending'
+  VersionAdded: '0.10'
+
+Minitest/MultipleAssertions:
+  Description: 'This cop checks if test cases contain too many assertion calls.'
+  Enabled: 'pending'
+  VersionAdded: '0.10'
+  Max: 3
+
 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'
+  StyleGuide: 'https://minitest.rubystyle.guide#refute-empty'
   Enabled: true
   VersionAdded: '0.3'
 
 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'
+  StyleGuide: 'https://minitest.rubystyle.guide#refute-equal'
   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'
+  StyleGuide: 'https://minitest.rubystyle.guide#refute-false'
   Enabled: true
   VersionAdded: '0.3'
 
+Minitest/RefuteInDelta:
+  Description: 'This cop enforces the test to use `refute_in_delta` instead of using `refute_equal` to compare floats.'
+  StyleGuide: 'https://minitest.rubystyle.guide/#refute-in-delta'
+  Enabled: 'pending'
+  VersionAdded: '0.10'
+
 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'
+  StyleGuide: 'https://minitest.rubystyle.guide#refute-includes'
   Enabled: true
   VersionAdded: '0.3'
 
 Minitest/RefuteMatch:
   Description: 'This cop enforces the test to use `refute_match` instead of using `refute(matcher.match(object))`.'
-  StyleGuide: 'https://github.com/rubocop-hq/minitest-style-guide#refute-match'
+  StyleGuide: 'https://minitest.rubystyle.guide#refute-match'
   Enabled: true
   VersionAdded: '0.6'
 
 Minitest/RefuteInstanceOf:
   Description: 'This cop enforces the test to use `refute_instance_of(Class, object)` over `refute(object.instance_of?(Class))`.'
-  StyleGuide: 'https://github.com/rubocop-hq/minitest-style-guide#refute-instance-of'
+  StyleGuide: 'https://minitest.rubystyle.guide#refute-instance-of'
   Enabled: true
   VersionAdded: '0.4'
 
+Minitest/RefuteKindOf:
+  Description: 'This cop enforces the test to use `refute_kind_of(Class, object)` over `refute(object.kind_of?(Class))`.'
+  StyleGuide: 'https://github.com/rubocop/minitest-style-guide#refute-kind-of'
+  Enabled: 'pending'
+  VersionAdded: '0.10'
+
 Minitest/RefuteNil:
   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'
+  StyleGuide: 'https://minitest.rubystyle.guide#refute-nil'
   Enabled: true
   VersionAdded: '0.2'
 
+Minitest/RefutePathExists:
+  Description: 'This cop enforces the test to use `refute_path_exists` instead of using `refute(File.exist?(path))`.'
+  StyleGuide: 'https://minitest.rubystyle.guide/#refute-path-exists'
+  Enabled: 'pending'
+  VersionAdded: '0.10'
+
 Minitest/RefuteRespondTo:
   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'
+  StyleGuide: 'https://minitest.rubystyle.guide#refute-respond-to'
   Enabled: true
   VersionAdded: '0.4'
+
+Minitest/TestMethodName:
+  Description: 'This cop enforces that test method names start with `test_` prefix.'
+  Enabled: 'pending'
+  VersionAdded: '0.10'
+
+Minitest/UnspecifiedException:
+  Description: 'This cop checks for a specified error in `assert_raises`.'
+  StyleGuide: 'https://minitest.rubystyle.guide#unspecified-exception'
+  Enabled: 'pending'
+  VersionAdded: '0.10'

data/docs/antora.yml

@@ -0,0 +1,7 @@
+name: rubocop-minitest
+title: RuboCop Minitest
+# We always provide version without patch here (e.g. 1.1),
+# as patch versions should not appear in the docs.
+version: '0.11'
+nav:
+- modules/ROOT/nav.adoc

data/docs/modules/ROOT/nav.adoc

@@ -0,0 +1,6 @@
+* xref:index.adoc[Home]
+* xref:installation.adoc[Installation]
+* xref:usage.adoc[Usage]
+* xref:cops.adoc[Cops]
+* Cops Documentation
+** xref:cops_minitest.adoc[Minitest]

data/docs/modules/ROOT/pages/cops.adoc

@@ -0,0 +1,49 @@
+= Cops
+
+In RuboCop lingo the various checks performed on the code are called cops.
+Each cop is responsible for detecting one particular offense.
+RuboCop Minitest has only one Minitest department.
+
+== Minitest
+
+Minitest cops check for Minitest best practices and coding conventions. Many of the them are
+based on the https://minitest.rubystyle.guide/[Minitest Style Guide].
+
+// START_COP_LIST
+
+=== Department xref:cops_minitest.adoc[Minitest]
+
+* xref:cops_minitest.adoc#minitestassertempty[Minitest/AssertEmpty]
+* xref:cops_minitest.adoc#minitestassertemptyliteral[Minitest/AssertEmptyLiteral]
+* xref:cops_minitest.adoc#minitestassertequal[Minitest/AssertEqual]
+* xref:cops_minitest.adoc#minitestassertindelta[Minitest/AssertInDelta]
+* xref:cops_minitest.adoc#minitestassertincludes[Minitest/AssertIncludes]
+* xref:cops_minitest.adoc#minitestassertinstanceof[Minitest/AssertInstanceOf]
+* xref:cops_minitest.adoc#minitestassertkindof[Minitest/AssertKindOf]
+* xref:cops_minitest.adoc#minitestassertmatch[Minitest/AssertMatch]
+* xref:cops_minitest.adoc#minitestassertnil[Minitest/AssertNil]
+* xref:cops_minitest.adoc#minitestassertoutput[Minitest/AssertOutput]
+* xref:cops_minitest.adoc#minitestassertpathexists[Minitest/AssertPathExists]
+* xref:cops_minitest.adoc#minitestassertrespondto[Minitest/AssertRespondTo]
+* xref:cops_minitest.adoc#minitestassertsilent[Minitest/AssertSilent]
+* xref:cops_minitest.adoc#minitestasserttruthy[Minitest/AssertTruthy]
+* xref:cops_minitest.adoc#minitestassertwithexpectedargument[Minitest/AssertWithExpectedArgument]
+* xref:cops_minitest.adoc#minitestassertioninlifecyclehook[Minitest/AssertionInLifecycleHook]
+* xref:cops_minitest.adoc#minitestglobalexpectations[Minitest/GlobalExpectations]
+* xref:cops_minitest.adoc#minitestliteralasactualargument[Minitest/LiteralAsActualArgument]
+* xref:cops_minitest.adoc#minitestmultipleassertions[Minitest/MultipleAssertions]
+* xref:cops_minitest.adoc#minitestrefuteempty[Minitest/RefuteEmpty]
+* xref:cops_minitest.adoc#minitestrefuteequal[Minitest/RefuteEqual]
+* xref:cops_minitest.adoc#minitestrefutefalse[Minitest/RefuteFalse]
+* xref:cops_minitest.adoc#minitestrefuteindelta[Minitest/RefuteInDelta]
+* xref:cops_minitest.adoc#minitestrefuteincludes[Minitest/RefuteIncludes]
+* xref:cops_minitest.adoc#minitestrefuteinstanceof[Minitest/RefuteInstanceOf]
+* xref:cops_minitest.adoc#minitestrefutekindof[Minitest/RefuteKindOf]
+* xref:cops_minitest.adoc#minitestrefutematch[Minitest/RefuteMatch]
+* xref:cops_minitest.adoc#minitestrefutenil[Minitest/RefuteNil]
+* xref:cops_minitest.adoc#minitestrefutepathexists[Minitest/RefutePathExists]
+* xref:cops_minitest.adoc#minitestrefuterespondto[Minitest/RefuteRespondTo]
+* xref:cops_minitest.adoc#minitesttestmethodname[Minitest/TestMethodName]
+* xref:cops_minitest.adoc#minitestunspecifiedexception[Minitest/UnspecifiedException]
+
+// END_COP_LIST

data/docs/modules/ROOT/pages/cops_minitest.adoc

@@ -0,0 +1,1050 @@
+= Minitest
+
+== Minitest/AssertEmpty
+
+|===
+| Enabled by default | Safe | Supports autocorrection | VersionAdded | VersionChanged
+
+| Enabled
+| Yes
+| Yes
+| 0.2
+| -
+|===
+
+This cop enforces the test to use `assert_empty`
+instead of using `assert(object.empty?)`.
+
+=== Examples
+
+[source,ruby]
+----
+# bad
+assert(object.empty?)
+assert(object.empty?, 'message')
+
+# good
+assert_empty(object)
+assert_empty(object, 'message')
+----
+
+=== References
+
+* https://minitest.rubystyle.guide#assert-empty
+
+== Minitest/AssertEmptyLiteral
+
+|===
+| Enabled by default | Safe | Supports autocorrection | VersionAdded | VersionChanged
+
+| Enabled
+| Yes
+| Yes (Unsafe)
+| 0.5
+| 0.11
+|===
+
+This cop enforces the test to use `assert_empty`
+instead of using `assert_equal([], object)`.
+
+=== Examples
+
+[source,ruby]
+----
+# bad
+assert_equal([], object)
+assert_equal({}, object)
+
+# good
+assert_empty(object)
+----
+
+== Minitest/AssertEqual
+
+|===
+| Enabled by default | Safe | Supports autocorrection | VersionAdded | VersionChanged
+
+| Enabled
+| Yes
+| Yes
+| 0.4
+| -
+|===
+
+This cop enforces the use of `assert_equal(expected, actual)`
+over `assert(expected == actual)`.
+
+=== Examples
+
+[source,ruby]
+----
+# bad
+assert("rubocop-minitest" == actual)
+
+# good
+assert_equal("rubocop-minitest", actual)
+----
+
+=== References
+
+* https://minitest.rubystyle.guide#assert-equal-arguments-order
+
+== Minitest/AssertInDelta
+
+|===
+| Enabled by default | Safe | Supports autocorrection | VersionAdded | VersionChanged
+
+| Pending
+| Yes
+| Yes
+| 0.10
+| -
+|===
+
+This cop enforces the test to use `assert_in_delta`
+instead of using `assert_equal` to compare floats.
+
+=== Examples
+
+[source,ruby]
+----
+# bad
+assert_equal(0.2, actual)
+assert_equal(0.2, actual, 'message')
+
+# good
+assert_in_delta(0.2, actual)
+assert_in_delta(0.2, actual, 0.001, 'message')
+----
+
+=== References
+
+* https://minitest.rubystyle.guide/#assert-in-delta
+
+== Minitest/AssertIncludes
+
+|===
+| Enabled by default | Safe | Supports autocorrection | VersionAdded | VersionChanged
+
+| Enabled
+| Yes
+| Yes
+| 0.2
+| -
+|===
+
+This cop enforces the test to use `assert_includes`
+instead of using `assert(collection.include?(object))`.
+
+=== Examples
+
+[source,ruby]
+----
+# bad
+assert(collection.include?(object))
+assert(collection.include?(object), 'message')
+
+# good
+assert_includes(collection, object)
+assert_includes(collection, object, 'message')
+----
+
+=== References
+
+* https://minitest.rubystyle.guide#assert-includes
+
+== Minitest/AssertInstanceOf
+
+|===
+| Enabled by default | Safe | Supports autocorrection | VersionAdded | VersionChanged
+
+| Enabled
+| Yes
+| Yes
+| 0.4
+| -
+|===
+
+This cop enforces the test to use `assert_instance_of(Class, object)`
+over `assert(object.instance_of?(Class))`.
+
+=== Examples
+
+[source,ruby]
+----
+# bad
+assert(object.instance_of?(Class))
+assert(object.instance_of?(Class), 'message')
+
+# good
+assert_instance_of(Class, object)
+assert_instance_of(Class, object, 'message')
+----
+
+=== References
+
+* https://minitest.rubystyle.guide#assert-instance-of
+
+== Minitest/AssertKindOf
+
+|===
+| Enabled by default | Safe | Supports autocorrection | VersionAdded | VersionChanged
+
+| Pending
+| Yes
+| Yes
+| 0.10
+| -
+|===
+
+This cop enforces the test to use `assert_kind_of(Class, object)`
+over `assert(object.kind_of?(Class))`.
+
+=== Examples
+
+[source,ruby]
+----
+# bad
+assert(object.kind_of?(Class))
+assert(object.kind_of?(Class), 'message')
+
+# good
+assert_kind_of(Class, object)
+assert_kind_of(Class, object, 'message')
+----
+
+=== References
+
+* https://github.com/rubocop/minitest-style-guide#assert-kind-of
+
+== Minitest/AssertMatch
+
+|===
+| Enabled by default | Safe | Supports autocorrection | VersionAdded | VersionChanged
+
+| Enabled
+| Yes
+| Yes
+| 0.6
+| -
+|===
+
+This cop enforces the test to use `assert_match`
+instead of using `assert(matcher.match(string))`.
+
+=== Examples
+
+[source,ruby]
+----
+# bad
+assert(matcher.match(string))
+assert(matcher.match(string), 'message')
+
+# good
+assert_match(regex, string)
+assert_match(matcher, string, 'message')
+----
+
+=== References
+
+* https://minitest.rubystyle.guide#assert-match
+
+== Minitest/AssertNil
+
+|===
+| Enabled by default | Safe | Supports autocorrection | VersionAdded | VersionChanged
+
+| Enabled
+| Yes
+| Yes
+| 0.1
+| -
+|===
+
+This cop enforces the test to use `assert_nil`
+instead of using `assert_equal(nil, something)`.
+
+=== Examples
+
+[source,ruby]
+----
+# bad
+assert_equal(nil, actual)
+assert_equal(nil, actual, 'message')
+
+# good
+assert_nil(actual)
+assert_nil(actual, 'message')
+----
+
+=== References
+
+* https://minitest.rubystyle.guide#assert-nil
+
+== Minitest/AssertOutput
+
+|===
+| Enabled by default | Safe | Supports autocorrection | VersionAdded | VersionChanged
+
+| Pending
+| Yes
+| No
+| 0.10
+| -
+|===
+
+This cop checks for opportunities to use `assert_output`.
+
+=== Examples
+
+[source,ruby]
+----
+# bad
+$stdout = StringIO.new
+puts object.method
+$stdout.rewind
+assert_match expected, $stdout.read
+
+# good
+assert_output(expected) { puts object.method }
+----
+
+=== References
+
+* https://minitest.rubystyle.guide/#assert-output
+
+== Minitest/AssertPathExists
+
+|===
+| Enabled by default | Safe | Supports autocorrection | VersionAdded | VersionChanged
+
+| Pending
+| Yes
+| Yes
+| 0.10
+| -
+|===
+
+This cop enforces the test to use `assert_path_exists`
+instead of using `assert(File.exist?(path))`.
+
+=== Examples
+
+[source,ruby]
+----
+# bad
+assert(File.exist?(path))
+assert(File.exist?(path), 'message')
+
+# good
+assert_path_exists(path)
+assert_path_exists(path, 'message')
+----
+
+=== References
+
+* https://minitest.rubystyle.guide/#assert-path-exists
+
+== 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, :do_something)`
+over `assert(object.respond_to?(:do_something))`.
+
+=== Examples
+
+[source,ruby]
+----
+# bad
+assert(object.respond_to?(:do_something))
+assert(object.respond_to?(:do_something), 'message')
+assert(respond_to?(:do_something))
+
+# good
+assert_respond_to(object, :do_something)
+assert_respond_to(object, :do_something, 'message')
+assert_respond_to(self, :do_something)
+----
+
+=== References
+
+* https://minitest.rubystyle.guide#assert-responds-to-method
+
+== Minitest/AssertSilent
+
+|===
+| Enabled by default | Safe | Supports autocorrection | VersionAdded | VersionChanged
+
+| Pending
+| Yes
+| Yes
+| 0.10
+| -
+|===
+
+This cop enforces the test to use `assert_silent { ... }`
+instead of using `assert_output('', '') { ... }`.
+
+=== Examples
+
+[source,ruby]
+----
+# bad
+assert_output('', '') { puts object.do_something }
+
+# good
+assert_silent { puts object.do_something }
+----
+
+=== References
+
+* https://github.com/rubocop/minitest-style-guide#assert-silent
+
+== Minitest/AssertTruthy
+
+|===
+| Enabled by default | Safe | Supports autocorrection | VersionAdded | VersionChanged
+
+| Enabled
+| Yes
+| Yes
+| 0.2
+| -
+|===
+
+This cop enforces the test to use `assert(actual)`
+instead of using `assert_equal(true, actual)`.
+
+=== Examples
+
+[source,ruby]
+----
+# bad
+assert_equal(true, actual)
+assert_equal(true, actual, 'message')
+
+# good
+assert(actual)
+assert(actual, 'message')
+----
+
+=== References
+
+* https://minitest.rubystyle.guide#assert-truthy
+
+== Minitest/AssertWithExpectedArgument
+
+|===
+| Enabled by default | Safe | Supports autocorrection | VersionAdded | VersionChanged
+
+| Pending
+| Yes
+| No
+| 0.11
+| -
+|===
+
+This cop tries to detect when a user accidentally used
+`assert` when they meant to use `assert_equal`.
+
+=== Examples
+
+[source,ruby]
+----
+# bad
+assert(3, my_list.length)
+assert(expected, actual)
+
+# good
+assert_equal(3, my_list.length)
+assert_equal(expected, actual)
+assert(foo, 'message')
+----
+
+== Minitest/AssertionInLifecycleHook
+
+|===
+| Enabled by default | Safe | Supports autocorrection | VersionAdded | VersionChanged
+
+| Pending
+| Yes
+| No
+| 0.10
+| -
+|===
+
+This cop checks for usage of assertions in lifecycle hooks.
+
+=== Examples
+
+[source,ruby]
+----
+# bad
+class FooTest < Minitest::Test
+  def setup
+    assert_equal(foo, bar)
+  end
+end
+
+# good
+class FooTest < Minitest::Test
+  def test_something
+    assert_equal(foo, bar)
+  end
+end
+----
+
+== Minitest/GlobalExpectations
+
+|===
+| Enabled by default | Safe | Supports autocorrection | VersionAdded | VersionChanged
+
+| Enabled
+| Yes
+| Yes
+| 0.7
+| -
+|===
+
+This cop checks for deprecated global expectations
+and autocorrects them to use expect format.
+
+=== Examples
+
+[source,ruby]
+----
+# bad
+musts.must_equal expected_musts
+wonts.wont_match expected_wonts
+musts.must_raise TypeError
+
+# good
+_(musts).must_equal expected_musts
+_(wonts).wont_match expected_wonts
+_ { musts }.must_raise TypeError
+----
+
+=== References
+
+* https://minitest.rubystyle.guide#global-expectations
+
+== Minitest/LiteralAsActualArgument
+
+|===
+| Enabled by default | Safe | Supports autocorrection | VersionAdded | VersionChanged
+
+| Pending
+| Yes
+| Yes
+| 0.10
+| -
+|===
+
+This cop enforces correct order of expected and
+actual arguments for `assert_equal`.
+
+=== Examples
+
+[source,ruby]
+----
+# bad
+assert_equal foo, 2
+assert_equal foo, [1, 2]
+assert_equal foo, [1, 2], 'message'
+
+# good
+assert_equal 2, foo
+assert_equal [1, 2], foo
+assert_equal [1, 2], foo, 'message'
+----
+
+=== References
+
+* https://minitest.rubystyle.guide/#assert-equal-arguments-order
+
+== Minitest/MultipleAssertions
+
+|===
+| Enabled by default | Safe | Supports autocorrection | VersionAdded | VersionChanged
+
+| Pending
+| Yes
+| No
+| 0.10
+| -
+|===
+
+This cop checks if test cases contain too many assertion calls.
+The maximum allowed assertion calls is configurable.
+
+=== Examples
+
+==== Max: 1
+
+[source,ruby]
+----
+# bad
+class FooTest < Minitest::Test
+  def test_asserts_twice
+    assert_equal(42, do_something)
+    assert_empty(array)
+  end
+end
+
+# good
+class FooTest < Minitest::Test
+  def test_asserts_once
+    assert_equal(42, do_something)
+  end
+
+  def test_another_asserts_once
+    assert_empty(array)
+  end
+end
+----
+
+=== Configurable attributes
+
+|===
+| Name | Default value | Configurable values
+
+| Max
+| `3`
+| Integer
+|===
+
+== 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
+
+[source,ruby]
+----
+# bad
+refute(object.empty?)
+refute(object.empty?, 'message')
+
+# good
+refute_empty(object)
+refute_empty(object, 'message')
+----
+
+=== References
+
+* https://minitest.rubystyle.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(expected != actual)` or `assert(! expected == actual)`.
+
+=== Examples
+
+[source,ruby]
+----
+# bad
+assert("rubocop-minitest" != actual)
+assert(! "rubocop-minitest" == actual)
+
+# good
+refute_equal("rubocop-minitest", actual)
+----
+
+=== References
+
+* https://minitest.rubystyle.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
+
+[source,ruby]
+----
+# bad
+assert_equal(false, actual)
+assert_equal(false, actual, 'message')
+
+assert(!test)
+assert(!test, 'message')
+
+# good
+refute(actual)
+refute(actual, 'message')
+----
+
+=== References
+
+* https://minitest.rubystyle.guide#refute-false
+
+== Minitest/RefuteInDelta
+
+|===
+| Enabled by default | Safe | Supports autocorrection | VersionAdded | VersionChanged
+
+| Pending
+| Yes
+| Yes
+| 0.10
+| -
+|===
+
+This cop enforces the test to use `refute_in_delta`
+instead of using `refute_equal` to compare floats.
+
+=== Examples
+
+[source,ruby]
+----
+# bad
+refute_equal(0.2, actual)
+refute_equal(0.2, actual, 'message')
+
+# good
+refute_in_delta(0.2, actual)
+refute_in_delta(0.2, actual, 0.001, 'message')
+----
+
+=== References
+
+* https://minitest.rubystyle.guide/#refute-in-delta
+
+== 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
+
+[source,ruby]
+----
+# bad
+refute(collection.include?(object))
+refute(collection.include?(object), 'message')
+
+# good
+refute_includes(collection, object)
+refute_includes(collection, object, 'message')
+----
+
+=== References
+
+* https://minitest.rubystyle.guide#refute-includes
+
+== Minitest/RefuteInstanceOf
+
+|===
+| Enabled by default | Safe | Supports autocorrection | VersionAdded | VersionChanged
+
+| Enabled
+| Yes
+| Yes
+| 0.4
+| -
+|===
+
+This cop enforces the use of `refute_instance_of(Class, object)`
+over `refute(object.instance_of?(Class))`.
+
+=== Examples
+
+[source,ruby]
+----
+# bad
+refute(object.instance_of?(Class))
+refute(object.instance_of?(Class), 'message')
+
+# good
+refute_instance_of(Class, object)
+refute_instance_of(Class, object, 'message')
+----
+
+=== References
+
+* https://minitest.rubystyle.guide#refute-instance-of
+
+== Minitest/RefuteKindOf
+
+|===
+| Enabled by default | Safe | Supports autocorrection | VersionAdded | VersionChanged
+
+| Pending
+| Yes
+| Yes
+| 0.10
+| -
+|===
+
+This cop enforces the use of `refute_kind_of(Class, object)`
+over `refute(object.kind_of?(Class))`.
+
+=== Examples
+
+[source,ruby]
+----
+# bad
+refute(object.kind_of?(Class))
+refute(object.kind_of?(Class), 'message')
+
+# good
+refute_kind_of(Class, object)
+refute_kind_of(Class, object, 'message')
+----
+
+=== References
+
+* https://github.com/rubocop/minitest-style-guide#refute-kind-of
+
+== Minitest/RefuteMatch
+
+|===
+| Enabled by default | Safe | Supports autocorrection | VersionAdded | VersionChanged
+
+| Enabled
+| Yes
+| Yes
+| 0.6
+| -
+|===
+
+This cop enforces the test to use `refute_match`
+instead of using `refute(matcher.match(string))`.
+
+=== Examples
+
+[source,ruby]
+----
+# bad
+refute(matcher.match(string))
+refute(matcher.match(string), 'message')
+
+# good
+refute_match(matcher, string)
+refute_match(matcher, string, 'message')
+----
+
+=== References
+
+* https://minitest.rubystyle.guide#refute-match
+
+== Minitest/RefuteNil
+
+|===
+| Enabled by default | Safe | Supports autocorrection | VersionAdded | VersionChanged
+
+| Enabled
+| Yes
+| Yes
+| 0.2
+| -
+|===
+
+This cop enforces the test to use `refute_nil`
+instead of using `refute_equal(nil, something)`.
+
+=== Examples
+
+[source,ruby]
+----
+# bad
+refute_equal(nil, actual)
+refute_equal(nil, actual, 'message')
+
+# good
+refute_nil(actual)
+refute_nil(actual, 'message')
+----
+
+=== References
+
+* https://minitest.rubystyle.guide#refute-nil
+
+== Minitest/RefutePathExists
+
+|===
+| Enabled by default | Safe | Supports autocorrection | VersionAdded | VersionChanged
+
+| Pending
+| Yes
+| Yes
+| 0.10
+| -
+|===
+
+This cop enforces the test to use `refute_path_exists`
+instead of using `refute(File.exist?(path))`.
+
+=== Examples
+
+[source,ruby]
+----
+# bad
+refute(File.exist?(path))
+refute(File.exist?(path), 'message')
+
+# good
+refute_path_exists(path)
+refute_path_exists(path, 'message')
+----
+
+=== References
+
+* https://minitest.rubystyle.guide/#refute-path-exists
+
+== Minitest/RefuteRespondTo
+
+|===
+| Enabled by default | Safe | Supports autocorrection | VersionAdded | VersionChanged
+
+| Enabled
+| Yes
+| Yes
+| 0.4
+| -
+|===
+
+This cop enforces the test to use `refute_respond_to(object, :do_something)`
+over `refute(object.respond_to?(:do_something))`.
+
+=== Examples
+
+[source,ruby]
+----
+# bad
+refute(object.respond_to?(:do_something))
+refute(object.respond_to?(:do_something), 'message')
+refute(respond_to?(:do_something))
+
+# good
+refute_respond_to(object, :do_something)
+refute_respond_to(object, :do_something, 'message')
+refute_respond_to(self, :do_something)
+----
+
+=== References
+
+* https://minitest.rubystyle.guide#refute-respond-to
+
+== Minitest/TestMethodName
+
+|===
+| Enabled by default | Safe | Supports autocorrection | VersionAdded | VersionChanged
+
+| Pending
+| Yes
+| Yes
+| 0.10
+| -
+|===
+
+This cop enforces that test method names start with `test_` prefix.
+It aims to prevent tests that aren't executed by forgetting to start test method name with `test_`.
+
+=== Examples
+
+[source,ruby]
+----
+# bad
+class FooTest < Minitest::Test
+  def does_something
+    assert_equal 42, do_something
+  end
+end
+
+# good
+class FooTest < Minitest::Test
+  def test_does_something
+    assert_equal 42, do_something
+  end
+end
+
+# good
+class FooTest < Minitest::Test
+  def helper_method(argument)
+  end
+end
+----
+
+== Minitest/UnspecifiedException
+
+|===
+| Enabled by default | Safe | Supports autocorrection | VersionAdded | VersionChanged
+
+| Pending
+| Yes
+| No
+| 0.10
+| -
+|===
+
+This cop checks for a specified error in `assert_raises`.
+
+=== Examples
+
+[source,ruby]
+----
+# bad
+assert_raises { raise FooException }
+assert_raises('This should have raised') { raise FooException }
+
+# good
+assert_raises(FooException) { raise FooException }
+assert_raises(FooException, 'This should have raised') { raise FooException }
+----
+
+=== References
+
+* https://minitest.rubystyle.guide#unspecified-exception