Struct MockClient 

pub struct MockClient { /* private fields */ }

In-memory MCP client used for plan unit tests. Each tool is registered with a closure that maps the call arguments to a CallOutcome. The mock is fully synchronous internally; concurrency is provided by tokio.

Implementations

impl MockClient

pub fn new() -> Self

Creates an empty mock with no tools registered.

pub fn register<F>(self, tool: Tool, handler: F) -> Self

where F: Fn(&Value) -> CallOutcome + Send + Sync + 'static,

Registers a tool with a synchronous handler. The handler is invoked on every call_tool; it can return any CallOutcome variant to simulate crashes, hangs, or protocol errors.

pub fn register_async<F, Fut>(self, tool: Tool, handler: F) -> Self

where F: Fn(&Value) -> Fut + Send + Sync + 'static, Fut: Future<Output = CallOutcome> + Send + 'static,

Registers a tool with an async handler. Useful when testing cancellation: the handler can await indefinitely and rely on the caller’s cancellation to drop it.

pub fn reconnect_count(&self) -> usize

Returns the number of times reconnect has been invoked.

Trait Implementations

impl Default for MockClient

fn default() -> Self

Returns the “default value” for a type.

impl McpExec for MockClient

fn list_tools<'life0, 'async_trait>( &'life0 self, ) -> Pin<Box<dyn Future<Output = Result<Vec<Tool>, ClientError>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Lists every tool exposed by the server.

fn call_tool<'life0, 'life1, 'async_trait>( &'life0 self, name: &'life1 str, arguments: Value, _timeout: Duration, ) -> Pin<Box<dyn Future<Output = CallOutcome> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Calls a tool, applying timeout. Returns a CallOutcome that the caller pattern-matches; this method itself never errors.

fn reconnect<'life0, 'async_trait>( &'life0 self, ) -> Pin<Box<dyn Future<Output = Result<(), ClientError>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Tears down the transport and rebuilds it. Used after a hang/crash so subsequent calls can succeed. Concurrent callers see either the old or the new transport, never a torn state.