canic-core 0.21.10

Canic — a canister orchestration and management toolkit for the 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

// Category A - Internal runtime-configured tests (ConfigTestBuilder when needed).
//! Test-only intent store wrappers for PocketIC canisters.

use crate::{
    ids::IntentResourceKey, ops::storage::intent::IntentStoreOps,
    storage::stable::intent::IntentStore,
};

#[doc(hidden)]
pub(crate) use crate::storage::stable::intent::{
    IntentId, IntentPendingEntryRecord, IntentRecord, IntentResourceTotalsRecord,
    IntentStoreMetaRecord,
};

///
/// IntentTestOps
///
/// Test-only convenience facade over IntentStoreOps.
/// Owns time explicitly and converts errors to strings for assertions.
///

pub struct IntentTestOps;

impl IntentTestOps {
    // -------------------------------------------------------------------------
    // Time helpers
    // -------------------------------------------------------------------------

    #[must_use]
    pub fn now() -> u64 {
        // Tests should override this explicitly where needed
        crate::ops::ic::IcOps::now_secs()
    }

    // -------------------------------------------------------------------------
    // Allocation
    // -------------------------------------------------------------------------

    pub fn allocate_intent_id() -> Result<IntentId, String> {
        IntentStoreOps::allocate_intent_id().map_err(|e| e.to_string())
    }

    // -------------------------------------------------------------------------
    // Commands
    // -------------------------------------------------------------------------

    pub fn try_reserve(
        intent_id: IntentId,
        resource_key: IntentResourceKey,
        quantity: u64,
        created_at: u64,
        ttl_secs: Option<u64>,
        now_secs: u64,
    ) -> Result<IntentRecord, String> {
        IntentStoreOps::try_reserve(
            intent_id,
            resource_key,
            quantity,
            created_at,
            ttl_secs,
            now_secs,
        )
        .map_err(|e| e.to_string())
    }

    pub fn commit_at(intent_id: IntentId, now: u64) -> Result<IntentRecord, String> {
        IntentStoreOps::commit_at(intent_id, now).map_err(|e| e.to_string())
    }

    pub fn abort(intent_id: IntentId) -> Result<IntentRecord, String> {
        IntentStoreOps::abort(intent_id).map_err(|e| e.to_string())
    }

    // -------------------------------------------------------------------------
    // Read-only views (TTL authoritative)
    // -------------------------------------------------------------------------

    #[must_use]
    pub fn totals_at(resource_key: &IntentResourceKey, now: u64) -> IntentResourceTotalsRecord {
        IntentStoreOps::totals_at(resource_key, now)
    }

    #[must_use]
    pub fn pending_entries_at(now: u64) -> Vec<(IntentId, IntentPendingEntryRecord)> {
        IntentStoreOps::pending_entries_at(now)
    }

    #[must_use]
    pub fn expired_pending_ids(now: u64) -> Vec<IntentId> {
        IntentStoreOps::list_expired_pending_intents(now)
    }

    // -------------------------------------------------------------------------
    // Storage-level inspection (tests only)
    // -------------------------------------------------------------------------

    #[must_use]
    pub fn meta() -> IntentStoreMetaRecord {
        // Tests are allowed to read storage internals directly
        IntentStore::meta()
    }

    #[must_use]
    pub fn record(intent_id: IntentId) -> Option<IntentRecord> {
        IntentStore::get_record(intent_id)
    }
}