rubocop-minitest 0.9.0 → 0.10.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: c082e4d082877168b339446bf00e74f719a3903d7ae2a19dc6b919af185c9c20
-  data.tar.gz: b77c805249d256213f7b166579244db96ce188e8dbe8ca7d156d14a4c74e77b5
+  metadata.gz: ba38b8b45ed71a06486486456dbda0e2d833f58ccf59fc7e22ecb3a1d4ec2dd7
+  data.tar.gz: 5f5260b7699852144213e044386662b3168eff83068ee88257df478fd79c7314
 SHA512:
-  metadata.gz: 348081b691b1afc2fc563d594482a8e19b3b5f487c18e4e51320e2be6c9e76fe89ea8c6badfcd4327f7c3da8a13b5aa8293e3535ce7385083edec466fedee769
-  data.tar.gz: 383422b5cc623d52cef4f0656da57e4b648d85c00699006d317837172dc06c97f182f660e15a7704cd5f13803e12af31912db41aed9f003223149b8cd64f5b51
+  metadata.gz: accc29f0bf8c2c80404a0777122446bea1ed7a6d57809b68b4ca21f66aedecdc161c3f29dd0777a61a2bccda158da3cb20892470994d335a4da63a2c09fbc80a
+  data.tar.gz: 8c3c5b4f73bd953c7ced000471c3e91645e36c240d7e73f04631487344c3a9e14152b2c83b3d6dccdf3530936007deb4e3dbc819c6b28e86a34ef5b821802375

data/.rubocop.yml

@@ -8,6 +8,7 @@ require:
   - rubocop-minitest
 
 AllCops:
+  NewCops: enable
   TargetRubyVersion: 2.4
 
 Naming/PredicateName:
@@ -47,9 +48,6 @@ Layout/ClassStructure:
       - protected_methods
       - private_methods
 
-Layout/LineLength:
-  Max: 120
-
 # Trailing white space is meaningful in code examples
 Layout/TrailingWhitespace:
   AllowInHeredoc: true

data/CHANGELOG.md

@@ -2,6 +2,26 @@
 
 ## master (unreleased)
 
+## 0.10.0 (2020-07-12)
+
+### New features
+
+* [#92](https://github.com/rubocop-hq/rubocop-minitest/pull/92): Add new `Minitest/LiteralAsActualArgument` cop. ([@fatkodima][], [@tsmmark][])
+* [#95](https://github.com/rubocop-hq/rubocop-minitest/pull/95): Add new `Minitest/AssertionInLifecycleHook` cop. ([@fatkodima][])
+* [#91](https://github.com/rubocop-hq/rubocop-minitest/pull/91): Add new `Minitest/AssertInDelta` and `Minitest/RefuteInDelta` cops. ([@fatkodima][])
+* [#89](https://github.com/rubocop-hq/rubocop-minitest/pull/89): Add new `Minitest/TestMethodName` cop. ([@fatkodima][])
+* [#83](https://github.com/rubocop-hq/rubocop-minitest/pull/83): New cops `AssertPathExists` and `RefutePathExists` check for use of `assert_path_exists`/`refute_path_exists` instead of `assert(File.exist?(path))`/`refute(File.exist?(path))`. ([@fatkodima][])
+* [#88](https://github.com/rubocop-hq/rubocop-minitest/pull/88): Add new `Minitest/MultipleAssertions` cop. ([@fatkodima][])
+* [#87](https://github.com/rubocop-hq/rubocop-minitest/pull/87): Add new `Minitest/AssertSilent` cop. ([@fatkodima][])
+* [#96](https://github.com/rubocop-hq/rubocop-minitest/pull/96): Add new `Minitest/UnspecifiedException` cop. ([@fatkodima][])
+* [#98](https://github.com/rubocop-hq/rubocop-minitest/pull/98): Add new `Minitest/AssertOutput` cop. ([@fatkodima][])
+* [#84](https://github.com/rubocop-hq/rubocop-minitest/pull/84): New cops `AssertKindOf` and `RefuteKindOf` check for use of `assert_kind_of`/`refute_kind_of` instead of `assert(foo.kind_of?(Class))`/`refute(foo.kind_of?(Class))`. ([@fatkodima][])
+* [#85](https://github.com/rubocop-hq/rubocop-minitest/pull/85): Add autocorrect to `Rails/AssertEmptyLiteral` cop. ([@fatkodima][])
+
+### Changes
+
+* [#104](https://github.com/rubocop-hq/rubocop-minitest/pull/104): Require RuboCop 0.87 or higher. ([@koic][])
+
 ## 0.9.0 (2020-04-13)
 
 ### Bug fixes
@@ -137,3 +157,5 @@
 [@herwinw]: https://github.com/herwinw
 [@fsateler]: https://github.com/fsateler
 [@andrykonchin]: https://github.com/andrykonchin
+[@fatkodima]: https://github.com/fatkodima
+[@tsmmark]: https://github.com/tsmmark

data/Gemfile

@@ -9,5 +9,5 @@ gemspec
 gem 'bump', require: false
 gem 'rake'
 gem 'rubocop', github: 'rubocop-hq/rubocop'
-gem 'rubocop-performance', '~> 1.5.0'
+gem 'rubocop-performance', '~> 1.6.0'
 gem 'yard', '~> 0.9'

data/README.md

@@ -62,7 +62,7 @@ end
 
 All cops are located under
 [`lib/rubocop/cop/minitest`](lib/rubocop/cop/minitest), and contain
-examples/documentation. The documentation is published [here](https://docs.rubocop.org/projects/minitest).
+examples/documentation. The documentation is published [here](https://docs.rubocop.org/rubocop-minitest/).
 
 In your `.rubocop.yml`, you may treat the Minitest cops just like any other
 cop. For example:
@@ -75,7 +75,7 @@ Minitest/AssertNil:
 
 ## Documentation
 
-You can read a lot more about RuboCop Minitest in its [official docs](https://docs.rubocop.org/projects/minitest/).
+You can read a lot more about RuboCop Minitest in its [official docs](https://docs.rubocop.org/rubocop-minitest/).
 
 ## Contributing
 

data/Rakefile

@@ -15,6 +15,7 @@ end
 
 require 'rubocop/rake_task'
 require 'rake/testtask'
+require_relative 'lib/rubocop/cop/generator'
 
 Rake::TestTask.new do |t|
   t.libs << 'test'
@@ -36,3 +37,31 @@ task default: %i[
   test
   internal_investigation
 ]
+
+desc 'Generate a new cop template'
+task :new_cop, [:cop] do |_task, args|
+  require 'rubocop'
+
+  cop_name = args.fetch(:cop) do
+    warn 'usage: bundle exec rake new_cop[Department/Name]'
+    exit!
+  end
+
+  github_user = `git config github.user`.chop
+  github_user = 'your_id' if github_user.empty?
+
+  generator = RuboCop::Cop::Generator.new(cop_name, github_user)
+
+  generator.write_source
+  generator.write_test
+  generator.inject_require(root_file_path: 'lib/rubocop/cop/minitest_cops.rb')
+  generator.inject_config(config_file_path: 'config/default.yml', version_added: bump_minor_version)
+
+  puts generator.todo
+end
+
+def bump_minor_version
+  major, minor, _patch = RuboCop::Minitest::VERSION.split('.')
+
+  "#{major}.#{minor.succ}"
+end

data/config/default.yml

@@ -6,106 +6,185 @@ 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.10'
 
 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-hq/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-hq/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/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-hq/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.10
+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,37 @@
+// 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#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,1014 @@
+= 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.10
+|===
+
+This cop enforces the test to use `assert_empty`
+instead of using `assert([], object)`.
+
+=== Examples
+
+[source,ruby]
+----
+# bad
+assert([], object)
+assert({}, 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-hq/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-hq/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/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_equal(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-hq/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.
+
+=== 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
+----
+
+== 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