Enabled by default | Safe | Supports autocorrection | Version Added | Version Changed |
---|---|---|---|---|
Enabled |
Yes |
Yes |
0.2 |
- |
Enforces the test to use assert_empty
instead of using assert(object.empty?)
.
# bad
assert(object.empty?)
assert(object.empty?, 'message')
# good
assert_empty(object)
assert_empty(object, 'message')
Enabled by default | Safe | Supports autocorrection | Version Added | Version Changed |
---|---|---|---|---|
Enabled |
Yes |
Yes |
0.5 |
0.11 |
Enforces the test to use assert_empty
instead of using assert_equal([], object)
or assert_equal({}, object)
.
Enabled by default | Safe | Supports autocorrection | Version Added | Version Changed |
---|---|---|---|---|
Enabled |
Yes |
Yes |
0.4 |
- |
Enforces the use of assert_equal(expected, actual)
over assert(expected == actual)
.
# bad
assert("rubocop-minitest" == actual)
assert_operator("rubocop-minitest", :==, actual)
# good
assert_equal("rubocop-minitest", actual)
Enabled by default | Safe | Supports autocorrection | Version Added | Version Changed |
---|---|---|---|---|
Pending |
Yes |
Yes |
0.10 |
- |
Enforces the test to use assert_in_delta
instead of using assert_equal
to compare floats.
# 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')
Enabled by default | Safe | Supports autocorrection | Version Added | Version Changed |
---|---|---|---|---|
Enabled |
Yes |
Yes |
0.2 |
- |
Enforces the test to use assert_includes
instead of using assert(collection.include?(object))
.
# bad
assert(collection.include?(object))
assert(collection.include?(object), 'message')
# good
assert_includes(collection, object)
assert_includes(collection, object, 'message')
Enabled by default | Safe | Supports autocorrection | Version Added | Version Changed |
---|---|---|---|---|
Enabled |
Yes |
Yes |
0.4 |
- |
Enforces the test to use assert_instance_of(Class, object)
over assert(object.instance_of?(Class))
.
# bad
assert(object.instance_of?(Class))
assert(object.instance_of?(Class), 'message')
# bad
assert_equal(Class, object.class)
assert_equal(Class, object.class, 'message')
# good
assert_instance_of(Class, object)
assert_instance_of(Class, object, 'message')
Enabled by default | Safe | Supports autocorrection | Version Added | Version Changed |
---|---|---|---|---|
Pending |
Yes |
Yes |
0.10 |
- |
Enforces the test to use assert_kind_of(Class, object)
over assert(object.kind_of?(Class))
.
# bad
assert(object.kind_of?(Class))
assert(object.kind_of?(Class), 'message')
# good
assert_kind_of(Class, object)
assert_kind_of(Class, object, 'message')
Enabled by default | Safe | Supports autocorrection | Version Added | Version Changed |
---|---|---|---|---|
Enabled |
Yes |
Yes |
0.6 |
- |
Enforces the test to use assert_match
instead of using assert(matcher.match(string))
.
# bad
assert(matcher.match(string))
assert(matcher.match?(string))
assert(matcher =~ string)
assert_operator(matcher, :=~, string)
assert(matcher.match(string), 'message')
# good
assert_match(regex, string)
assert_match(matcher, string, 'message')
Enabled by default | Safe | Supports autocorrection | Version Added | Version Changed |
---|---|---|---|---|
Enabled |
Yes |
Yes |
0.1 |
- |
Enforces the test to use assert_nil
instead of using
assert_equal(nil, something)
, assert(something.nil?)
, or assert_predicate(something, :nil?)
.
# 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')
Enabled by default | Safe | Supports autocorrection | Version Added | Version Changed |
---|---|---|---|---|
Pending |
Yes |
Yes |
0.32 |
- |
Enforces the use of assert_operator(expected, :<, actual)
over assert(expected < actual)
.
Enabled by default | Safe | Supports autocorrection | Version Added | Version Changed |
---|---|---|---|---|
Pending |
Yes |
No |
0.10 |
- |
Checks for opportunities to use assert_output
.
# bad
$stdout = StringIO.new
puts object.method
$stdout.rewind
assert_match expected, $stdout.read
# good
assert_output(expected) { puts object.method }
Enabled by default | Safe | Supports autocorrection | Version Added | Version Changed |
---|---|---|---|---|
Pending |
Yes |
Yes |
0.10 |
- |
Enforces the test to use assert_path_exists
instead of using assert(File.exist?(path))
.
# bad
assert(File.exist?(path))
assert(File.exist?(path), 'message')
# good
assert_path_exists(path)
assert_path_exists(path, 'message')
Enabled by default | Safe | Supports autocorrection | Version Added | Version Changed |
---|---|---|---|---|
Pending |
Yes |
Yes |
0.18 |
- |
Enforces the test to use assert_predicate
instead of using assert(obj.a_predicate_method?)
.
# bad
assert(obj.one?)
assert(obj.one?, 'message')
# good
assert_predicate(obj, :one?)
assert_predicate(obj, :one?, 'message')
Enabled by default | Safe | Supports autocorrection | Version Added | Version Changed |
---|---|---|---|---|
Pending |
Yes |
No |
0.21 |
- |
Enforces the block body of assert_raises { … }
to be reduced to only the raising code.
Enabled by default | Safe | Supports autocorrection | Version Added | Version Changed |
---|---|---|---|---|
Pending |
Yes |
No |
0.22 |
0.26 |
Checks for assert_raises
with arguments of regular expression literals.
Arguments should be exception classes.
Optionally the last argument can be a custom message string to help explain failures.
Either way, it’s not the argument that exception.message
is compared to.
The raised exception is returned and can be used
to match against a regular expression.
# bad
assert_raises FooError, /some message/ do
obj.occur_error
end
# good
exception = assert_raises FooError do
obj.occur_error
end
assert_match(/some message/, exception.message)
Enabled by default | Safe | Supports autocorrection | Version Added | Version Changed |
---|---|---|---|---|
Enabled |
Yes |
Yes |
0.3 |
- |
Enforces the use of assert_respond_to(object, :do_something)
over assert(object.respond_to?(:do_something))
.
# 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)
Enabled by default | Safe | Supports autocorrection | Version Added | Version Changed |
---|---|---|---|---|
Pending |
Yes |
Yes |
0.26 |
- |
Enforces the use of assert_same(expected, actual)
over assert(expected.equal?(actual))
.
Note
|
Use assert_same only when there is a need to compare by identity.
Otherwise, use assert_equal .
|
Enabled by default | Safe | Supports autocorrection | Version Added | Version Changed |
---|---|---|---|---|
Pending |
Yes |
Yes |
0.10 |
- |
Enforces the test to use assert_silent { … }
instead of using assert_output('', '') { … }
.
# bad
assert_output('', '') { puts object.do_something }
# good
assert_silent { puts object.do_something }
Enabled by default | Safe | Supports autocorrection | Version Added | Version Changed |
---|---|---|---|---|
Enabled |
No |
Yes (Unsafe) |
0.2 |
0.27 |
Enforces the test to use assert(actual)
instead of using assert_equal(true, actual)
.
This cop is unsafe because true might be expected instead of truthy. False positives cannot be prevented when this is a variable or method return value.
assert_equal(true, 'truthy') # failure
assert('truthy') # success
# bad
assert_equal(true, actual)
assert_equal(true, actual, 'message')
# good
assert(actual)
assert(actual, 'message')
Enabled by default | Safe | Supports autocorrection | Version Added | Version Changed |
---|---|---|---|---|
Pending |
No |
No |
0.11 |
0.26 |
Tries to detect when a user accidentally used
assert
when they meant to use assert_equal
.
Note
|
The second argument to the assert method named message and msg is allowed.
Because their names are inferred as message arguments.
|
This cop is unsafe because it is not possible to determine
whether the second argument of assert
is a message or not.
# bad
assert(3, my_list.length)
assert(expected, actual)
# good
assert_equal(3, my_list.length)
assert_equal(expected, actual)
assert(foo, 'message')
assert(foo, message)
assert(foo, msg)
Enabled by default | Safe | Supports autocorrection | Version Added | Version Changed |
---|---|---|---|---|
Pending |
Yes |
No |
0.10 |
- |
Checks for usage of assertions in lifecycle hooks.
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 offense to the Child class in such a case.
# 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
Enabled by default | Safe | Supports autocorrection | Version Added | Version Changed |
---|---|---|---|---|
Enabled |
Yes |
Yes |
0.7 |
0.26 |
Checks for deprecated global expectations and autocorrects them to use expect format.
# 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
# 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
# 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
# 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
Name | Default value | Configurable values |
---|---|---|
Severity |
|
String |
EnforcedStyle |
|
|
Include |
|
Array |
Enabled by default | Safe | Supports autocorrection | Version Added | Version Changed |
---|---|---|---|---|
Pending |
Yes |
Yes |
0.28 |
- |
Checks that lifecycle hooks are declared in the order in which they will be executed.
# bad
class FooTest < Minitest::Test
def teardown; end
def setup; end
end
# good
class FooTest < Minitest::Test
def setup; end
def teardown; end
end
# bad (after test cases)
class FooTest < Minitest::Test
def test_something
assert foo
end
def setup; end
def teardown; end
end
# good
class FooTest < Minitest::Test
def setup; end
def teardown; end
def test_something
assert foo
end
end
# good (after non test case methods)
class FooTest < Minitest::Test
def do_something; end
def setup; end
def teardown; end
end
Enabled by default | Safe | Supports autocorrection | Version Added | Version Changed |
---|---|---|---|---|
Pending |
Yes |
Yes |
0.10 |
- |
Enforces correct order of expected and
actual arguments for assert_equal
.
# 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'
Enabled by default | Safe | Supports autocorrection | Version Added | Version Changed |
---|---|---|---|---|
Pending |
Yes |
No |
0.10 |
- |
Checks if test cases contain too many assertion calls. If conditional code with assertions is used, the branch with maximum assertions is counted. The maximum allowed assertion calls is configurable.
Enabled by default | Safe | Supports autocorrection | Version Added | Version Changed |
---|---|---|---|---|
Disabled |
Yes |
No |
0.12 |
- |
Checks if test cases contain any assertion calls.
Enabled by default | Safe | Supports autocorrection | Version Added | Version Changed |
---|---|---|---|---|
Pending |
Yes |
No |
0.27 |
- |
Detects non public
(marked as private
or protected
) test methods.
Minitest runs only test methods which are public
.
# bad
class FooTest
private # or protected
def test_does_something
assert_equal 42, do_something
end
end
# good
class FooTest
def test_does_something
assert_equal 42, do_something
end
end
# good (not a test case name)
class FooTest
private # or protected
def does_something
assert_equal 42, do_something
end
end
# good (no assertions)
class FooTest
private # or protected
def test_does_something
do_something
end
end
Enabled by default | Safe | Supports autocorrection | Version Added | Version Changed |
---|---|---|---|---|
Enabled |
Yes |
Yes |
0.3 |
- |
Enforces to use refute_empty
instead of using refute(object.empty?)
.
# bad
refute(object.empty?)
refute(object.empty?, 'message')
# good
refute_empty(object)
refute_empty(object, 'message')
Enabled by default | Safe | Supports autocorrection | Version Added | Version Changed |
---|---|---|---|---|
Enabled |
Yes |
Yes |
0.3 |
- |
Enforces the use of refute_equal(expected, object)
over assert(expected != actual)
or assert(! expected == actual)
.
# bad
assert("rubocop-minitest" != actual)
refute("rubocop-minitest" == actual)
assert_operator("rubocop-minitest", :!=, actual)
refute_operator("rubocop-minitest", :==, actual)
# good
refute_equal("rubocop-minitest", actual)
Enabled by default | Safe | Supports autocorrection | Version Added | Version Changed |
---|---|---|---|---|
Enabled |
No |
Yes (Unsafe) |
0.3 |
0.27 |
Enforces the use of refute(object)
over assert_equal(false, object)
.
This cop is unsafe because it cannot detect failure when second argument is nil
.
False positives cannot be prevented when this is a variable or method return value.
assert_equal(false, nil) # failure
refute(nil) # success
# bad
assert_equal(false, actual)
assert_equal(false, actual, 'message')
assert(!test)
assert(!test, 'message')
# good
refute(actual)
refute(actual, 'message')
Enabled by default | Safe | Supports autocorrection | Version Added | Version Changed |
---|---|---|---|---|
Pending |
Yes |
Yes |
0.10 |
- |
Enforces the test to use refute_in_delta
instead of using refute_equal
to compare floats.
# 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')
Enabled by default | Safe | Supports autocorrection | Version Added | Version Changed |
---|---|---|---|---|
Enabled |
Yes |
Yes |
0.3 |
- |
Enforces the test to use refute_includes
instead of using refute(collection.include?(object))
.
# bad
refute(collection.include?(object))
refute(collection.include?(object), 'message')
# good
refute_includes(collection, object)
refute_includes(collection, object, 'message')
Enabled by default | Safe | Supports autocorrection | Version Added | Version Changed |
---|---|---|---|---|
Enabled |
Yes |
Yes |
0.4 |
- |
Enforces the use of refute_instance_of(Class, object)
over refute(object.instance_of?(Class))
.
# bad
refute(object.instance_of?(Class))
refute(object.instance_of?(Class), 'message')
# bad
refute_equal(Class, object.class)
refute_equal(Class, object.class, 'message')
# good
refute_instance_of(Class, object)
refute_instance_of(Class, object, 'message')
Enabled by default | Safe | Supports autocorrection | Version Added | Version Changed |
---|---|---|---|---|
Pending |
Yes |
Yes |
0.10 |
- |
Enforces the use of refute_kind_of(Class, object)
over refute(object.kind_of?(Class))
.
# bad
refute(object.kind_of?(Class))
refute(object.kind_of?(Class), 'message')
# good
refute_kind_of(Class, object)
refute_kind_of(Class, object, 'message')
Enabled by default | Safe | Supports autocorrection | Version Added | Version Changed |
---|---|---|---|---|
Enabled |
Yes |
Yes |
0.6 |
- |
Enforces the test to use refute_match
instead of using refute(matcher.match(string))
.
# bad
refute(matcher.match(string))
refute(matcher.match?(string))
refute(matcher =~ string)
refute_operator(matcher, :=~, string)
assert_operator(matcher, :!~, string)
refute(matcher.match(string), 'message')
# good
refute_match(matcher, string)
refute_match(matcher, string, 'message')
Enabled by default | Safe | Supports autocorrection | Version Added | Version Changed |
---|---|---|---|---|
Enabled |
Yes |
Yes |
0.2 |
- |
Enforces the test to use refute_nil
instead of using
refute_equal(nil, something)
, refute(something.nil?)
, or refute_predicate(something, :nil?)
.
# 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')
Enabled by default | Safe | Supports autocorrection | Version Added | Version Changed |
---|---|---|---|---|
Pending |
Yes |
Yes |
0.32 |
- |
Enforces the use of refute_operator(expected, :<, actual)
over refute(expected < actual)
.
Enabled by default | Safe | Supports autocorrection | Version Added | Version Changed |
---|---|---|---|---|
Pending |
Yes |
Yes |
0.10 |
- |
Enforces the test to use refute_path_exists
instead of using refute(File.exist?(path))
.
# bad
refute(File.exist?(path))
refute(File.exist?(path), 'message')
# good
refute_path_exists(path)
refute_path_exists(path, 'message')
Enabled by default | Safe | Supports autocorrection | Version Added | Version Changed |
---|---|---|---|---|
Pending |
Yes |
Yes |
0.18 |
- |
Enforces the test to use refute_predicate
instead of using refute(obj.a_predicate_method?)
.
# bad
refute(obj.one?)
refute(obj.one?, 'message')
# good
refute_predicate(obj, :one?)
refute_predicate(obj, :one?, 'message')
Enabled by default | Safe | Supports autocorrection | Version Added | Version Changed |
---|---|---|---|---|
Enabled |
Yes |
Yes |
0.4 |
- |
Enforces the test to use refute_respond_to(object, :do_something)
over refute(object.respond_to?(:do_something))
.
# 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)
Enabled by default | Safe | Supports autocorrection | Version Added | Version Changed |
---|---|---|---|---|
Pending |
Yes |
Yes |
0.26 |
- |
Enforces the use of refute_same(expected, object)
over refute(expected.equal?(actual))
.
Note
|
Use refute_same only when there is a need to compare by identity.
Otherwise, use refute_equal .
|
Enabled by default | Safe | Supports autocorrection | Version Added | Version Changed |
---|---|---|---|---|
Pending |
Yes |
Yes |
0.31 |
- |
Enforces the use of skip
instead of return
in test methods.
# bad
def test_something
return if condition?
assert_equal(42, something)
end
# good
def test_something
skip if condition?
assert_equal(42, something)
end
Enabled by default | Safe | Supports autocorrection | Version Added | Version Changed |
---|---|---|---|---|
Pending |
Yes |
No |
0.20 |
0.26 |
Checks that ensure
call even if skip
. It is unexpected that ensure
will be called when skipping test.
If conditional skip
is used, it checks that ensure
is also called conditionally.
On the other hand, it accepts skip
used in rescue
because ensure
may be teardown process to begin
setup process.
# bad
def test_skip
skip 'This test is skipped.'
assert 'foo'.present?
ensure
do_something
end
# bad
def test_conditional_skip
skip 'This test is skipped.' if condition
assert do_something
ensure
do_teardown
end
# good
def test_skip
skip 'This test is skipped.'
begin
assert 'foo'.present?
ensure
do_something
end
end
# good
def test_conditional_skip
skip 'This test is skipped.' if condition
assert do_something
ensure
if condition
do_teardown
end
end
# good
def test_skip_is_used_in_rescue
do_setup
assert do_something
rescue
skip 'This test is skipped.'
ensure
do_teardown
end
Enabled by default | Safe | Supports autocorrection | Version Added | Version Changed |
---|---|---|---|---|
Pending |
Yes |
No |
0.26 |
- |
Checks if test file names start with test_
or end with _test.rb
.
Files which define classes having names ending with Test
are checked.
Not following this convention may result in tests not being run.
Enabled by default | Safe | Supports autocorrection | Version Added | Version Changed |
---|---|---|---|---|
Pending |
Yes |
Yes |
0.10 |
- |
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_
.
Enabled by default | Safe | Supports autocorrection | Version Added | Version Changed |
---|---|---|---|---|
Pending |
Yes |
No |
0.14 |
0.26 |
Checks for assert_raises
has an assertion method at
the bottom of block because the assertion will be never reached.
# 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)
Enabled by default | Safe | Supports autocorrection | Version Added | Version Changed |
---|---|---|---|---|
Pending |
Yes |
No |
0.10 |
- |
Checks for a specified error in assert_raises
.
# 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 }
Enabled by default | Safe | Supports autocorrection | Version Added | Version Changed |
---|---|---|---|---|
Pending |
Yes |
No |
0.26 |
- |
Detects useless assertions (assertions that either always pass or always fail).