icydb 0.296.1

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

use crate::{
    Error, ErrorCode, ErrorOrigin,
    db::EntitySchemaDescription,
    diagnostic::RuntimeBoundaryCode,
    wire::{
        method::RpcMethod,
        reply::{
            MAX_PUBLIC_QUERY_REPLY_BYTES, MAX_REPLICATED_QUERY_REPLY_BYTES,
            into_deliverable_query_reply_with_limit, into_deliverable_schema_reply,
        },
    },
};

// A scalar label controls encoded size without changing container-prefix widths.
fn report(label_bytes: usize) -> Vec<EntitySchemaDescription> {
    vec![EntitySchemaDescription::new(
        "tests::Entry".into(),
        "x".repeat(label_bytes),
        1,
        1,
        [0; 16],
        "id".into(),
        vec!["id".into()],
        vec![],
        vec![],
        vec![],
        vec![],
        1,
        1,
    )]
}

#[test]
fn schema_reply_admission_preserves_small_and_empty_successes() {
    for candidate in [vec![], report(5)] {
        assert_eq!(
            into_deliverable_schema_reply(candidate.clone()),
            Ok(candidate)
        );
    }
}

#[test]
fn schema_reply_admission_measures_the_exact_frame_at_both_ic_caps() {
    for limit in [
        MAX_REPLICATED_QUERY_REPLY_BYTES,
        MAX_PUBLIC_QUERY_REPLY_BYTES,
    ] {
        let probe = report(limit - 256);
        let response: Result<&Vec<EntitySchemaDescription>, Error> = Ok(&probe);
        let overhead =
            ic_wire::native::encoded_frame_len(&response, icydb_schema::wire::sizing_limits())
                .unwrap()
                - (limit - 256);
        for target in [limit - 1, limit, limit + 1] {
            let candidate = report(target - overhead);
            let response: Result<&Vec<EntitySchemaDescription>, Error> = Ok(&candidate);
            let bytes = ic_wire::native::encode_response(
                RpcMethod::Schema.id(),
                &response,
                icydb_schema::wire::sizing_limits(),
            )
            .unwrap();
            assert_eq!(bytes.len(), target);
            let result = into_deliverable_query_reply_with_limit(
                candidate.clone(),
                limit,
                RuntimeBoundaryCode::SchemaReplyBytesExceeded,
            );
            if target <= limit {
                assert_eq!(result, Ok(candidate));
            } else {
                let error = result.unwrap_err();
                assert_eq!(
                    error.code(),
                    ErrorCode::RUNTIME_BOUNDARY_SCHEMA_REPLY_BYTES_EXCEEDED
                );
                assert_eq!(error.origin(), ErrorOrigin::Response);
                let error_frame = RpcMethod::Schema
                    .encode_response(
                        Err::<Vec<EntitySchemaDescription>, Error>(error),
                        crate::wire::limits(limit),
                    )
                    .unwrap();
                assert!(error_frame.len() < limit);
                assert!(
                    RpcMethod::Schema
                        .decode_response::<Result<Vec<EntitySchemaDescription>, Error>>(
                            &error_frame,
                            crate::wire::limits(limit),
                        )
                        .unwrap()
                        .is_err()
                );
            }
        }
    }
}

#[test]
fn schema_public_guard_returns_a_deliverable_error_for_an_oversized_success() {
    let error = into_deliverable_schema_reply(report(MAX_PUBLIC_QUERY_REPLY_BYTES)).unwrap_err();
    assert_eq!(
        error.code(),
        ErrorCode::RUNTIME_BOUNDARY_SCHEMA_REPLY_BYTES_EXCEEDED
    );
    let frame = RpcMethod::Schema
        .encode_response(
            Err::<Vec<EntitySchemaDescription>, Error>(error),
            crate::wire::limits(MAX_PUBLIC_QUERY_REPLY_BYTES),
        )
        .unwrap();
    assert!(frame.len() < MAX_REPLICATED_QUERY_REPLY_BYTES);
}