Mocking & Test Doubles

Rust favors trait-based seams and manual fakes over heavy mocking frameworks. mockall generates mock implementations for traits when you need call expectations and verification.

Recipe

use mockall::automock;
 
#[automock]
pub trait PaymentGateway {
    async fn charge(&self, cents: u64) -> Result<String, Error>;
}

let mut mock = MockPaymentGateway::new();
mock.expect_charge().returning(|_| Ok("ch_123".into()));

When to reach for this: External I/O boundaries (HTTP, payments, clock) that must be swapped in tests.

Working Example

use mockall::automock;
 
#[automock]
pub trait OrderRepo {
    async fn save(&self, order: &Order) -> Result<(), Error>;
}
 
pub struct Service<G: PaymentGateway, R: OrderRepo> {
    pay: G,
    repo: R,
}
 
impl<G: PaymentGateway, R: OrderRepo> Service<G, R> {
    pub async fn checkout(&self, order: &Order) -> Result<(), Error> {
        self.pay.charge(order.total_cents).await?;
        self.repo.save(order).await
    }
}
 
#[tokio::test]
async fn checkout_charges_then_saves() {
    let mut pay = MockPaymentGateway::new();
    pay.expect_charge().with(eq(500)).returning(|_| Ok("ok".into()));
 
    let mut repo = MockOrderRepo::new();
    repo.expect_save().times(1).returning(|_| Ok(()));
 
    let svc = Service { pay, repo };
    svc.checkout(&Order { total_cents: 500 }).await.unwrap();
}

What this demonstrates:

• Generic service accepts trait implementations
• expect_* sets call count and arguments
• Production uses real types; tests inject mocks
• Async traits need #[async_trait] or Rust 1.75+ native async traits

Deep Dive

Fake vs Mock

Manual Fake Example

struct InMemoryRepo {
    orders: Mutex<Vec<Order>>,
}
 
impl OrderRepo for InMemoryRepo {
    async fn save(&self, order: &Order) -> Result<(), Error> {
        self.orders.lock().unwrap().push(order.clone());
        Ok(())
    }
}

• Often clearer than mocks for domain logic
• No code generation; full control over behavior

Gotchas

• Mocking concrete structs - cannot without traits. Fix: extract trait boundary at compile time.
• Over-specifying call order - brittle tests. Fix: assert outcomes, not every internal call.
• Async trait mock without async_trait - confusing errors. Fix: enable mockall async support or use sync trait + block_on in tests only.
• Shared Arc<dyn Trait> mocks - expectation races in parallel tests. Fix: per-test mock instance.
• Mocking std types - not possible. Fix: wrap Instant, Uuid, or HTTP in your own trait.

Alternatives

FAQs

Related

• Test Organization - shared fakes
• Trait-Based Abstraction - design seams
• Testing Async Code - async tests
• Unit vs Integration Tests - where doubles live

Stack versions: This page was written for Rust 1.97.0 (edition 2024), Tokio 1.x, Axum 0.8, serde 1.0, sqlx 0.8, clap 4, and Polars 0.46+.