Skip to content

Add deprecated unittest assertions to PT009 #6572

New issue

Have a question about this project? Sign up for a free GitHub account to open an issue and contact its maintainers and the community.

Sign up for GitHub

By clicking “Sign up for GitHub”, you agree to our terms of service and privacy statement. We’ll occasionally send you account related emails.

Already on GitHub? Sign in to your account

Merged
charliermarsh merged 1 commit into from
Aug 14, 2023
Merged

Add deprecated unittest assertions to PT009 #6572

Show file tree
Hide file tree
Changes from all commits
Commits
Show all changes
1 commit
Select commit
File filter

Filter by extension

Filter by extension
Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
12 changes: 12 additions & 0 deletions crates/ruff/resources/test/fixtures/flake8_pytest_style/PT009.py
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -80,3 +80,15 @@ def test_assert_regexp_matches(self):

def test_assert_not_regexp_matches(self):
self.assertNotRegex("abc", r"abc") # Error

def test_fail_if(self):
self.failIf("abc") # Error

def test_fail_unless(self):
self.failUnless("abc") # Error

def test_fail_unless_equal(self):
self.failUnlessEqual(1, 2) # Error

def test_fail_if_equal(self):
self.failIfEqual(1, 2) # Error
68 changes: 52 additions & 16 deletions crates/ruff/src/rules/flake8_pytest_style/rules/unittest_assert.rs
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -19,6 +19,13 @@ pub(crate) enum UnittestAssert {
DictEqual,
Equal,
Equals,
FailIf,
FailIfAlmostEqual,
FailIfEqual,
FailUnless,
FailUnlessAlmostEqual,
FailUnlessEqual,
// FailUnlessRaises,
False,
Greater,
GreaterEqual,
Expand Down Expand Up @@ -62,10 +69,16 @@ impl std::fmt::Display for UnittestAssert {
UnittestAssert::AlmostEqual => write!(f, "assertAlmostEqual"),
UnittestAssert::AlmostEquals => write!(f, "assertAlmostEquals"),
UnittestAssert::CountEqual => write!(f, "assertCountEqual"),
UnittestAssert::DictEqual => write!(f, "assertDictEqual"),
UnittestAssert::DictContainsSubset => write!(f, "assertDictContainsSubset"),
UnittestAssert::DictEqual => write!(f, "assertDictEqual"),
UnittestAssert::Equal => write!(f, "assertEqual"),
UnittestAssert::Equals => write!(f, "assertEquals"),
UnittestAssert::FailIf => write!(f, "failIf"),
UnittestAssert::FailIfAlmostEqual => write!(f, "failIfAlmostEqual"),
UnittestAssert::FailIfEqual => write!(f, "failIfEqual"),
UnittestAssert::FailUnless => write!(f, "failUnless"),
UnittestAssert::FailUnlessAlmostEqual => write!(f, "failUnlessAlmostEqual"),
UnittestAssert::FailUnlessEqual => write!(f, "failUnlessEqual"),
UnittestAssert::False => write!(f, "assertFalse"),
UnittestAssert::Greater => write!(f, "assertGreater"),
UnittestAssert::GreaterEqual => write!(f, "assertGreaterEqual"),
Expand Down Expand Up @@ -110,6 +123,12 @@ impl TryFrom<&str> for UnittestAssert {
"assertDictEqual" => Ok(UnittestAssert::DictEqual),
"assertEqual" => Ok(UnittestAssert::Equal),
"assertEquals" => Ok(UnittestAssert::Equals),
"failIf" => Ok(UnittestAssert::FailIf),
"failIfAlmostEqual" => Ok(UnittestAssert::FailIfAlmostEqual),
"failIfEqual" => Ok(UnittestAssert::FailIfEqual),
"failUnless" => Ok(UnittestAssert::FailUnless),
"failUnlessAlmostEqual" => Ok(UnittestAssert::FailUnlessAlmostEqual),
"failUnlessEqual" => Ok(UnittestAssert::FailUnlessEqual),
"assertFalse" => Ok(UnittestAssert::False),
"assertGreater" => Ok(UnittestAssert::Greater),
"assertGreaterEqual" => Ok(UnittestAssert::GreaterEqual),
Expand Down Expand Up @@ -198,6 +217,12 @@ impl UnittestAssert {
UnittestAssert::True => &["expr", "msg"],
UnittestAssert::TupleEqual => &["first", "second", "msg"],
UnittestAssert::Underscore => &["expr", "msg"],
UnittestAssert::FailIf => &["expr", "msg"],
UnittestAssert::FailIfAlmostEqual => &["first", "second", "msg"],
UnittestAssert::FailIfEqual => &["first", "second", "msg"],
UnittestAssert::FailUnless => &["expr", "msg"],
UnittestAssert::FailUnlessAlmostEqual => &["first", "second", "places", "msg", "delta"],
UnittestAssert::FailUnlessEqual => &["first", "second", "places", "msg", "delta"],
}
}

Expand Down Expand Up @@ -257,28 +282,35 @@ impl UnittestAssert {
pub(crate) fn generate_assert(self, args: &[Expr], keywords: &[Keyword]) -> Result<Stmt> {
let args = self.args_map(args, keywords)?;
match self {
UnittestAssert::True | UnittestAssert::False => {
UnittestAssert::True
| UnittestAssert::False
| UnittestAssert::FailUnless
| UnittestAssert::FailIf => {
let expr = *args
.get("expr")
.ok_or_else(|| anyhow!("Missing argument `expr`"))?;
let msg = args.get("msg").copied();
Ok(if matches!(self, UnittestAssert::False) {
assert(
&Expr::UnaryOp(ast::ExprUnaryOp {
op: UnaryOp::Not,
operand: Box::new(expr.clone()),
range: TextRange::default(),
}),
msg,
)
} else {
assert(expr, msg)
})
Ok(
if matches!(self, UnittestAssert::False | UnittestAssert::FailIf) {
assert(
&Expr::UnaryOp(ast::ExprUnaryOp {
op: UnaryOp::Not,
operand: Box::new(expr.clone()),
range: TextRange::default(),
}),
msg,
)
} else {
assert(expr, msg)
},
)
}
UnittestAssert::Equal
| UnittestAssert::Equals
| UnittestAssert::FailUnlessEqual
| UnittestAssert::NotEqual
| UnittestAssert::NotEquals
| UnittestAssert::FailIfEqual
| UnittestAssert::Greater
| UnittestAssert::GreaterEqual
| UnittestAssert::Less
Expand All @@ -293,8 +325,12 @@ impl UnittestAssert {
.ok_or_else(|| anyhow!("Missing argument `second`"))?;
let msg = args.get("msg").copied();
let cmp_op = match self {
UnittestAssert::Equal | UnittestAssert::Equals => CmpOp::Eq,
UnittestAssert::NotEqual | UnittestAssert::NotEquals => CmpOp::NotEq,
UnittestAssert::Equal
| UnittestAssert::Equals
| UnittestAssert::FailUnlessEqual => CmpOp::Eq,
UnittestAssert::NotEqual
| UnittestAssert::NotEquals
| UnittestAssert::FailIfEqual => CmpOp::NotEq,
UnittestAssert::Greater => CmpOp::Gt,
UnittestAssert::GreaterEqual => CmpOp::GtE,
UnittestAssert::Less => CmpOp::Lt,
Expand Down
80 changes: 80 additions & 0 deletions ...c/rules/flake8_pytest_style/snapshots/ruff__rules__flake8_pytest_style__tests__PT009.snap
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -548,6 +548,8 @@ PT009.py:82:9: PT009 [*] Use a regular `assert` instead of unittest-style `asser
81 | def test_assert_not_regexp_matches(self):
82 | self.assertNotRegex("abc", r"abc") # Error
| ^^^^^^^^^^^^^^^^^^^ PT009
83 |
84 | def test_fail_if(self):
|
= help: Replace `assertNotRegex(...)` with `assert ...`

Expand All @@ -557,5 +559,83 @@ PT009.py:82:9: PT009 [*] Use a regular `assert` instead of unittest-style `asser
81 81 | def test_assert_not_regexp_matches(self):
82 |- self.assertNotRegex("abc", r"abc") # Error
82 |+ assert not re.search("abc", "abc") # Error
83 83 |
84 84 | def test_fail_if(self):
85 85 | self.failIf("abc") # Error

PT009.py:85:9: PT009 [*] Use a regular `assert` instead of unittest-style `failIf`
|
84 | def test_fail_if(self):
85 | self.failIf("abc") # Error
| ^^^^^^^^^^^ PT009
86 |
87 | def test_fail_unless(self):
|
= help: Replace `failIf(...)` with `assert ...`

ℹ Suggested fix
82 82 | self.assertNotRegex("abc", r"abc") # Error
83 83 |
84 84 | def test_fail_if(self):
85 |- self.failIf("abc") # Error
85 |+ assert not "abc" # Error
86 86 |
87 87 | def test_fail_unless(self):
88 88 | self.failUnless("abc") # Error

PT009.py:88:9: PT009 [*] Use a regular `assert` instead of unittest-style `failUnless`
|
87 | def test_fail_unless(self):
88 | self.failUnless("abc") # Error
| ^^^^^^^^^^^^^^^ PT009
89 |
90 | def test_fail_unless_equal(self):
|
= help: Replace `failUnless(...)` with `assert ...`

ℹ Suggested fix
85 85 | self.failIf("abc") # Error
86 86 |
87 87 | def test_fail_unless(self):
88 |- self.failUnless("abc") # Error
88 |+ assert "abc" # Error
89 89 |
90 90 | def test_fail_unless_equal(self):
91 91 | self.failUnlessEqual(1, 2) # Error

PT009.py:91:9: PT009 [*] Use a regular `assert` instead of unittest-style `failUnlessEqual`
|
90 | def test_fail_unless_equal(self):
91 | self.failUnlessEqual(1, 2) # Error
| ^^^^^^^^^^^^^^^^^^^^ PT009
92 |
93 | def test_fail_if_equal(self):
|
= help: Replace `failUnlessEqual(...)` with `assert ...`

ℹ Suggested fix
88 88 | self.failUnless("abc") # Error
89 89 |
90 90 | def test_fail_unless_equal(self):
91 |- self.failUnlessEqual(1, 2) # Error
91 |+ assert 1 == 2 # Error
92 92 |
93 93 | def test_fail_if_equal(self):
94 94 | self.failIfEqual(1, 2) # Error

PT009.py:94:9: PT009 [*] Use a regular `assert` instead of unittest-style `failIfEqual`
|
93 | def test_fail_if_equal(self):
94 | self.failIfEqual(1, 2) # Error
| ^^^^^^^^^^^^^^^^ PT009
|
= help: Replace `failIfEqual(...)` with `assert ...`

ℹ Suggested fix
91 91 | self.failUnlessEqual(1, 2) # Error
92 92 |
93 93 | def test_fail_if_equal(self):
94 |- self.failIfEqual(1, 2) # Error
94 |+ assert 1 != 2 # Error


20 changes: 10 additions & 10 deletions crates/ruff/src/rules/pyupgrade/rules/deprecated_unittest_alias.rs
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -59,21 +59,21 @@ impl AlwaysAutofixableViolation for DeprecatedUnittestAlias {

static DEPRECATED_ALIASES: Lazy<FxHashMap<&'static str, &'static str>> = Lazy::new(|| {
FxHashMap::from_iter([
("failUnlessEqual", "assertEqual"),
("assertAlmostEquals", "assertAlmostEqual"),
("assertEquals", "assertEqual"),
("failIfEqual", "assertNotEqual"),
("assertNotAlmostEquals", "assertNotAlmostEqual"),
("assertNotEquals", "assertNotEqual"),
("failUnless", "assertTrue"),
("assertNotRegexpMatches", "assertNotRegex"),
("assertRaisesRegexp", "assertRaisesRegex"),
("assertRegexpMatches", "assertRegex"),
("assert_", "assertTrue"),
("failIf", "assertFalse"),
("failUnlessRaises", "assertRaises"),
("failUnlessAlmostEqual", "assertAlmostEqual"),
("assertAlmostEquals", "assertAlmostEqual"),
("failIfAlmostEqual", "assertNotAlmostEqual"),
("assertNotAlmostEquals", "assertNotAlmostEqual"),
("assertRegexpMatches", "assertRegex"),
("assertNotRegexpMatches", "assertNotRegex"),
("assertRaisesRegexp", "assertRaisesRegex"),
("failIfEqual", "assertNotEqual"),
("failUnless", "assertTrue"),
("failUnlessAlmostEqual", "assertAlmostEqual"),
("failUnlessEqual", "assertEqual"),
("failUnlessRaises", "assertRaises"),
])
});

Expand Down