= Minitest

== Minitest/AssertEmpty

|===
| Enabled by default | Safe | Supports autocorrection | Version Added | Version Changed

| 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 | Version Added | Version Changed

| Enabled
| Yes
| Yes
| 0.5
| 0.11
|===

This cop enforces the test to use `assert_empty`
instead of using `assert_equal([], object)` or `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 | Version Added | Version Changed

| 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 | Version Added | Version Changed

| 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 | Version Added | Version Changed

| 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 | Version Added | Version Changed

| 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 | Version Added | Version Changed

| 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 | Version Added | Version Changed

| 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 | Version Added | Version Changed

| Enabled
| Yes
| Yes
| 0.1
| -
|===

This cop enforces the test to use `assert_nil` instead of using
`assert_equal(nil, something)`, `assert(something.nil?)`, or `assert_predicate(something, :nil?)`.

=== Examples

[source,ruby]
----
# bad
assert_equal(nil, actual)
assert_equal(nil, actual, 'message')
assert(object.nil?)
assert(object.nil?, 'message')
assert_predicate(object, :nil?)
assert_predicate(object, :nil?, 'message')

# good
assert_nil(actual)
assert_nil(actual, 'message')
----

=== References

* https://minitest.rubystyle.guide#assert-nil

== Minitest/AssertOutput

|===
| Enabled by default | Safe | Supports autocorrection | Version Added | Version Changed

| 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 | Version Added | Version Changed

| 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/AssertPredicate

|===
| Enabled by default | Safe | Supports autocorrection | Version Added | Version Changed

| Pending
| Yes
| Yes
| 0.18
| -
|===

This cop enforces the test to use `assert_predicate`
instead of using `assert(obj.a_predicate_method?)`.

=== Examples

[source,ruby]
----
# bad
assert(obj.one?)
assert(obj.one?, 'message')

# good
assert_predicate(obj, :one?)
assert_predicate(obj, :one?, 'message')
----

=== References

* https://minitest.rubystyle.guide/#assert-predicate

== Minitest/AssertRespondTo

|===
| Enabled by default | Safe | Supports autocorrection | Version Added | Version Changed

| 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 | Version Added | Version Changed

| 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 | Version Added | Version Changed

| 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 | Version Added | Version Changed

| Pending
| No
| No
| 0.11
| -
|===

This cop tries to detect when a user accidentally used
`assert` when they meant to use `assert_equal`.

=== Safety

This cop is unsafe because it is not possible to determine
whether the second argument of `assert` is a message or not.

=== 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 | Version Added | Version Changed

| 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 | Version Added | Version Changed

| Enabled
| Yes
| Yes
| 0.7
| 0.16
|===

This cop checks for deprecated global expectations
and autocorrects them to use expect format.

=== Examples

==== EnforcedStyle: _

[source,ruby]
----
# bad
musts.must_equal expected_musts
wonts.wont_match expected_wonts
musts.must_raise TypeError

expect(musts).must_equal expected_musts
expect(wonts).wont_match expected_wonts
expect { musts }.must_raise TypeError

value(musts).must_equal expected_musts
value(wonts).wont_match expected_wonts
value { musts }.must_raise TypeError

# good
_(musts).must_equal expected_musts
_(wonts).wont_match expected_wonts
_ { musts }.must_raise TypeError
----

==== EnforcedStyle: any (default)

[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

expect(musts).must_equal expected_musts
expect(wonts).wont_match expected_wonts
expect { musts }.must_raise TypeError

value(musts).must_equal expected_musts
value(wonts).wont_match expected_wonts
value { musts }.must_raise TypeError
----

==== EnforcedStyle: expect

[source,ruby]
----
# bad
musts.must_equal expected_musts
wonts.wont_match expected_wonts
musts.must_raise TypeError

_(musts).must_equal expected_musts
_(wonts).wont_match expected_wonts
_ { musts }.must_raise TypeError

value(musts).must_equal expected_musts
value(wonts).wont_match expected_wonts
value { musts }.must_raise TypeError

# good
expect(musts).must_equal expected_musts
expect(wonts).wont_match expected_wonts
expect { musts }.must_raise TypeError
----

==== EnforcedStyle: value

[source,ruby]
----
# bad
musts.must_equal expected_musts
wonts.wont_match expected_wonts
musts.must_raise TypeError

_(musts).must_equal expected_musts
_(wonts).wont_match expected_wonts
_ { musts }.must_raise TypeError

expect(musts).must_equal expected_musts
expect(wonts).wont_match expected_wonts
expect { musts }.must_raise TypeError

# good
value(musts).must_equal expected_musts
value(wonts).wont_match expected_wonts
value { musts }.must_raise TypeError
----

=== Configurable attributes

|===
| Name | Default value | Configurable values

| EnforcedStyle
| `any`
| `_`, `any`, `expect`, `value`

| Include
| `+**/test/**/*+`, `+**/*_test.rb+`, `+**/spec/**/*+`, `+**/*_spec.rb+`
| Array
|===

=== References

* https://minitest.rubystyle.guide#global-expectations

== Minitest/LiteralAsActualArgument

|===
| Enabled by default | Safe | Supports autocorrection | Version Added | Version Changed

| 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 | Version Added | Version Changed

| 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/NoAssertions

|===
| Enabled by default | Safe | Supports autocorrection | Version Added | Version Changed

| Disabled
| Yes
| No
| 0.12
| -
|===

This cop checks if test cases contain any assertion calls.

=== Examples

[source,ruby]
----
# bad
class FooTest < Minitest::Test
  def test_the_truth
  end
end

# good
class FooTest < Minitest::Test
  def test_the_truth
    assert true
  end
end
----

== Minitest/RefuteEmpty

|===
| Enabled by default | Safe | Supports autocorrection | Version Added | Version Changed

| 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 | Version Added | Version Changed

| 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 | Version Added | Version Changed

| 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 | Version Added | Version Changed

| 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 | Version Added | Version Changed

| 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 | Version Added | Version Changed

| 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 | Version Added | Version Changed

| 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 | Version Added | Version Changed

| 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 | Version Added | Version Changed

| Enabled
| Yes
| Yes
| 0.2
| -
|===

This cop enforces the test to use `refute_nil` instead of using
`refute_equal(nil, something)`, `refute(something.nil?)`, or `refute_predicate(something, :nil?)`.

=== Examples

[source,ruby]
----
# bad
refute_equal(nil, actual)
refute_equal(nil, actual, 'message')
refute(actual.nil?)
refute(actual.nil?, 'message')
refute_predicate(object, :nil?)
refute_predicate(object, :nil?, 'message')

# good
refute_nil(actual)
refute_nil(actual, 'message')
----

=== References

* https://minitest.rubystyle.guide#refute-nil

== Minitest/RefutePathExists

|===
| Enabled by default | Safe | Supports autocorrection | Version Added | Version Changed

| 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/RefutePredicate

|===
| Enabled by default | Safe | Supports autocorrection | Version Added | Version Changed

| Pending
| Yes
| Yes
| 0.18
| -
|===

This cop enforces the test to use `refute_predicate`
instead of using `refute(obj.a_predicate_method?)`.

=== Examples

[source,ruby]
----
# bad
refute(obj.one?)
refute(obj.one?, 'message')

# good
refute_predicate(obj, :one?)
refute_predicate(obj, :one?, 'message')
----

=== References

* https://minitest.rubystyle.guide/#refute-predicate

== Minitest/RefuteRespondTo

|===
| Enabled by default | Safe | Supports autocorrection | Version Added | Version Changed

| 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 | Version Added | Version Changed

| 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/UnreachableAssertion

|===
| Enabled by default | Safe | Supports autocorrection | Version Added | Version Changed

| Pending
| Yes
| No
| 0.14
| -
|===

This cop checks for `assert_raises` has an assertion method at
the bottom of block because the assertion will be never reached.

=== Examples

[source,ruby]
----
# bad
assert_raises FooError do
  obj.occur_error
  assert_equal('foo', obj.bar) # Never asserted.
end

# good
assert_raises FooError do
  obj.occur_error
end
assert_equal('foo', obj.bar)
----

== Minitest/UnspecifiedException

|===
| Enabled by default | Safe | Supports autocorrection | Version Added | Version Changed

| 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