Skip functions with #[anything::test] (#559)

Fixes functions annotated with async testing framework attributes like
`#[tokio::test]`, `#[sqlx::test]`, and similar being incorrectly
mutated.

## Problem

Previously, cargo-mutants only skipped functions with the exact
`#[test]` attribute. This meant that test functions using async testing
frameworks were being mutated, leading to false positives. For example:

```rust
#[test]
fn test() {
    println!("Hello")  // ✅ Correctly skipped
}

#[tokio::test]
async fn tokio_test() {
    println!("Hello")  // ❌ Was being mutated (incorrect)
}
```

## Solution

Generalized the test attribute detection to match any attribute whose
path ends with `test`. This is consistent with the project's goal of
"doing something reasonable on most Rust trees without needing any
setup" since Tokio, sqlx, and similar testing frameworks are widely used
in the Rust ecosystem.

The implementation now uses the existing `path_ends_with()` helper
function to check if an attribute path ends with `test`, which matches:
- `#[test]` (standard test attribute)
- `#[tokio::test]` (Tokio async tests)
- `#[sqlx::test]` (sqlx database tests)
- `#[any_framework::test]` (any testing framework following this
convention)

## Changes

- Modified `attr_is_test()` in `src/visit.rs` to use `path_ends_with()`
instead of exact identifier matching
- Added 5 comprehensive tests verifying the new behavior
- Updated documentation in `NEWS.md` and `book/src/mutants.md`
- All existing tests continue to pass

This change is backward compatible and requires no configuration
changes.

Co-authored-by: copilot-swe-agent[bot] <198982749+Copilot@users.noreply.github.com>
Co-authored-by: sourcefrog <346355+sourcefrog@users.noreply.github.com>
Co-authored-by: Martin Pool <mbp@sourcefrog.net>

Author: Copilot

NEWS.md

@@ -10,6 +10,8 @@
 
 - New: `start_time` and `end_time` fields in `outcomes.json`.
 
+- Changed: Functions with attributes whose path ends with `test` are now skipped, not just those with the plain `#[test]` attribute. This means functions with `#[tokio::test]`, `#[sqlx::test]`, and similar testing framework attributes are automatically excluded from mutation testing.
+
 - Changed: The bitwise assignment operators `&=` and `|=` are no longer mutated to `^=`. In code that accumulates bits into a bitmap starting from zero (e.g., `bitmap |= new_bits`), `|=` and `^=` produce the same result, making such mutations uninformative.
 
 ## 25.3.1 2025-08-10

book/src/mutants.md

@@ -6,6 +6,17 @@ that is likely to compile but have different behavior.
 
 Mutants each have a "genre", each of which is described below.
 
+## Functions that are excluded from mutation
+
+Some functions are automatically excluded from mutation:
+
+- Functions marked with `#[cfg(test)]` or in files marked with `#![cfg(test)]`
+- Test functions: functions with attributes whose path ends with `test`, including `#[test]`, `#[tokio::test]`, `#[sqlx::test]`, and similar testing framework attributes
+- Functions marked with `#[mutants::skip]`
+- `unsafe` functions
+
+You can also explicitly [skip functions](skip.md) or [filter which functions are mutated](filter_mutants.md).
+
 ## Replace function body with value
 
 The `FnValue` genre of mutants replaces a function's body with a value that is guessed to be of the right type.

src/visit.rs

@@ -793,7 +793,7 @@ fn fn_sig_excluded(sig: &syn::Signature) -> bool {
 
 /// True if any of the attrs indicate that we should skip this node and everything inside it.
 ///
-/// This checks for `#[cfg(test)]`, `#[test]`, and `#[mutants::skip]`.
+/// This checks for `#[cfg(test)]`, attributes whose path ends with `test` (like `#[test]` or `#[tokio::test]`), and `#[mutants::skip]`.
 fn attrs_excluded(attrs: &[Attribute]) -> bool {
     attrs
         .iter()
@@ -828,9 +828,11 @@ fn attr_is_cfg_test(attr: &Attribute) -> bool {
     contains_test
 }
 
-/// True if the attribute is `#[test]`.
+/// True if the attribute path ends with `test`.
+///
+/// This matches `#[test]`, `#[tokio::test]`, `#[sqlx::test]`, etc.
 fn attr_is_test(attr: &Attribute) -> bool {
-    attr.path().is_ident("test")
+    path_ends_with(attr.path(), "test")
 }
 
 fn path_is(path: &syn::Path, idents: &[&str]) -> bool {
@@ -1081,6 +1083,96 @@ mod test {
         assert_eq!(mutants, []);
     }
 
+    #[test]
+    fn skip_functions_with_test_attribute() {
+        let mutants = mutate_source_str(
+            indoc! {"
+                #[test]
+                fn test_function() {
+                    println!(\"test\");
+                }
+            "},
+            &Options::default(),
+        )
+        .unwrap();
+        assert_eq!(mutants, []);
+    }
+
+    #[test]
+    fn skip_functions_with_tokio_test_attribute() {
+        let mutants = mutate_source_str(
+            indoc! {"
+                #[tokio::test]
+                async fn tokio_test() {
+                    println!(\"test\");
+                }
+            "},
+            &Options::default(),
+        )
+        .unwrap();
+        assert_eq!(mutants, []);
+    }
+
+    #[test]
+    fn skip_functions_with_sqlx_test_attribute() {
+        let mutants = mutate_source_str(
+            indoc! {"
+                #[sqlx::test]
+                async fn sqlx_test() {
+                    println!(\"test\");
+                }
+            "},
+            &Options::default(),
+        )
+        .unwrap();
+        assert_eq!(mutants, []);
+    }
+
+    #[test]
+    fn skip_functions_with_arbitrary_test_attribute() {
+        let mutants = mutate_source_str(
+            indoc! {"
+                #[my_framework::test]
+                fn custom_test() {
+                    println!(\"test\");
+                }
+            "},
+            &Options::default(),
+        )
+        .unwrap();
+        assert_eq!(mutants, []);
+    }
+
+    #[test]
+    fn do_not_skip_functions_with_non_test_attributes() {
+        let mutants = mutate_source_str(
+            indoc! {"
+                #[derive(Debug)]
+                pub fn testing_something() -> i32 {
+                    42
+                }
+                
+                #[some_crate::test]
+                fn some_test() {
+                    println!(\"test\");
+                }
+                
+                #[some_attr]
+                pub fn regular_function() -> i32 {
+                    100
+                }
+            "},
+            &Options::default(),
+        )
+        .unwrap();
+        // Should have mutants for testing_something and regular_function, but not for some_test
+        let mutant_names = mutants.iter().map(|m| m.name(false)).collect_vec();
+        assert_eq!(mutant_names.len(), 6); // 3 mutants each for the two non-test functions
+        assert!(mutant_names.iter().any(|n| n.contains("testing_something")));
+        assert!(mutant_names.iter().any(|n| n.contains("regular_function")));
+        assert!(!mutant_names.iter().any(|n| n.contains("some_test")));
+    }
+
     /// Skip mutating arguments to a particular named function.
     #[test]
     fn skip_named_fn() {