ic-response-verification 3.2.0

Client side response verification 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

use crate::types::VerifiedResponse;

#[cfg(all(target_arch = "wasm32", feature = "js"))]
use wasm_bindgen::prelude::*;

#[cfg(all(target_arch = "wasm32", feature = "js"))]
#[wasm_bindgen(typescript_custom_section)]
const VERIFICATION_RESULT: &'static str = r#"
type VerificationInfo = {
  response?: VerifiedResponse;
  verificationVersion: number;
}
"#;

/// Result of verifying the provided request/response pair's certification.
#[derive(Debug)]
pub struct VerificationInfo {
    /// Response object including the status code, body and headers that were included in the
    /// certification and passed verification. If verification failed then this object will be
    /// empty.
    pub response: Option<VerifiedResponse>,
    /// The version of verification that was used to verify the response
    pub verification_version: u16,
}

#[cfg(all(target_arch = "wasm32", feature = "js"))]
impl From<VerificationInfo> for JsValue {
    fn from(verification_result: VerificationInfo) -> Self {
        use js_sys::{Array, Number, Object};

        let verification_version = Number::from(verification_result.verification_version);
        let verification_version_entry =
            Array::of2(&JsValue::from("verificationVersion"), &verification_version);

        let response = JsValue::from(verification_result.response);
        let response_entry = Array::of2(&JsValue::from("response"), &response.into());

        let result =
            Object::from_entries(&Array::of2(&response_entry, &verification_version_entry))
                .unwrap();

        JsValue::from(result)
    }
}

#[cfg(all(target_arch = "wasm32", feature = "js", test))]
mod tests {
    use super::*;
    use js_sys::JSON;
    use wasm_bindgen::JsValue;
    use wasm_bindgen_test::wasm_bindgen_test;

    #[wasm_bindgen_test]
    fn serialize_verification_result_with_no_response() {
        let expected = r#"{"verificationVersion":1}"#;

        assert_eq!(
            JSON::stringify(&JsValue::from(VerificationInfo {
                response: None,
                verification_version: 1,
            }))
            .unwrap(),
            expected
        );
    }

    #[wasm_bindgen_test]
    fn serialize_verification_result_with_response() {
        let expected = r#"{"response":{"statusCode":200,"body":{"0":0,"1":1,"2":2},"headers":[]},"verificationVersion":2}"#;

        assert_eq!(
            JSON::stringify(&JsValue::from(VerificationInfo {
                response: Some(VerifiedResponse {
                    status_code: Some(200),
                    body: vec![0, 1, 2],
                    headers: vec![],
                }),
                verification_version: 2,
            }))
            .unwrap(),
            expected
        );
    }
}