= 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/DuplicateTestRun

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

| Pending
| Yes
| No
| 0.19
| -
|===

If a Minitest class inherits from another class,
it will also inherit its methods causing Minitest to run the parent's tests methods twice.

This cop detects when there are two tests classes, one inherits from the other, and both have tests methods.
This cop will add an offence to the Child class in such a case.

=== Examples

[source,ruby]
----
# bad
class ParentTest < Minitest::Test
  def test_parent # it will run this test twice.
  end
end

class ChildTest < ParentTest
  def test_child
  end
end

# good
class ParentTest < Minitest::Test
  def test_parent
  end
end

class ChildTest < Minitest::Test
  def test_child
  end
end

# good
class ParentTest < Minitest::Test
end

class ChildTest
  def test_child
  end

  def test_parent
  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