[ruff] Ambiguous pattern passed to pytest.raises() (RUF043)

crates/ruff_linter/resources/test/fixtures/flake8_pytest_style/PT201.py

@@ -0,0 +1,35 @@
+import re
+import pytest
+
+def test_foo():
+
+    ### Errors
+
+    with pytest.raises(FooAtTheEnd, match="foo."): ...
+    with pytest.raises(PackageExtraSpecifier, match="Install `foo[bar]` instead"): ...
+    with pytest.raises(InnocentQuestion, match="This is a simple sentence (or is it?)"): ...
+
+    with pytest.raises(ManuallyEscapedWindowsPathToDotFile, match="C:\\\\Users\\\\Foo\\\\.config"): ...
+
+    with pytest.raises(MiddleDot, match="foo.bar"): ...
+    with pytest.raises(EndDot, match="foobar."): ...
+    with pytest.raises(EndBackslash, match="foobar\\"): ...
+
+
+    ### No errors
+
+    with pytest.raises(NoMatch): ...
+    with pytest.raises(NonLiteral, match=pattern): ...
+    with pytest.raises(FunctionCall, match=frobnicate("qux")): ...
+    with pytest.raises(ReEscaped, match=re.escape("foobar")): ...
+    with pytest.raises(RawString, match=r"fo()bar"): ...
+    with pytest.raises(RawStringPart, match=r"foo" '\bar'): ...
+    with pytest.raises(NoMetacharacters, match="foobar"): ...
+
+    with pytest.raises(ManuallyEscaped, match="some\\.fully\\.qualified\\.name"): ...
+    with pytest.raises(ManuallyEscapedWindowsPath, match="C:\\\\Users\\\\Foo\\\\file\\.py"): ...
+
+    with pytest.raises(MiddleEscapedDot, match="foo\\.bar"): ...
+    with pytest.raises(MiddleEscapedBackslash, match="foo\\\\bar"): ...
+    with pytest.raises(EndEscapedDot, match="foobar\\."): ...
+    with pytest.raises(EndEscapedBackslash, match="foobar\\\\"): ...

crates/ruff_linter/src/checkers/ast/analyze/expression.rs

@@ -907,6 +907,7 @@ pub(crate) fn expression(expr: &Expr, checker: &mut Checker) {
             if checker.any_enabled(&[
                 Rule::PytestRaisesWithoutException,
                 Rule::PytestRaisesTooBroad,
+                Rule::PytestRaisesAmbiguousPattern,
             ]) {
                 flake8_pytest_style::rules::raises_call(checker, call);
             }

crates/ruff_linter/src/codes.rs

@@ -826,6 +826,7 @@ pub fn code_to_rule(linter: Linter, code: &str) -> Option<(RuleGroup, Rule)> {
         (Flake8PytestStyle, "025") => (RuleGroup::Stable, rules::flake8_pytest_style::rules::PytestErroneousUseFixturesOnFixture),
         (Flake8PytestStyle, "026") => (RuleGroup::Stable, rules::flake8_pytest_style::rules::PytestUseFixturesWithoutParameters),
         (Flake8PytestStyle, "027") => (RuleGroup::Stable, rules::flake8_pytest_style::rules::PytestUnittestRaisesAssertion),
+        (Flake8PytestStyle, "201") => (RuleGroup::Preview, rules::flake8_pytest_style::rules::PytestRaisesAmbiguousPattern),
 
         // flake8-pie
         (Flake8Pie, "790") => (RuleGroup::Stable, rules::flake8_pie::rules::UnnecessaryPlaceholder),

crates/ruff_linter/src/rules/flake8_pytest_style/mod.rs

@@ -314,6 +314,7 @@ mod tests {
     }
 
     #[test_case(Rule::PytestParametrizeNamesWrongType, Path::new("PT006.py"))]
+    #[test_case(Rule::PytestRaisesAmbiguousPattern, Path::new("PT201.py"))]
     fn test_pytest_style_preview(rule_code: Rule, path: &Path) -> Result<()> {
         let snapshot = format!(
             "preview__{}_{}",

crates/ruff_linter/src/rules/flake8_pytest_style/rules/assertion.rs

@@ -144,7 +144,7 @@ impl Violation for PytestAssertInExcept {
 ///     ...
 /// ```
 ///
-/// References
+/// ## References
 /// - [`pytest` documentation: `pytest.fail`](https://docs.pytest.org/en/latest/reference/reference.html#pytest-fail)
 #[derive(ViolationMetadata)]
 pub(crate) struct PytestAssertAlwaysFalse;

crates/ruff_linter/src/rules/flake8_pytest_style/rules/marks.rs

@@ -104,7 +104,6 @@ impl AlwaysFixableViolation for PytestIncorrectMarkParenthesesStyle {
 ///
 /// ## References
 /// - [`pytest` documentation: `pytest.mark.usefixtures`](https://docs.pytest.org/en/latest/reference/reference.html#pytest-mark-usefixtures)
-
 #[derive(ViolationMetadata)]
 pub(crate) struct PytestUseFixturesWithoutParameters;
 

crates/ruff_linter/src/rules/flake8_pytest_style/rules/raises.rs

@@ -1,15 +1,15 @@
+use itertools::Itertools;
 use ruff_diagnostics::{Diagnostic, Violation};
 use ruff_macros::{derive_message_formats, ViolationMetadata};
 use ruff_python_ast::helpers::is_compound_statement;
-use ruff_python_ast::{self as ast, Expr, Stmt, WithItem};
+use ruff_python_ast::{self as ast, Expr, Keyword, Stmt, StringLiteralValue, WithItem};
 use ruff_python_semantic::SemanticModel;
 use ruff_text_size::Ranged;
 
+use super::helpers::is_empty_or_null_string;
 use crate::checkers::ast::Checker;
 use crate::registry::Rule;
 
-use super::helpers::is_empty_or_null_string;
-
 /// ## What it does
 /// Checks for `pytest.raises` context managers with multiple statements.
 ///
@@ -151,6 +151,78 @@ impl Violation for PytestRaisesWithoutException {
     }
 }
 
+/// ## What it does
+/// Checks for non-raw literal string arguments passed to the `match` parameter
+/// of `pytest.raises()` where the string contains at least one unescaped
+/// regex metacharacter.
+///
+/// ## Why is this bad?
+/// The `match` argument is implicitly converted to a regex under the hood.
+/// It should be made explicit whether the string is meant to be a regex or a "plain" pattern
+/// by prefixing the string with the `r` suffix, escaping the metacharacter(s)
+/// in the string using backslashes, or wrapping the entire string in a call to
+/// `re.escape()`.
+///
+/// ## Example
+///
+/// ```python
+/// import pytest
+///
+///
+/// with pytest.raises(Exception, match="A full sentence."):
+///     do_thing_that_raises()
+/// ```
+///
+/// Use instead:
+///
+/// ```python
+/// import pytest
+///
+///
+/// with pytest.raises(Exception, match=r"A full sentence."):
+///     do_thing_that_raises()
+/// ```
+///
+/// Alternatively:
+///
+/// ```python
+/// import pytest
+/// import re
+///
+///
+/// with pytest.raises(Exception, match=re.escape("A full sentence.")):
+///     do_thing_that_raises()
+/// ```
+///
+/// or:
+///
+/// ```python
+/// import pytest
+/// import re
+///
+///
+/// with pytest.raises(Exception, "A full sentence\\."):
+///     do_thing_that_raises()
+/// ```
+///
+/// ## References
+/// - [Python documentation: `re.escape`](https://docs.python.org/3/library/re.html#re.escape)
+/// - [`pytest` documentation: `pytest.raises`](https://docs.pytest.org/en/latest/reference/reference.html#pytest-raises)
+#[derive(ViolationMetadata)]
+pub(crate) struct PytestRaisesAmbiguousPattern;
+
+impl Violation for PytestRaisesAmbiguousPattern {
+    #[derive_message_formats]
+    fn message(&self) -> String {
+        "Pattern passed to `match=` contains metacharacters but is neither escaped nor raw"
+            .to_string()
+    }
+
+    fn fix_title(&self) -> Option<String> {
+        Some("Use a raw string or `re.escape()` to make the intention explicit".to_string())
+    }
+}
+
 fn is_pytest_raises(func: &Expr, semantic: &SemanticModel) -> bool {
     semantic
         .resolve_qualified_name(func)
@@ -165,6 +237,38 @@ const fn is_non_trivial_with_body(body: &[Stmt]) -> bool {
     }
 }
 
+fn string_has_unescaped_metacharacters(value: &StringLiteralValue) -> bool {
+    let mut skip = false;
+    let mut last = '\0';
+
+    for (current, next) in value.chars().tuple_windows() {
+        if skip {
+            skip = false;
+            continue;
+        }
+
+        if current == '\\' {
+            skip = true;
+            continue;
+        }
+
+        if char_is_regex_metacharacter(current) {
+            return true;
+        }
+
+        last = next;
+    }
+
+    !skip && char_is_regex_metacharacter(last)
+}
+
+const fn char_is_regex_metacharacter(c: char) -> bool {
+    matches!(
+        c,
+        '.' | '^' | '$' | '*' | '+' | '?' | '{' | '[' | '\\' | '|' | '('
+    )
+}
+
 pub(crate) fn raises_call(checker: &mut Checker, call: &ast::ExprCall) {
     if is_pytest_raises(&call.func, checker.semantic()) {
         if checker.enabled(Rule::PytestRaisesWithoutException) {
@@ -176,6 +280,21 @@ pub(crate) fn raises_call(checker: &mut Checker, call: &ast::ExprCall) {
             }
         }
 
+        if checker.enabled(Rule::PytestRaisesAmbiguousPattern) {
+            if let Some(Keyword { value, .. }) = call.arguments.find_keyword("match") {
+                if let Some(string) = value.as_string_literal_expr() {
+                    let any_part_is_raw =
+                        string.value.iter().any(|part| part.flags.prefix().is_raw());
+
+                    if !any_part_is_raw && string_has_unescaped_metacharacters(&string.value) {
+                        let diagnostic =
+                            Diagnostic::new(PytestRaisesAmbiguousPattern, string.range);
+                        checker.diagnostics.push(diagnostic);
+                    }
+                }
+            }
+        }
+
         if checker.enabled(Rule::PytestRaisesTooBroad) {
             if let Some(exception) = call.arguments.find_argument("expected_exception", 0) {
                 if call

crates/ruff_linter/src/rules/flake8_pytest_style/snapshots/ruff_linter__rules__flake8_pytest_style__tests__preview__PT201_PT201.py.snap

@@ -0,0 +1,74 @@
+---
+source: crates/ruff_linter/src/rules/flake8_pytest_style/mod.rs
+snapshot_kind: text
+---
+PT201.py:8:43: PT201 Pattern passed to `match=` contains metacharacters but is neither escaped nor raw
+   |
+ 6 |     ### Errors
+ 7 | 
+ 8 |     with pytest.raises(FooAtTheEnd, match="foo."): ...
+   |                                           ^^^^^^ PT201
+ 9 |     with pytest.raises(PackageExtraSpecifier, match="Install `foo[bar]` instead"): ...
+10 |     with pytest.raises(InnocentQuestion, match="This is a simple sentence (or is it?)"): ...
+   |
+   = help: Use a raw string or `re.escape()` to make the intention explicit
+
+PT201.py:9:53: PT201 Pattern passed to `match=` contains metacharacters but is neither escaped nor raw
+   |
+ 8 |     with pytest.raises(FooAtTheEnd, match="foo."): ...
+ 9 |     with pytest.raises(PackageExtraSpecifier, match="Install `foo[bar]` instead"): ...
+   |                                                     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ PT201
+10 |     with pytest.raises(InnocentQuestion, match="This is a simple sentence (or is it?)"): ...
+   |
+   = help: Use a raw string or `re.escape()` to make the intention explicit
+
+PT201.py:10:48: PT201 Pattern passed to `match=` contains metacharacters but is neither escaped nor raw
+   |
+ 8 |     with pytest.raises(FooAtTheEnd, match="foo."): ...
+ 9 |     with pytest.raises(PackageExtraSpecifier, match="Install `foo[bar]` instead"): ...
+10 |     with pytest.raises(InnocentQuestion, match="This is a simple sentence (or is it?)"): ...
+   |                                                ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ PT201
+11 | 
+12 |     with pytest.raises(ManuallyEscapedWindowsPathToDotFile, match="C:\\\\Users\\\\Foo\\\\.config"): ...
+   |
+   = help: Use a raw string or `re.escape()` to make the intention explicit
+
+PT201.py:12:67: PT201 Pattern passed to `match=` contains metacharacters but is neither escaped nor raw
+   |
+10 |     with pytest.raises(InnocentQuestion, match="This is a simple sentence (or is it?)"): ...
+11 | 
+12 |     with pytest.raises(ManuallyEscapedWindowsPathToDotFile, match="C:\\\\Users\\\\Foo\\\\.config"): ...
+   |                                                                   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ PT201
+13 | 
+14 |     with pytest.raises(MiddleDot, match="foo.bar"): ...
+   |
+   = help: Use a raw string or `re.escape()` to make the intention explicit
+
+PT201.py:14:41: PT201 Pattern passed to `match=` contains metacharacters but is neither escaped nor raw
+   |
+12 |     with pytest.raises(ManuallyEscapedWindowsPathToDotFile, match="C:\\\\Users\\\\Foo\\\\.config"): ...
+13 | 
+14 |     with pytest.raises(MiddleDot, match="foo.bar"): ...
+   |                                         ^^^^^^^^^ PT201
+15 |     with pytest.raises(EndDot, match="foobar."): ...
+16 |     with pytest.raises(EndBackslash, match="foobar\\"): ...
+   |
+   = help: Use a raw string or `re.escape()` to make the intention explicit
+
+PT201.py:15:38: PT201 Pattern passed to `match=` contains metacharacters but is neither escaped nor raw
+   |
+14 |     with pytest.raises(MiddleDot, match="foo.bar"): ...
+15 |     with pytest.raises(EndDot, match="foobar."): ...
+   |                                      ^^^^^^^^^ PT201
+16 |     with pytest.raises(EndBackslash, match="foobar\\"): ...
+   |
+   = help: Use a raw string or `re.escape()` to make the intention explicit
+
+PT201.py:16:44: PT201 Pattern passed to `match=` contains metacharacters but is neither escaped nor raw
+   |
+14 |     with pytest.raises(MiddleDot, match="foo.bar"): ...
+15 |     with pytest.raises(EndDot, match="foobar."): ...
+16 |     with pytest.raises(EndBackslash, match="foobar\\"): ...
+   |                                            ^^^^^^^^^^ PT201
+   |
+   = help: Use a raw string or `re.escape()` to make the intention explicit

crates/ruff_linter/src/rules/ruff/rules/unnecessary_regular_expression.rs

@@ -3,7 +3,7 @@ use ruff_diagnostics::{Applicability, Diagnostic, Edit, Fix, FixAvailability, Vi
 use ruff_macros::{derive_message_formats, ViolationMetadata};
 use ruff_python_ast::{
     Arguments, CmpOp, Expr, ExprAttribute, ExprCall, ExprCompare, ExprContext, ExprStringLiteral,
-    Identifier,
+    Identifier, StringLiteralValue,
 };
 use ruff_python_semantic::analyze::typing::find_binding_value;
 use ruff_python_semantic::{Modules, SemanticModel};
@@ -100,12 +100,8 @@ pub(crate) fn unnecessary_regular_expression(checker: &mut Checker, call: &ExprC
         return;
     };
 
-    // For now, reject any regex metacharacters. Compare to the complete list
-    // from https://docs.python.org/3/howto/regex.html#matching-characters
-    let has_metacharacters = string_lit
-        .value
-        .to_str()
-        .contains(['.', '^', '$', '*', '+', '?', '{', '[', '\\', '|', '(']);
+    // For now, reject any regex metacharacters.
+    let has_metacharacters = string_has_metacharacters(&string_lit.value);
 
     if has_metacharacters {
         return;
@@ -140,6 +136,14 @@ pub(crate) fn unnecessary_regular_expression(checker: &mut Checker, call: &ExprC
     checker.diagnostics.push(diagnostic);
 }
 
+pub(crate) fn string_has_metacharacters(value: &StringLiteralValue) -> bool {
+    // Compare to the complete list from
+    // https://docs.python.org/3/howto/regex.html#matching-characters
+    value
+        .to_str()
+        .contains(['.', '^', '$', '*', '+', '?', '{', '[', '\\', '|', '('])
+}
+
 /// The `re` functions supported by this rule.
 #[derive(Debug)]
 enum ReFuncKind<'a> {