[flake8-pytest-style] Implement duplicate parameterized fixture detection (PT014)

crates/ruff/resources/test/fixtures/flake8_pytest_style/PT014.py

@@ -0,0 +1,26 @@
+import pytest
+
+
+@pytest.mark.parametrize("x", [1, 1, 2])
+def test_error_literal(x):
+    ...
+
+
+a = 1
+b = 2
+c = 3
+
+
+@pytest.mark.parametrize("x", [a, a, b, b, c])
+def test_error_expr_simple(x):
+    ...
+
+
+@pytest.mark.parametrize("x", [(a, b), (a, b), (b, c)])
+def test_error_expr_complex(x):
+    ...
+
+
+@pytest.mark.parametrize("x", [1, 2])
+def test_ok(x):
+    ...

crates/ruff/src/checkers/ast/analyze/statement.rs

@@ -300,6 +300,7 @@ pub(crate) fn statement(stmt: &Stmt, checker: &mut Checker) {
             if checker.any_enabled(&[
                 Rule::PytestParametrizeNamesWrongType,
                 Rule::PytestParametrizeValuesWrongType,
+                Rule::PytestDuplicateParametrizeTestCases,
             ]) {
                 flake8_pytest_style::rules::parametrize(checker, decorator_list);
             }

crates/ruff/src/codes.rs

@@ -685,6 +685,7 @@ pub fn code_to_rule(linter: Linter, code: &str) -> Option<(RuleGroup, Rule)> {
         (Flake8PytestStyle, "011") => (RuleGroup::Unspecified, rules::flake8_pytest_style::rules::PytestRaisesTooBroad),
         (Flake8PytestStyle, "012") => (RuleGroup::Unspecified, rules::flake8_pytest_style::rules::PytestRaisesWithMultipleStatements),
         (Flake8PytestStyle, "013") => (RuleGroup::Unspecified, rules::flake8_pytest_style::rules::PytestIncorrectPytestImport),
+        (Flake8PytestStyle, "014") => (RuleGroup::Unspecified, rules::flake8_pytest_style::rules::PytestDuplicateParametrizeTestCases),
         (Flake8PytestStyle, "015") => (RuleGroup::Unspecified, rules::flake8_pytest_style::rules::PytestAssertAlwaysFalse),
         (Flake8PytestStyle, "016") => (RuleGroup::Unspecified, rules::flake8_pytest_style::rules::PytestFailWithoutMessage),
         (Flake8PytestStyle, "017") => (RuleGroup::Unspecified, rules::flake8_pytest_style::rules::PytestAssertInExcept),

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

@@ -169,6 +169,12 @@ mod tests {
         Settings::default(),
         "PT013"
     )]
+    #[test_case(
+        Rule::PytestDuplicateParametrizeTestCases,
+        Path::new("PT014.py"),
+        Settings::default(),
+        "PT014"
+    )]
     #[test_case(
         Rule::PytestAssertAlwaysFalse,
         Path::new("PT015.py"),

crates/ruff/src/rules/flake8_pytest_style/rules/parametrize.rs

@@ -1,3 +1,5 @@
+use itertools::Itertools;
+
 use ruff_python_ast::{
     self as ast, Arguments, Constant, Decorator, Expr, ExprContext, PySourceType, Ranged,
 };
@@ -6,6 +8,7 @@ use ruff_text_size::TextRange;
 
 use ruff_diagnostics::{AutofixKind, Diagnostic, Edit, Fix, Violation};
 use ruff_macros::{derive_message_formats, violation};
+use ruff_python_ast::comparable::ComparableExpr;
 use ruff_python_codegen::Generator;
 use ruff_source_file::Locator;
 
@@ -166,6 +169,58 @@ impl Violation for PytestParametrizeValuesWrongType {
     }
 }
 
+/// ## What it does
+/// Checks for duplicate test cases in `pytest.mark.parametrize`.
+///
+/// ## Why is this bad?
+/// Duplicate test cases are redundant and should be removed.
+///
+/// ## Example
+/// ```python
+/// import pytest
+///
+///
+/// @pytest.mark.parametrize(
+///     ("param1", "param2"),
+///     [
+///         (1, 2),
+///         (1, 2),
+///     ],
+/// )
+/// def test_foo(param1, param2):
+///     ...
+/// ```
+///
+/// Use instead:
+/// ```python
+/// import pytest
+///
+///
+/// @pytest.mark.parametrize(
+///     ("param1", "param2"),
+///     [
+///         (1, 2),
+///     ],
+/// )
+/// def test_foo(param1, param2):
+///     ...
+/// ```
+///
+/// ## References
+/// - [`pytest` documentation: How to parametrize fixtures and test functions](https://docs.pytest.org/en/latest/how-to/parametrize.html#pytest-mark-parametrize)
+#[violation]
+pub struct PytestDuplicateParametrizeTestCases {
+    pub indices: (usize, usize),
+}
+
+impl Violation for PytestDuplicateParametrizeTestCases {
+    #[derive_message_formats]
+    fn message(&self) -> String {
+        let PytestDuplicateParametrizeTestCases { indices } = self;
+        format!("Found duplicate test cases {indices:?} in `@pytest.mark.parametrize`")
+    }
+}
+
 fn elts_to_csv(elts: &[Expr], generator: Generator) -> Option<String> {
     let all_literals = elts.iter().all(|expr| {
         matches!(
@@ -472,6 +527,7 @@ fn check_values(checker: &mut Checker, names: &Expr, values: &Expr) {
                     values.range(),
                 ));
             }
+
             if is_multi_named {
                 handle_value_rows(checker, elts, values_type, values_row_type);
             }
@@ -494,6 +550,31 @@ fn check_values(checker: &mut Checker, names: &Expr, values: &Expr) {
     }
 }
 
+fn find_duplicates(elts: &[Expr]) -> Vec<(usize, usize)> {
+    let mut duplicates: Vec<(usize, usize)> = Vec::new();
+    for ((idx1, elt1), (idx2, elt2)) in elts.iter().enumerate().tuple_combinations() {
+        if ComparableExpr::from(elt1) == ComparableExpr::from(elt2) {
+            duplicates.push((idx1 + 1, idx2 + 1));
+        }
+    }
+    duplicates
+}
+
+/// PT014
+fn check_duplicates(checker: &mut Checker, values: &Expr) {
+    match values {
+        Expr::List(ast::ExprList { elts, .. }) | Expr::Tuple(ast::ExprTuple { elts, .. }) => {
+            for indices in find_duplicates(elts) {
+                checker.diagnostics.push(Diagnostic::new(
+                    PytestDuplicateParametrizeTestCases { indices },
+                    values.range(),
+                ));
+            }
+        }
+        _ => {}
+    }
+}
+
 fn handle_single_name(checker: &mut Checker, expr: &Expr, value: &Expr) {
     let mut diagnostic = Diagnostic::new(
         PytestParametrizeNamesWrongType {
@@ -567,6 +648,11 @@ pub(crate) fn parametrize(checker: &mut Checker, decorators: &[Decorator]) {
                         }
                     }
                 }
+                if checker.enabled(Rule::PytestDuplicateParametrizeTestCases) {
+                    if let [_, values, ..] = &args[..] {
+                        check_duplicates(checker, values);
+                    }
+                }
             }
         }
     }

crates/ruff/src/rules/flake8_pytest_style/snapshots/ruff__rules__flake8_pytest_style__tests__PT014.snap

@@ -0,0 +1,36 @@
+---
+source: crates/ruff/src/rules/flake8_pytest_style/mod.rs
+---
+PT014.py:4:31: PT014 Found duplicate test cases (1, 2) in `@pytest.mark.parametrize`
+  |
+4 | @pytest.mark.parametrize("x", [1, 1, 2])
+  |                               ^^^^^^^^^ PT014
+5 | def test_error_literal(x):
+6 |     ...
+  |
+
+PT014.py:14:31: PT014 Found duplicate test cases (1, 2) in `@pytest.mark.parametrize`
+   |
+14 | @pytest.mark.parametrize("x", [a, a, b, b, c])
+   |                               ^^^^^^^^^^^^^^^ PT014
+15 | def test_error_expr_simple(x):
+16 |     ...
+   |
+
+PT014.py:14:31: PT014 Found duplicate test cases (3, 4) in `@pytest.mark.parametrize`
+   |
+14 | @pytest.mark.parametrize("x", [a, a, b, b, c])
+   |                               ^^^^^^^^^^^^^^^ PT014
+15 | def test_error_expr_simple(x):
+16 |     ...
+   |
+
+PT014.py:19:31: PT014 Found duplicate test cases (1, 2) in `@pytest.mark.parametrize`
+   |
+19 | @pytest.mark.parametrize("x", [(a, b), (a, b), (b, c)])
+   |                               ^^^^^^^^^^^^^^^^^^^^^^^^ PT014
+20 | def test_error_expr_complex(x):
+21 |     ...
+   |
+
+