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

use crate::node::{Def, Schema, SchemaGraphError, SchemaNode, Validator};

fn validator(path: &'static str, ident: &'static str) -> SchemaNode {
    SchemaNode::Validator(Validator::new(Def::new(path, ident)))
}

#[test]
fn sealing_is_deterministic_and_idempotent() {
    let mut left = Schema::new();
    left.insert_node(validator("test::beta", "Beta"));
    left.insert_node(validator("test::alpha", "Alpha"));

    let mut right = Schema::new();
    right.insert_node(validator("test::alpha", "Alpha"));
    right.insert_node(validator("test::beta", "Beta"));

    let left_digest = left.seal().expect("left graph should seal");
    let right_digest = right.seal().expect("right graph should seal");

    assert_eq!(left_digest, right_digest);
    assert_eq!(
        left.seal().expect("sealed graph should reuse its digest"),
        left_digest,
    );
}

#[test]
fn sealing_digest_changes_with_graph_content() {
    let mut before = Schema::new();
    before.insert_node(validator("test", "Before"));

    let mut after = Schema::new();
    after.insert_node(validator("test", "After"));

    assert_ne!(
        before.seal().expect("before graph should seal"),
        after.seal().expect("after graph should seal"),
    );
}

#[test]
fn duplicate_registration_fails_without_replacing_the_first_node() {
    let mut schema = Schema::new();
    schema.insert_node(validator("test", "Duplicate"));
    schema.insert_node(validator("test", "Duplicate"));

    assert_eq!(
        schema.seal(),
        Err(SchemaGraphError::DuplicateRegistration(
            "test::Duplicate".to_string(),
        )),
    );
    assert_eq!(schema.nodes().len(), 1);
}

#[test]
fn duplicate_registration_diagnostic_is_constructor_order_independent() {
    let mut left = Schema::new();
    left.insert_node(validator("test", "Beta"));
    left.insert_node(validator("test", "Beta"));
    left.insert_node(validator("test", "Alpha"));
    left.insert_node(validator("test", "Alpha"));

    let mut right = Schema::new();
    right.insert_node(validator("test", "Alpha"));
    right.insert_node(validator("test", "Alpha"));
    right.insert_node(validator("test", "Beta"));
    right.insert_node(validator("test", "Beta"));

    let expected = Err(SchemaGraphError::DuplicateRegistration(
        "test::Alpha".to_string(),
    ));
    assert_eq!(left.seal(), expected);
    assert_eq!(right.seal(), expected);
}

#[test]
fn late_registration_fails_without_mutating_the_snapshot() {
    let mut schema = Schema::new();
    schema.insert_node(validator("test", "BeforeSeal"));
    let digest = schema.seal().expect("initial graph should seal");

    schema.insert_node(validator("test", "AfterSeal"));

    assert_eq!(
        schema.seal(),
        Err(SchemaGraphError::LateRegistration(
            "test::AfterSeal".to_string(),
        )),
    );
    assert_eq!(schema.digest(), Some(digest));
    assert_eq!(schema.nodes().len(), 1);
}