ic-atp 0.1.2

ATP(Account Transfer Protocol) implementation for Internet Computer
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145

//! Mock implementations of IC API for testing

use candid::Principal;
use std::cell::RefCell;
use std::collections::HashMap;
use std::time::{SystemTime, UNIX_EPOCH};

use super::api::IcApi;

/// A configurable mock for the IC API
pub struct MockIcApi {
    caller: RefCell<Principal>,
    id: RefCell<Principal>,
    time: RefCell<u64>,
    logs: RefCell<Vec<String>>,
}

impl Default for MockIcApi {
    fn default() -> Self {
        Self {
            caller: RefCell::new(Principal::anonymous()),
            id: RefCell::new(
                Principal::from_text("rrkah-fqaaa-aaaaa-aaaaq-cai")
                    .unwrap_or_else(|_| Principal::anonymous()),
            ),
            time: RefCell::new(
                SystemTime::now()
                    .duration_since(UNIX_EPOCH)
                    .unwrap_or_default()
                    .as_nanos() as u64,
            ),
            logs: RefCell::new(Vec::new()),
        }
    }
}

impl MockIcApi {
    /// Create a new mock API with default values
    pub fn new() -> Self {
        Self::default()
    }

    /// Set the caller principal for testing
    pub fn with_caller(self, caller: Principal) -> Self {
        *self.caller.borrow_mut() = caller;
        self
    }

    /// Set the canister ID for testing
    pub fn with_id(self, id: Principal) -> Self {
        *self.id.borrow_mut() = id;
        self
    }

    /// Set the current time for testing
    pub fn with_time(self, time: u64) -> Self {
        *self.time.borrow_mut() = time;
        self
    }

    /// Get the logs that have been captured
    pub fn get_logs(&self) -> Vec<String> {
        self.logs.borrow().clone()
    }
}

impl IcApi for MockIcApi {
    fn caller(&self) -> Principal {
        self.caller.borrow().clone()
    }

    fn id(&self) -> Principal {
        self.id.borrow().clone()
    }

    fn time(&self) -> u64 {
        self.time.borrow().clone()
    }

    fn println(&self, message: &str) {
        self.logs.borrow_mut().push(message.to_string());
    }
}

/// A more sophisticated mock that can record and verify API calls
pub struct SpyIcApi {
    mock: MockIcApi,
    calls: RefCell<HashMap<String, usize>>,
}

impl SpyIcApi {
    /// Create a new spy API with default mock values
    pub fn new() -> Self {
        Self {
            mock: MockIcApi::default(),
            calls: RefCell::new(HashMap::new()),
        }
    }

    /// Configure the underlying mock
    pub fn with_mock(self, mock: MockIcApi) -> Self {
        Self {
            mock,
            calls: self.calls,
        }
    }

    /// Check how many times a method was called
    pub fn times_called(&self, method: &str) -> usize {
        *self.calls.borrow().get(method).unwrap_or(&0)
    }

    /// Reset call counts
    pub fn reset_calls(&self) {
        self.calls.borrow_mut().clear();
    }

    /// Record a method call
    fn record_call(&self, method: &str) {
        let mut calls = self.calls.borrow_mut();
        *calls.entry(method.to_string()).or_insert(0) += 1;
    }
}

impl IcApi for SpyIcApi {
    fn caller(&self) -> Principal {
        self.record_call("caller");
        self.mock.caller()
    }

    fn id(&self) -> Principal {
        self.record_call("id");
        self.mock.id()
    }

    fn time(&self) -> u64 {
        self.record_call("time");
        self.mock.time()
    }

    fn println(&self, message: &str) {
        self.record_call("println");
        self.mock.println(message);
    }
}