diff --git a/crates/ruff/resources/test/fixtures/flake8_pytest_style/PT009.py b/crates/ruff/resources/test/fixtures/flake8_pytest_style/PT009.py index e25aef6facff9..128c6b0325729 100644 --- a/crates/ruff/resources/test/fixtures/flake8_pytest_style/PT009.py +++ b/crates/ruff/resources/test/fixtures/flake8_pytest_style/PT009.py @@ -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 diff --git a/crates/ruff/src/rules/flake8_pytest_style/rules/unittest_assert.rs b/crates/ruff/src/rules/flake8_pytest_style/rules/unittest_assert.rs index 52274ab22c355..49c78e10d49e8 100644 --- a/crates/ruff/src/rules/flake8_pytest_style/rules/unittest_assert.rs +++ b/crates/ruff/src/rules/flake8_pytest_style/rules/unittest_assert.rs @@ -19,6 +19,13 @@ pub(crate) enum UnittestAssert { DictEqual, Equal, Equals, + FailIf, + FailIfAlmostEqual, + FailIfEqual, + FailUnless, + FailUnlessAlmostEqual, + FailUnlessEqual, + // FailUnlessRaises, False, Greater, GreaterEqual, @@ -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"), @@ -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), @@ -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"], } } @@ -257,28 +282,35 @@ impl UnittestAssert { pub(crate) fn generate_assert(self, args: &[Expr], keywords: &[Keyword]) -> Result { 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 @@ -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, diff --git a/crates/ruff/src/rules/flake8_pytest_style/snapshots/ruff__rules__flake8_pytest_style__tests__PT009.snap b/crates/ruff/src/rules/flake8_pytest_style/snapshots/ruff__rules__flake8_pytest_style__tests__PT009.snap index be4c1bb726387..ff04ae6a491c8 100644 --- a/crates/ruff/src/rules/flake8_pytest_style/snapshots/ruff__rules__flake8_pytest_style__tests__PT009.snap +++ b/crates/ruff/src/rules/flake8_pytest_style/snapshots/ruff__rules__flake8_pytest_style__tests__PT009.snap @@ -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 ...` @@ -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 diff --git a/crates/ruff/src/rules/pyupgrade/rules/deprecated_unittest_alias.rs b/crates/ruff/src/rules/pyupgrade/rules/deprecated_unittest_alias.rs index f716a465bbb48..a939672f303b9 100644 --- a/crates/ruff/src/rules/pyupgrade/rules/deprecated_unittest_alias.rs +++ b/crates/ruff/src/rules/pyupgrade/rules/deprecated_unittest_alias.rs @@ -59,21 +59,21 @@ impl AlwaysAutofixableViolation for DeprecatedUnittestAlias { static DEPRECATED_ALIASES: Lazy> = 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"), ]) });