rubocop-minitest 0.7.0 → 0.10.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 2fe4a7de0dfd13839c19db673fa07861a917a78e2558fae305131eeb852ccb89
-  data.tar.gz: 6c2c47e6ecf6260635e87d86cbda171d4716a581fef79786af619b97b76a8dc4
+  metadata.gz: 6b6cb0236ad583a81b4b3d12fdf4bf9d83cb53cfb565973fd54e5ae8a9dbd487
+  data.tar.gz: 6e41c1f11d6e20f29fbff140a71bf44c6e67db274b6cc30531220839e9c903b7
 SHA512:
-  metadata.gz: 9cf68be606a67b36392817fcf1436f5eb6b7c1b4bf1ea5c35516384dde2ff8a2a1b370bdbf900d3c58b96f0e4d0f5ae9c70084864ca08ef3fdbe0a8bf6a50a1d
-  data.tar.gz: 0f88de02da060b0b05c2ff6cb14d37989c1ca0d63b7c298809dda8fad8fb9271d41c98c816f90dff0282198a40096523c5a70151b7551fec0c4c6790a689bdfd
+  metadata.gz: 2ea2746f324798c678144e938f35e392dc9062d4ccdbd184726d0dd122ddd564c993db2ab20c7d45f989f542adca8e692e40f6d2edeef1201e7415ab2c78b625
+  data.tar.gz: 8448666265020b303754a109336f055402bdd375b020261a6d46f61d682c979e1e42edff409124bb9ee2cbc43744383f260c6b5908f55737c7b2fdefdf4856de

data/.circleci/config.yml

@@ -23,9 +23,6 @@ jobs:
 workflows:
   build:
     jobs:
-      - rake_default:
-          name: Ruby 2.3
-          image: circleci/ruby:2.3
       - rake_default:
           name: Ruby 2.4
           image: circleci/ruby:2.4

data/.rubocop.yml

@@ -8,7 +8,8 @@ require:
   - rubocop-minitest
 
 AllCops:
-  TargetRubyVersion: 2.3
+  NewCops: enable
+  TargetRubyVersion: 2.4
 
 Naming/PredicateName:
   # Method define macros for dynamically generated method.

data/.rubocop_todo.yml

@@ -14,10 +14,3 @@ Metrics/AbcSize:
 # Configuration parameters: CountComments, ExcludedMethods.
 Metrics/MethodLength:
   Max: 14
-
-# Offense count: 40
-# Cop supports --auto-correct.
-# Configuration parameters: AutoCorrect, AllowHeredoc, AllowURI, URISchemes, IgnoreCopDirectives, IgnoredPatterns.
-# URISchemes: http, https
-Layout/LineLength:
-  Max: 100

data/CHANGELOG.md

@@ -2,6 +2,61 @@
 
 ## master (unreleased)
 
+## 0.10.1 (2020-07-25)
+
+### Bug fixes
+
+* [#106](https://github.com/rubocop-hq/rubocop-minitest/issues/106): Fix an error for `Minitest/AssertOutput` when using gvar at top level. ([@koic][])
+
+## 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
+
+* [#75](https://github.com/rubocop-hq/rubocop-minitest/issues/75): Fix a false negative for `Minitest/GlobalExpectations` when using global expectation methods with no arguments. ([@koic][])
+
+### Changes
+
+* [#73](https://github.com/rubocop-hq/rubocop-minitest/issues/73): The Minitest department works on file names end with `_test.rb` by default. ([@koic][])
+* [#77](https://github.com/rubocop-hq/rubocop-minitest/pull/77): **(BREAKING)** Drop support for Ruby 2.3. ([@koic][])
+
+## 0.8.1 (2020-04-06)
+
+### Bug fixes
+
+* [#72](https://github.com/rubocop-hq/rubocop-minitest/pull/72): Fix some false negatives for `Minitest/GlobalExpectations`. ([@andrykonchin][])
+
+## 0.8.0 (2020-03-24)
+
+### New features
+
+* [#66](https://github.com/rubocop-hq/rubocop-minitest/issues/66): Support all expectations of `Minitest::Expectations` for `Minitest/GlobalExpectations` cop. ([@koic][])
+
+### Bug fixes
+
+* [#60](https://github.com/rubocop-hq/rubocop-minitest/issues/60): Fix `Minitest/GlobalExpectations` autocorrection for chained methods. ([@tejasbubane][])
+* [#69](https://github.com/rubocop-hq/rubocop-minitest/pull/69): Fix a false negative for `Minitest/GlobalExpectations` cop when using a variable or a hash index for receiver. ([@koic][])
+* [#71](https://github.com/rubocop-hq/rubocop-minitest/pull/71): Fix a false negative for `Minitest/AssertEqual` when an argument is enclosed in redundant parentheses. ([@koic][])
+
 ## 0.7.0 (2020-03-09)
 
 ### New features
@@ -107,3 +162,6 @@
 [@abhaynikam]: https://github.com/abhaynikam
 [@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

@@ -2,109 +2,189 @@ Minitest:
   Enabled: true
   Include:
     - '**/test/**/*'
+    - '**/*_test.rb'
 
 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