canic-host 0.110.53

Host-side App build and desired-state Fleet reconciliation library for Canic workspaces
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

use super::{IcpJsonResponseError, decode_json_response, decode_json_result_response};
use candid::Encode;
use canic_core::{
    cdk::utils::hash::hex_bytes, diagnostics::codes, dto::error::Error as CanicError,
};
use ic_host_tools::response::{JsonErrorKind, ResponseError};

#[test]
fn decodes_plain_typed_response_bytes() {
    let output = response_json(&42_u64);

    assert_eq!(
        decode_json_response::<u64>(&output).expect("decode value"),
        42
    );
}

#[test]
fn decodes_successful_typed_result_response_bytes() {
    let output = response_json(&Ok::<u64, CanicError>(42));

    assert_eq!(
        decode_json_result_response::<u64>(&output).expect("decode result"),
        42
    );
}

#[test]
fn preserves_typed_canister_rejection() {
    let output = response_json(&Err::<u64, _>(CanicError::from_registered(
        codes::AUTHORITY_UNAUTHORIZED,
    )));
    let error = decode_json_result_response::<u64>(&output).expect_err("reject result");

    let IcpJsonResponseError::Rejected(error) = error else {
        panic!("expected typed canister rejection");
    };
    assert_eq!(error.code(), codes::AUTHORITY_UNAUTHORIZED.raw_code());

    let rendered = IcpJsonResponseError::Rejected(error).to_string();
    assert!(rendered.contains("canister rejected request: E30 AUTHORITY_UNAUTHORIZED"));
    assert!(rendered.contains("origin: topology_authority"));
    assert!(rendered.contains("Authority is unauthorized."));
}

#[test]
fn requires_top_level_string_response_bytes() {
    for output in [r"{}", r#"{"response_bytes":null}"#] {
        assert!(matches!(
            decode_json_response::<u64>(output),
            Err(IcpJsonResponseError::Envelope(
                ResponseError::MissingResponseBytes
            ))
        ));
    }
}

#[test]
fn rejects_invalid_hex_and_candid() {
    assert!(matches!(
        decode_json_response::<u64>(r#"{"response_bytes":"not-hex"}"#),
        Err(IcpJsonResponseError::Envelope(ResponseError::InvalidHex {
            offset: 0
        }))
    ));
    assert!(matches!(
        decode_json_response::<u64>(r#"{"response_bytes":"00"}"#),
        Err(IcpJsonResponseError::Candid(_))
    ));
}

#[test]
fn envelope_errors_preserve_shared_categories_and_source() {
    for output in [
        r#"{"response_bytes":42}"#,
        r#"{"response_bytes":"00","response_bytes":"01"}"#,
    ] {
        let error = decode_json_response::<u64>(output).unwrap_err();
        assert!(matches!(
            error,
            IcpJsonResponseError::Envelope(ResponseError::Json {
                kind: JsonErrorKind::Data,
                ..
            })
        ));
        assert!(
            std::error::Error::source(&error)
                .unwrap()
                .downcast_ref::<ResponseError>()
                .is_some()
        );
    }
    assert!(matches!(
        decode_json_response::<u64>("not json"),
        Err(IcpJsonResponseError::Envelope(ResponseError::Json {
            kind: JsonErrorKind::Syntax,
            ..
        }))
    ));
    assert!(matches!(
        super::response_bytes(r#"{"response_bytes":"f"}"#),
        Err(IcpJsonResponseError::Envelope(ResponseError::OddHexLength))
    ));
    assert!(matches!(
        super::response_bytes(r#"{"response_bytes":" 00"}"#),
        Err(IcpJsonResponseError::Envelope(ResponseError::InvalidHex {
            offset: 0
        }))
    ));
    assert_eq!(
        super::response_bytes(r#"{"response_bytes":""}"#).unwrap(),
        Vec::<u8>::new()
    );
}

fn response_json<T: candid::CandidType>(response: &T) -> String {
    let bytes = Encode!(response).expect("encode response");
    serde_json::json!({
        "response_bytes": hex_bytes(bytes),
        "response_text": null,
        "response_candid": "scripted",
    })
    .to_string()
}