icydb 0.264.5

IcyDB — A schema-first typed query engine and persistence runtime for Internet Computer canisters
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
146
147
148
149
150
151
152
153
154
155

//! Exact public classifications for nested upstream causes and internal controls.

use crate::{
    Error, ErrorOrigin,
    db::{DatabaseBootstrapError, MemoryBootstrapAdmissionError},
};
use ic_memory::{
    AllocationValidationError, BootstrapAdmissionError, MemoryManagerRangeAuthorityError,
    RuntimeAdoptionError, RuntimeBootstrapError, RuntimeOpenError, RuntimePolicyError,
    RuntimeStateError, StableKey, StaticMemoryDeclarationError,
};
use icydb_diagnostic_code::{DiagnosticFactTag, ErrorCode};

fn public(cause: RuntimeBootstrapError<MemoryBootstrapAdmissionError>) -> Error {
    Error::from(DatabaseBootstrapError::from(cause))
}

fn grant() -> MemoryManagerRangeAuthorityError {
    MemoryManagerRangeAuthorityError::UnclaimedId { id: 42 }
}

fn historical() -> BootstrapAdmissionError {
    BootstrapAdmissionError::Range {
        stable_key: StableKey::parse("icydb.main.store.old.journal.v1").unwrap(),
        authority: "icydb.main".into(),
        source: grant(),
    }
}

#[test]
fn memory_bootstrap_grant_wrappers_preserve_bounded_slot_evidence() {
    for cause in [
        RuntimeBootstrapError::Resolution(ic_memory::MemoryResolutionError::Range(grant())),
        RuntimeBootstrapError::Registry(StaticMemoryDeclarationError::Range(grant())),
        RuntimeBootstrapError::Validation(AllocationValidationError::Policy(
            RuntimePolicyError::Range(grant()),
        )),
    ] {
        let error = public(cause);
        assert_eq!(
            error.code(),
            ErrorCode::RUNTIME_BOUNDARY_MEMORY_ALLOCATION_RESOLUTION_FAILED
        );
        assert_eq!(
            error.core_facts().unwrap(),
            [(DiagnosticFactTag::ActualMemoryId, 42)]
        );
        assert_eq!(error.origin(), ErrorOrigin::Runtime);
    }
    for cause in [
        RuntimeBootstrapError::Admission(historical()),
        RuntimeBootstrapError::AdmissionPolicy(MemoryBootstrapAdmissionError::HistoricalJournal(
            historical(),
        )),
    ] {
        let error = public(cause);
        assert_eq!(
            error.code(),
            ErrorCode::RUNTIME_BOUNDARY_MEMORY_HISTORICAL_JOURNAL_UNAVAILABLE
        );
        assert_eq!(
            error.core_facts().unwrap(),
            [(DiagnosticFactTag::ActualMemoryId, 42)]
        );
    }
}

#[test]
fn memory_bootstrap_roles_and_invalid_declarations_keep_their_identity() {
    for store in [None, Some("main".to_string())] {
        let count = if store.is_some() { 4 } else { 3 };
        let error = public(RuntimeBootstrapError::AdmissionPolicy(
            MemoryBootstrapAdmissionError::IncompleteRoles {
                namespace: "main".into(),
                store,
            },
        ));
        assert_eq!(
            error.code(),
            ErrorCode::RUNTIME_BOUNDARY_MEMORY_ALLOCATION_ROLES_INCOMPLETE
        );
        assert_eq!(
            error.core_facts().unwrap(),
            [(DiagnosticFactTag::ExpectedCount, count)]
        );
    }
    for cause in [
        RuntimeBootstrapError::AdmissionPolicy(MemoryBootstrapAdmissionError::UnsupportedKey(
            "icydb.main.invalid.v1".into(),
        )),
        RuntimeBootstrapError::Validation(AllocationValidationError::Policy(
            RuntimePolicyError::Custom(MemoryBootstrapAdmissionError::InvalidDeclaration(
                "icydb.main.commit.control.v1".into(),
            )),
        )),
        RuntimeBootstrapError::Registry(StaticMemoryDeclarationError::DuplicateRequest {
            stable_key: StableKey::parse("icydb.main.commit.control.v1").unwrap(),
        }),
    ] {
        let error = public(cause);
        assert_eq!(
            error.code(),
            ErrorCode::RUNTIME_BOUNDARY_MEMORY_DECLARATION_INVALID
        );
        assert!(error.facts().is_empty());
    }
}

#[test]
fn memory_adoption_requirement_drift_is_a_public_conflict() {
    for cause in [
        RuntimeAdoptionError::UnknownAuthority {
            authority: "icydb.main".into(),
        },
        RuntimeAdoptionError::AuthorityMismatch {
            stable_key: "icydb.main.commit.control.v1".into(),
            committed_authority: "host.other".into(),
            requested_authority: "icydb.main".into(),
        },
        RuntimeAdoptionError::DeclarationMetadataMismatch {
            stable_key: "icydb.main.commit.control.v1".into(),
        },
        RuntimeAdoptionError::Open(RuntimeOpenError::StableKeyNotCommitted(
            "icydb.main.commit.control.v1".into(),
        )),
    ] {
        let error = Error::from(DatabaseBootstrapError::from(cause));
        assert_eq!(
            error.code(),
            ErrorCode::RUNTIME_BOUNDARY_MEMORY_DECLARATION_SNAPSHOT_MISMATCH
        );
        assert_eq!(error.class(), icydb_diagnostic_code::ErrorClass::Conflict);
        assert!(error.facts().is_empty());
    }
}

#[test]
fn memory_bootstrap_internal_failures_retain_internal_classification() {
    for cause in [
        RuntimeBootstrapError::State(RuntimeStateError::ReentrantAccess),
        RuntimeBootstrapError::State(RuntimeStateError::InconsistentLifecycle),
        RuntimeBootstrapError::Registry(StaticMemoryDeclarationError::RegistryPoisoned),
        RuntimeBootstrapError::Registry(StaticMemoryDeclarationError::EagerInitPanicked),
    ] {
        let error = public(cause);
        assert_eq!(error.code(), ErrorCode::RUNTIME_INTERNAL);
        assert_eq!(error.class(), icydb_diagnostic_code::ErrorClass::Internal);
        assert_eq!(error.origin(), ErrorOrigin::Runtime);
        assert!(error.facts().is_empty());
    }
    let error = Error::from(DatabaseBootstrapError::from(RuntimeAdoptionError::Open(
        RuntimeOpenError::State(RuntimeStateError::Unavailable),
    )));
    assert_eq!(error.code(), ErrorCode::RUNTIME_INTERNAL);
}