ic-host-tools 0.15.0

Host-side Candid interfaces and extraction, ICP responses and IC resource reports
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

use super::*;
use crate::candid::service::{ServiceLimits, inspect as inspect_service};
use ic_host_artifacts::wasm::{Export, InspectionLimits, inspect};
use std::collections::BTreeSet;

#[test]
fn projection_preserves_names_modes_and_internal_exports_without_acceptance_policy() {
    // This fixture tests projection over structural facts, not Wasm validation.
    let mut facts = inspect(
        b"\0asm\x01\0\0\0",
        InspectionLimits {
            module_bytes: 8,
            sections: 0,
            exports: 0,
            custom_sections: 0,
        },
    )
    .unwrap();
    for (name, kind) in [
        ("canister_query read with spaces", ExportKind::Function),
        ("canister_update read with spaces", ExportKind::Function),
        ("canister_composite_query composed", ExportKind::Function),
        (
            "canister_update <ic-cdk internal> timer_executor",
            ExportKind::Function,
        ),
        ("canister_query ", ExportKind::Function),
        ("canister_query not_a_function", ExportKind::Global),
        ("canister_init", ExportKind::Function),
        ("canister_query", ExportKind::Function),
        ("get_candid_pointer", ExportKind::Function),
    ] {
        facts.exports.insert(name, Export { kind, index: 0 });
    }
    let methods = exported_methods(&facts).collect::<BTreeSet<_>>();
    assert_eq!(
        methods,
        BTreeSet::from([
            ExportedMethod {
                name: "read with spaces",
                mode: MethodMode::Query
            },
            ExportedMethod {
                name: "read with spaces",
                mode: MethodMode::Update
            },
            ExportedMethod {
                name: "composed",
                mode: MethodMode::CompositeQuery
            },
            ExportedMethod {
                name: "<ic-cdk internal> timer_executor",
                mode: MethodMode::Update
            },
            ExportedMethod {
                name: "",
                mode: MethodMode::Query
            },
        ])
    );
}

#[test]
fn declared_and_exported_modes_can_be_compared_without_discarding_mismatches() {
    let methods = inspect_service(
        "service : { read : () -> () query; notify : () -> () oneway; };",
        ServiceLimits {
            source_bytes: 128,
            methods: 2,
        },
    )
    .unwrap();
    let mut module = b"\0asm\x01\0\0\0\x01\x04\x01\x60\0\0\x03\x02\x01\0".to_vec();
    let mut exports = vec![2];
    for name in ["canister_update read", "canister_update notify"] {
        exports.push(u8::try_from(name.len()).unwrap());
        exports.extend_from_slice(name.as_bytes());
        exports.extend_from_slice(&[0, 0]);
    }
    module.extend_from_slice(&[7, u8::try_from(exports.len()).unwrap()]);
    module.extend_from_slice(&exports);
    module.extend_from_slice(&[10, 4, 1, 2, 0, 11]);
    let facts = inspect(
        &module,
        InspectionLimits {
            module_bytes: 1024,
            sections: 4,
            exports: 2,
            custom_sections: 0,
        },
    )
    .unwrap();
    let declared = methods
        .iter()
        .map(|method| method.as_export())
        .collect::<BTreeSet<_>>();
    let exported = exported_methods(&facts).collect::<BTreeSet<_>>();
    assert_eq!(
        declared.difference(&exported).copied().collect::<Vec<_>>(),
        vec![ExportedMethod {
            name: "read",
            mode: MethodMode::Query
        }]
    );
    assert_eq!(
        exported.difference(&declared).copied().collect::<Vec<_>>(),
        vec![ExportedMethod {
            name: "read",
            mode: MethodMode::Update
        }]
    );
}