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

# bad
assert(object.empty?)
assert(object.empty?, 'message')

# good
assert_empty(object)
assert_empty(object, 'message')

References

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

# 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

# bad
assert("rubocop-minitest" == actual)

# good
assert_equal("rubocop-minitest", actual)

References

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

# 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

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

# bad
assert(collection.include?(object))
assert(collection.include?(object), 'message')

# good
assert_includes(collection, object)
assert_includes(collection, object, 'message')

References

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

# 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

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

# 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

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

# bad
assert(matcher.match(string))
assert(matcher.match(string), 'message')

# good
assert_match(regex, string)
assert_match(matcher, string, 'message')

References

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

# 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

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

# bad
$stdout = StringIO.new
puts object.method
$stdout.rewind
assert_match expected, $stdout.read

# good
assert_output(expected) { puts object.method }

References

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

# bad
assert(File.exist?(path))
assert(File.exist?(path), 'message')

# good
assert_path_exists(path)
assert_path_exists(path, 'message')

References

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

# bad
assert(obj.one?)
assert(obj.one?, 'message')

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

References

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

# 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

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

# bad
assert_output('', '') { puts object.do_something }

# good
assert_silent { puts object.do_something }

References

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

# bad
assert_equal(true, actual)
assert_equal(true, actual, 'message')

# good
assert(actual)
assert(actual, 'message')

References

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

# 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

# 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: _

# 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)

# 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

# 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

# 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

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

# 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

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

# 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

# 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

# bad
refute(object.empty?)
refute(object.empty?, 'message')

# good
refute_empty(object)
refute_empty(object, 'message')

References

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

# bad
assert("rubocop-minitest" != actual)
assert(! "rubocop-minitest" == actual)

# good
refute_equal("rubocop-minitest", actual)

References

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

# bad
assert_equal(false, actual)
assert_equal(false, actual, 'message')

assert(!test)
assert(!test, 'message')

# good
refute(actual)
refute(actual, 'message')

References

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

# 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

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

# bad
refute(collection.include?(object))
refute(collection.include?(object), 'message')

# good
refute_includes(collection, object)
refute_includes(collection, object, 'message')

References

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

# 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

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

# 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

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

# bad
refute(matcher.match(string))
refute(matcher.match(string), 'message')

# good
refute_match(matcher, string)
refute_match(matcher, string, 'message')

References

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

# 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

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

# bad
refute(File.exist?(path))
refute(File.exist?(path), 'message')

# good
refute_path_exists(path)
refute_path_exists(path, 'message')

References

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

# bad
refute(obj.one?)
refute(obj.one?, 'message')

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

References

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

# 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

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

# 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

# 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

# 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