Testing Generic Code with Mock Objects

In this lesson, you’ll learn how to make your generic business logic testable by using trait bounds to swap real dependencies for mock objects.

The Dependency Problem

When writing generic functions, you often rely on external services like databases or network APIs. If your code uses concrete types (like a RealDatabase), your tests will be slow, flaky, or require complex setups. To solve this, we define a trait that represents the behavior we need, and we constrain our generic function to that trait.

Injecting Mocks via Generics

Instead of hardcoding a type, you define a generic function with a trait bound. During production, you pass the RealDatabase. During testing, you pass a MockDatabase that implements the same trait but returns canned responses.

Consider this service:

pub trait DataProvider {
    fn fetch_data(&self) -> String;
}

// Our generic business logic
pub fn process_data<T: DataProvider>(source: T) -> String {
    let data = source.fetch_data();
    format!("Processed: {}", data)
}

// In your test module
struct MockDatabase;
impl DataProvider for MockDatabase {
    fn fetch_data(&self) -> String {
        "mocked result".to_string()
    }
}

#[test]
fn test_process_data() {
    let mock = MockDatabase;
    assert_eq!(process_data(mock), "Processed: mocked result");
}

Why this works with Static Dispatch

Because we are using T: DataProvider (static dispatch), the compiler generates a specialized version of process_data for our MockDatabase at compile time. This is extremely efficient—there is no runtime overhead for using the mock. The compiler simply inlines the logic for the specific type you provide.

By decoupling your logic from concrete implementations through these trait bounds, you ensure that your business rules remain pure and easy to verify. You don't need to change your production code to accommodate testing; you simply satisfy the trait requirements with a "fake" struct that mimics the interface.

Key Takeaway: By constraining generic parameters with traits, you can seamlessly inject mock implementations into your business logic, allowing for isolated and performant unit testing without sacrificing the zero-cost performance of static dispatch.