icydb 0.297.0

IcyDB — A schema-first typed query engine and persistence runtime for Internet Computer canisters
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

//! Current endpoint envelopes and native projections.

use crate::__macro::RpcMethod;

#[test]
fn endpoint_decoders_accept_deserialize_only_arguments() {
    #[derive(Debug, serde::Deserialize, PartialEq)]
    struct ReceiveOnly(u32);

    let request = RpcMethod::Query
        .encode_request(128_u32, crate::wire::limits(crate::wire::MAX_REQUEST_BYTES))
        .unwrap();
    assert_eq!(
        RpcMethod::Query.decode_request::<ReceiveOnly>(
            &request,
            crate::wire::limits(crate::wire::MAX_REQUEST_BYTES)
        ),
        Ok(ReceiveOnly(128))
    );
    let response = RpcMethod::Query
        .encode_response(128_u32, crate::wire::limits(crate::wire::MAX_REPLY_BYTES))
        .unwrap();
    assert_eq!(
        RpcMethod::Query.decode_response::<ReceiveOnly>(
            &response,
            crate::wire::limits(crate::wire::MAX_REPLY_BYTES)
        ),
        Ok(ReceiveOnly(128))
    );
}

#[test]
fn endpoint_identity_and_direction_are_checked_before_payloads() {
    let request = RpcMethod::Metrics
        .encode_request((), crate::wire::limits(crate::wire::MAX_REQUEST_BYTES))
        .unwrap();
    assert_eq!(&request[..2], b"IW");
    assert_eq!(&request[2..10], &RpcMethod::Metrics.id().to_le_bytes());
    assert_eq!(request[10], 0);
    assert_eq!(
        RpcMethod::Metrics.decode_request::<()>(
            &request,
            crate::wire::limits(crate::wire::MAX_REQUEST_BYTES)
        ),
        Ok(())
    );
    assert_eq!(
        RpcMethod::Snapshot.decode_request::<()>(
            &request,
            crate::wire::limits(crate::wire::MAX_REQUEST_BYTES)
        ),
        Err(ic_wire::Error::Identity)
    );
    assert_eq!(
        RpcMethod::Metrics
            .decode_response::<()>(&request, crate::wire::limits(crate::wire::MAX_REPLY_BYTES)),
        Err(ic_wire::Error::Identity)
    );

    let response = RpcMethod::Metrics
        .encode_response((), crate::wire::limits(crate::wire::MAX_REPLY_BYTES))
        .unwrap();
    assert_eq!(response[10], 1);
    assert_eq!(
        RpcMethod::Metrics
            .decode_response::<()>(&response, crate::wire::limits(crate::wire::MAX_REPLY_BYTES)),
        Ok(())
    );
}

#[test]
fn borrowed_arguments_share_the_generated_native_request_projection() {
    let sql = "SELECT id FROM Item".to_owned();
    let request = RpcMethod::Query
        .encode_request((&sql,), crate::wire::limits(crate::wire::MAX_REQUEST_BYTES))
        .unwrap();
    assert_eq!(
        RpcMethod::Query
            .decode_request::<String>(
                &request,
                crate::wire::limits(crate::wire::MAX_REQUEST_BYTES)
            )
            .unwrap(),
        sql
    );
    assert!(
        RpcMethod::Query
            .decode_request::<String>(
                &request[..request.len() - 1],
                crate::wire::limits(crate::wire::MAX_REQUEST_BYTES)
            )
            .is_err()
    );
    let mut trailing = request;
    trailing.push(0);
    assert!(
        RpcMethod::Query
            .decode_request::<String>(
                &trailing,
                crate::wire::limits(crate::wire::MAX_REQUEST_BYTES)
            )
            .is_err()
    );
}

#[test]
fn typed_public_errors_round_trip_through_the_actual_endpoint_envelope() {
    let error = crate::Error::from_runtime_boundary(
        crate::diagnostic::RuntimeBoundaryCode::DatabaseStartupRecoveryPending,
        crate::ErrorOrigin::Runtime,
    );
    let response: Result<(), crate::Error> = Err(error);
    let bytes = RpcMethod::MetricsReset
        .encode_response(&response, crate::wire::limits(crate::wire::MAX_REPLY_BYTES))
        .unwrap();
    assert_eq!(
        RpcMethod::MetricsReset
            .decode_response::<Result<(), crate::Error>>(
                &bytes,
                crate::wire::limits(crate::wire::MAX_REPLY_BYTES)
            )
            .unwrap(),
        response
    );
}