Simulating Network Latency

In this lesson, you will learn how to design test suites that inject artificial delays into your async communication layers to validate your application’s robustness under jitter and latency.

The Problem of "Happy Path" Testing

When testing async network code, we often rely on local loopback connections. Because these are near-instant, they mask race conditions and timing-dependent bugs. To simulate real-world conditions, we need an abstraction layer between our logic and the raw transport—essentially a "Latency Wrapper."

Implementing a Latency Proxy

Instead of mocking the entire socket, we wrap the AsyncRead and AsyncWrite traits. By introducing a tokio::time::sleep (or your custom executor's timer) inside these wrappers, we force our system to handle delayed responses gracefully.

Here is a simplified pattern for a latency-injecting buffer:

struct LatencyWrapper<T> {
    inner: T,
    delay: Duration,
}

impl<T: AsyncRead + Unpin> AsyncRead for LatencyWrapper<T> {
    fn poll_read(mut self: Pin<&mut Self>, cx: &mut Context<'_>, buf: &mut ReadBuf<'_>) -> Poll<io::Result<()>> {
        // Simulate jitter before fulfilling the read request
        let delay = sleep(self.delay);
        tokio::pin!(delay);
        
        match delay.poll(cx) {
            Poll::Pending => Poll::Pending,
            Poll::Ready(_) => Pin::new(&mut self.inner).poll_read(cx, buf),
        }
    }
}

Why this validates robustness

By wrapping your network stream in this structure, your unit tests can now verify three critical failure modes:

1. Timeout Handling: Does your system trigger the correct "Timeout" error when the latency exceeds your configured deadline?
2. Buffer Backpressure: If the "network" is slow, does your AsyncWrite implementation correctly signal backpressure by returning Poll::Pending rather than overwhelming memory?
3. Task Cancellation: If a task is dropped while waiting for a delayed packet, does your executor properly clean up the underlying resources?

By injecting these deterministic delays into your test suite, you transform flaky "works on my machine" networking code into a resilient system that respects the reality of distributed environments.

Key Takeaway: Simulating network latency requires wrapping your I/O streams in middleware that yields to the executor for a specified duration, ensuring your system logic remains responsive even when the underlying transport is slow.