rust-testing

pluginagentmarketplace's avatarfrom pluginagentmarketplace

Master Rust testing - unit tests, integration tests, mocking, and TDD

⭐1stars🔀0forks📁View on GitHub🕐Updated Jan 5, 2026
[Testing and QA]

When & Why to Use This Skill

This Claude skill provides a comprehensive toolkit for mastering the Rust testing ecosystem. It empowers developers to implement high-quality software through unit testing, integration testing, documentation tests, and advanced techniques like property-based testing and mocking, ensuring code reliability and performance in Rust projects.

Use Cases

  • Case 1: Writing and organizing unit tests within Rust modules to validate internal logic and handle edge cases effectively.
  • Case 2: Setting up integration tests in the tests/ directory to verify the public API and end-to-end workflows of a crate.
  • Case 3: Implementing Test-Driven Development (TDD) by utilizing Rust's built-in test runner and advanced tools like cargo-nextest.
  • Case 4: Using mocking frameworks such as mockall to isolate components and simulate external dependencies like databases or APIs.
  • Case 5: Leveraging property-based testing with proptest to automatically generate a wide range of inputs and uncover hidden bugs.
namerust-testing
descriptionMaster Rust testing - unit tests, integration tests, mocking, and TDD
sasmp_version"1.3.0"
bonded_agentrust-tooling-agent
bond_typeSECONDARY_BOND
version"1.0.0"

Rust Testing Skill

Master comprehensive testing in Rust: unit tests, integration tests, doc tests, property testing, and mocking.

Quick Start

Unit Tests

pub fn add(a: i32, b: i32) -> i32 {
    a + b
}

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn test_add_positive() {
        assert_eq!(add(2, 3), 5);
    }

    #[test]
    fn test_add_negative() {
        assert_eq!(add(-1, -1), -2);
    }

    #[test]
    #[should_panic(expected = "overflow")]
    fn test_overflow() {
        panic!("overflow");
    }

    #[test]
    #[ignore]
    fn expensive_test() {
        // Run with: cargo test -- --ignored
    }
}

Integration Tests

// tests/integration_test.rs
use my_crate::public_api;

#[test]
fn test_full_workflow() {
    let result = public_api::process("input");
    assert!(result.is_ok());
}

mod common;  // tests/common/mod.rs

#[test]
fn test_with_setup() {
    let ctx = common::setup();
    // test...
}

Doc Tests

/// Adds two numbers.
///
/// # Examples
///
/// ```
/// let result = my_lib::add(2, 2);
/// assert_eq!(result, 4);
/// ```
pub fn add(a: i32, b: i32) -> i32 {
    a + b
}

Test Commands

cargo test                      # All tests
cargo test test_name            # Specific test
cargo test -- --nocapture       # Show output
cargo test -- --ignored         # Ignored tests
cargo test --doc                # Doc tests only
cargo nextest run               # Fast parallel

Common Patterns

Async Tests

#[tokio::test]
async fn test_async_operation() {
    let result = async_function().await;
    assert!(result.is_ok());
}

Property Testing

use proptest::prelude::*;

proptest! {
    #[test]
    fn test_commutative(a in 0i32..1000, b in 0i32..1000) {
        assert_eq!(add(a, b), add(b, a));
    }
}

Mocking

use mockall::automock;

#[automock]
trait Database {
    fn get(&self, id: u32) -> Option<String>;
}

#[test]
fn test_with_mock() {
    let mut mock = MockDatabase::new();
    mock.expect_get()
        .returning(|_| Some("data".to_string()));
}

Troubleshooting

Problem Solution
Test not found Check module path
Async fails Add #[tokio::test]
Random failures Use --test-threads=1

Resources