Struct MockCanisterCaller 

pub struct MockCanisterCaller<F: Fn(&Principal, &str, Vec<u8>) -> Vec<u8> + Send + Sync> { /* private fields */ }

A mock implementation of CanisterCaller for testing purposes.

This struct allows you to simulate canister calls by providing a transformation function that takes the canister ID, method name, and arguments, and returns a response.

Example

use anda_engine::context::mock::MockCanisterCaller;
use anda_core::CanisterCaller;
use candid::{encode_args, CandidType, Deserialize, Principal};

#[derive(CandidType, Deserialize, Debug, PartialEq)]
struct TestResponse {
    canister: Principal,
    method: String,
    args: Vec<u8>,
}

#[tokio::test]
async fn test_mock_canister_caller() {
    let canister_id = Principal::anonymous();
    let empty_args = encode_args(()).unwrap();

    let caller = MockCanisterCaller::new(|canister, method, args| {
        let response = TestResponse {
            canister: canister.clone(),
            method: method.to_string(),
            args,
        };
        candid::encode_args((response,)).unwrap()
    });

    let res: TestResponse = caller
        .canister_query(&canister_id, "canister_query", ())
        .await
        .unwrap();
    assert_eq!(res.canister, canister_id);
    assert_eq!(res.method, "canister_query");
    assert_eq!(res.args, empty_args);

    let res: TestResponse = caller
        .canister_update(&canister_id, "canister_update", ())
        .await
        .unwrap();
    assert_eq!(res.canister, canister_id);
    assert_eq!(res.method, "canister_update");
    assert_eq!(res.args, empty_args);
}

Implementations

impl<F> MockCanisterCaller<F>

where F: Fn(&Principal, &str, Vec<u8>) -> Vec<u8> + Send + Sync,

pub fn new(transform: F) -> Self

Creates a new MockCanisterCaller with the provided transformation function.

Arguments

• transform - A function that takes (canister_id, method_name, args) and returns a serialized response

Trait Implementations

impl<F> CanisterCaller for MockCanisterCaller<F>

where F: Fn(&Principal, &str, Vec<u8>) -> Vec<u8> + Send + Sync,

async fn canister_query<In: ArgumentEncoder + Send, Out: CandidType + for<'a> Deserialize<'a>>( &self, canister: &Principal, method: &str, args: In, ) -> Result<Out, BoxError>

Performs a query call to a canister (read-only, no state changes)

async fn canister_update<In: ArgumentEncoder + Send, Out: CandidType + for<'a> Deserialize<'a>>( &self, canister: &Principal, method: &str, args: In, ) -> Result<Out, BoxError>

Performs an update call to a canister (may modify state)