icydb-model-macros 0.301.0

Procedural macros for IcyDB application models
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

use darling::{FromMeta, ast::NestedMeta};
use quote::quote;

use super::{SourceRule, SourceRuleOperation, Type};

fn parse_rule(tokens: proc_macro2::TokenStream) -> Result<SourceRule, darling::Error> {
    let args = NestedMeta::parse_meta_list(tokens)?;
    SourceRule::from_list(args.as_slice())
}

fn parse_type(tokens: proc_macro2::TokenStream) -> Result<Type, darling::Error> {
    let args = NestedMeta::parse_meta_list(tokens)?;
    Type::from_list(args.as_slice())
}

#[test]
fn parses_each_closed_typed_rule_operation() {
    assert!(matches!(
        parse_rule(quote!(
            name = "length",
            length_range_inclusive(min = 1, max = 40)
        ))
        .expect("length range should parse")
        .operation,
        SourceRuleOperation::LengthRangeInclusive { .. }
    ));
    assert!(matches!(
        parse_rule(quote!(name = "step", multiple_of(divisor = 5)))
            .expect("multiple-of should parse")
            .operation,
        SourceRuleOperation::MultipleOf { .. }
    ));
    assert!(matches!(
        parse_rule(quote!(
            name = "maximum",
            numeric_maximum_inclusive(value = 100)
        ))
        .expect("numeric maximum should parse")
        .operation,
        SourceRuleOperation::NumericMaximumInclusive { .. }
    ));
    assert!(matches!(
        parse_rule(quote!(
            name = "minimum",
            numeric_minimum_inclusive(value = 0)
        ))
        .expect("numeric minimum should parse")
        .operation,
        SourceRuleOperation::NumericMinimumInclusive { .. }
    ));
    assert!(matches!(
        parse_rule(quote!(
            name = "range",
            numeric_range_inclusive(min = 0, max = 100)
        ))
        .expect("numeric range should parse")
        .operation,
        SourceRuleOperation::NumericRangeInclusive { .. }
    ));
}

#[test]
fn rejects_missing_multiple_and_malformed_typed_operations() {
    assert!(parse_rule(quote!(name = "missing")).is_err());
    assert!(parse_rule(quote!(name = "unknown", unsupported_operation(value = 0))).is_err());
    assert!(
        parse_rule(quote!(
            name = "multiple",
            numeric_minimum_inclusive(value = 0),
            numeric_maximum_inclusive(value = 100)
        ))
        .is_err()
    );
    assert!(
        parse_rule(quote!(
            name = "missing_operand",
            numeric_range_inclusive(min = 0)
        ))
        .is_err()
    );
    assert!(
        parse_rule(quote!(
            name = "wrong_operand",
            numeric_minimum_inclusive(min = 0)
        ))
        .is_err()
    );
    assert!(
        parse_rule(quote!(
            name = "repeated_operand",
            numeric_minimum_inclusive(value = 0, value = 1)
        ))
        .is_err()
    );
    assert!(
        parse_rule(quote!(
            name = "reversed",
            length_range_inclusive(min = 2, max = 1)
        ))
        .is_err()
    );
    assert!(parse_rule(quote!(name = "zero", multiple_of(divisor = 0))).is_err());
}

#[test]
fn rejects_invalid_and_duplicate_local_rule_names() {
    assert!(parse_rule(quote!(name = "", numeric_minimum_inclusive(value = 0))).is_err());
    assert!(
        parse_rule(quote!(
            name = "invalid name",
            numeric_minimum_inclusive(value = 0)
        ))
        .is_err()
    );
    assert!(
        parse_type(quote!(
            rule(name = "range", numeric_minimum_inclusive(value = 0)),
            rule(name = "range", numeric_maximum_inclusive(value = 100))
        ))
        .is_err()
    );
}