feat: improved mock server for unit and provider testing

[0xAlcibiades]

Motivation

As a user of the ecosystem, I need a robust way to unit test code without having to connect to a node or fork alloy, for example when I need the presence of a provider I control the responses of. The existing mock provider was limited in that it could not handle concurrent requests, nor did it have a proper handle for management.

Solution

This pull request implements a much improved mock provider that can be used, and is usable, for flexible unit tests across the ecosystem where a provider is involved.

Additionally, there are tests, which could be included here at will.

#[cfg(test)]
mod tests {
    use super::*;
    use crate::test_utils::RUSTLS;
    use alloy::primitives::U256;
    use alloy::providers::{Provider, ProviderBuilder};
    use alloy::transports::ipc::IpcConnect;
    use once_cell::sync::Lazy;
    use serde_json::json;
    use telemetry::TRACING;

    /// Test the basic functionality of the mock IPC server:
    /// - Server creation and startup
    /// - Adding a response
    /// - Connecting a provider
    /// - Making a request and receiving the mocked response
    /// - Clean shutdown
    #[tokio::test(flavor = "multi_thread")]
    async fn test_mock_ipc_server() -> eyre::Result<()> {
        // Initialize logging
        Lazy::force(&RUSTLS);
        Lazy::force(&TRACING);

        // Create and start the mock server
        let server = MockIpcServer::new();
        let path = server.path();
        let handle = server.spawn().await?;

        // Queue a mock response for eth_getBalance
        handle
            .add_reply(json!({
                "jsonrpc": "2.0",
                "id": 0,
                "result": "0x0000000000000000000000000000000000000000000000000000000000000064"
            }))
            .await;

        // Create a provider connected to our mock
        let provider = ProviderBuilder::new().on_ipc(IpcConnect::new(path)).await?;

        // Make a request and verify the response
        let balance = provider
            .get_balance("0x742d35Cc6634C0532925a3b844Bc454e4438f44e".parse()?)
            .await?;

        assert_eq!(balance, U256::from(100));

        // Clean shutdown
        handle.shutdown().await;
        Ok(())
    }
}

However, I didn't want to presume to add dependencies to this crate.

PR Checklist

• Added Tests
• Added Documentation
• Breaking changes

[mattsse]

supportive

some suggestions

[mattsse]

smol pedantic nit

[mattsse]

last suggestion to remove channel because none of this does IO

[mattsse]

imo we can get rid of this additional roundtrip entirely.
we don't need this and can write the response right away.

[mattsse]

this is also problematic because there's no guarantee that this task will pop the item that was at first position when the task was spawned

[mattsse]

ah one more problem here is that this uses unix socket which is incompatible with windows,

we have LocalSocketStream for that