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

use crate::{
    Path as _,
    base::types::{
        color::{RgbHex, RgbaHex},
        finance::{E8s, E18s, Usd},
        geo::{AddressLine, CityName, PostalCode, RegionName},
        hash::Sha256,
        ident::{Constant, Field, Function, Variable, Variant},
        intl::{CountryCode, LanguageCode, PhoneNumber},
        lang::Code,
        num::{Degrees, Percent, PercentModifier},
        web::{MimeType, Url},
    },
    build::schema_read,
    node::Newtype,
};

#[test]
fn built_in_durable_rules_and_application_validators_have_disjoint_owners() {
    let schema = schema_read();
    for path in [
        Degrees::PATH,
        Percent::PATH,
        PercentModifier::PATH,
        Usd::PATH,
        E8s::PATH,
        E18s::PATH,
        AddressLine::PATH,
        CityName::PATH,
        PostalCode::PATH,
        RegionName::PATH,
    ] {
        let newtype = schema
            .cast_node::<Newtype>(path)
            .expect("durable built-in newtype should be registered");
        assert_eq!(newtype.ty().rules().len(), 1, "{path}");
        assert!(newtype.ty().validators().is_empty(), "{path}");
    }

    for path in [
        Constant::PATH,
        Field::PATH,
        Function::PATH,
        Variable::PATH,
        Variant::PATH,
    ] {
        let newtype = schema
            .cast_node::<Newtype>(path)
            .expect("identifier built-in newtype should be registered");
        assert_eq!(newtype.ty().rules().len(), 1, "{path}");
        assert_eq!(newtype.ty().validators().len(), 1, "{path}");
    }

    for path in [Url::PATH, MimeType::PATH, PhoneNumber::PATH] {
        let newtype = schema
            .cast_node::<Newtype>(path)
            .expect("application-only built-in newtype should be registered");
        assert!(newtype.ty().rules().is_empty(), "{path}");
        assert!(!newtype.ty().validators().is_empty(), "{path}");
    }

    for path in [
        RgbHex::PATH,
        RgbaHex::PATH,
        Sha256::PATH,
        CountryCode::PATH,
        LanguageCode::PATH,
        Code::PATH,
    ] {
        let newtype = schema
            .cast_node::<Newtype>(path)
            .expect("application-only built-in newtype should be registered");
        assert!(newtype.ty().rules().is_empty(), "{path}");
        assert!(!newtype.ty().validators().is_empty(), "{path}");
    }

    let mut classified = [
        Degrees::PATH,
        Percent::PATH,
        PercentModifier::PATH,
        Usd::PATH,
        E8s::PATH,
        E18s::PATH,
        AddressLine::PATH,
        CityName::PATH,
        PostalCode::PATH,
        RegionName::PATH,
        Constant::PATH,
        Field::PATH,
        Function::PATH,
        Variable::PATH,
        Variant::PATH,
        Url::PATH,
        MimeType::PATH,
        PhoneNumber::PATH,
        RgbHex::PATH,
        RgbaHex::PATH,
        Sha256::PATH,
        CountryCode::PATH,
        LanguageCode::PATH,
        Code::PATH,
    ];
    classified.sort_unstable();
    let attached = schema
        .get_nodes::<Newtype>()
        .filter(|(_, newtype)| {
            !newtype.ty().rules().is_empty() || !newtype.ty().validators().is_empty()
        })
        .map(|(path, _)| path)
        .collect::<Vec<_>>();
    assert_eq!(attached, classified);

    for (path, expected_scale) in [(Usd::PATH, 2), (E8s::PATH, 8), (E18s::PATH, 18)] {
        let newtype = schema
            .cast_node::<Newtype>(path)
            .expect("decimal built-in newtype should be registered");
        assert_eq!(newtype.item().scale(), Some(expected_scale), "{path}");
    }
    drop(schema);
}