icydb-model 0.299.0

IcyDB application-model authoring, validation, and code generation
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
125
126
127
128
129
130
131
132
133
134
135
136

use crate::node::{
    Canister, Def, Entity, FieldList, PrimaryKey, PrimaryKeySource, Schema, SchemaNode, Store, Type,
};

use super::*;

fn insert_canister_store(
    schema: &mut Schema,
    module_path: &'static str,
    canister_ident: &'static str,
    canister_path: &'static str,
    store_ident: &'static str,
    store_path: &'static str,
) {
    schema.insert_node(SchemaNode::Canister(Canister::new(
        Def::new(module_path, canister_ident),
        "test_db",
        None,
    )));
    schema.insert_node(SchemaNode::Store(Store::new_journaled(
        Def::new(module_path, store_ident),
        canister_path,
        StoreJournaledMemoryConfig::new("main"),
    )));

    let inserted_store_path = format!("{module_path}::{store_ident}");
    assert_eq!(
        inserted_store_path, store_path,
        "test helper requires literal store-path to match Def path",
    );
}

fn insert_entity(
    schema: &mut Schema,
    module_path: &'static str,
    entity_ident: &'static str,
    store_path: &'static str,
) {
    schema.insert_node(SchemaNode::Entity(Entity::new(
        Def::new(module_path, entity_ident),
        store_path,
        1,
        PrimaryKey::new(&["id"], PrimaryKeySource::Internal),
        &[],
        &[],
        &[],
        FieldList::new(&[]),
        Type::new(&[], &[], &[]),
    )));
}

#[test]
fn validate_entity_naming_rejects_case_insensitive_duplicates_per_canister() {
    let mut schema = Schema::new();

    insert_canister_store(
        &mut schema,
        "schema_case_conflict",
        "Canister",
        "schema_case_conflict::Canister",
        "Store",
        "schema_case_conflict::Store",
    );
    insert_entity(
        &mut schema,
        "schema_case_conflict",
        "Struct",
        "schema_case_conflict::Store",
    );
    insert_entity(
        &mut schema,
        "schema_case_conflict",
        "struct",
        "schema_case_conflict::Store",
    );

    let mut errs = ErrorTree::new();
    validate_entity_naming(&schema, &mut errs);
    let err = errs
        .result()
        .expect_err("case-insensitive duplicate entity names must fail");
    let rendered = err.to_string();

    assert!(
        rendered.contains("duplicate entity name"),
        "expected duplicate entity-name error, got: {rendered}",
    );
    assert!(
        rendered.contains("case-insensitive conflict"),
        "expected case-insensitive conflict detail, got: {rendered}",
    );
    assert!(
        rendered.contains("schema_case_conflict::Struct")
            && rendered.contains("schema_case_conflict::struct"),
        "expected both conflicting entity paths in error detail, got: {rendered}",
    );
}

#[test]
fn validate_entity_naming_allows_same_name_when_canister_differs() {
    let mut schema = Schema::new();

    insert_canister_store(
        &mut schema,
        "schema_case_allowed_a",
        "CanisterA",
        "schema_case_allowed_a::CanisterA",
        "StoreA",
        "schema_case_allowed_a::StoreA",
    );
    insert_canister_store(
        &mut schema,
        "schema_case_allowed_b",
        "CanisterB",
        "schema_case_allowed_b::CanisterB",
        "StoreB",
        "schema_case_allowed_b::StoreB",
    );
    insert_entity(
        &mut schema,
        "schema_case_allowed_a",
        "Struct",
        "schema_case_allowed_a::StoreA",
    );
    insert_entity(
        &mut schema,
        "schema_case_allowed_b",
        "struct",
        "schema_case_allowed_b::StoreB",
    );

    let mut errs = ErrorTree::new();
    validate_entity_naming(&schema, &mut errs);
    errs.result()
        .expect("case variants across different canisters should pass");
}