validatron 0.5.0

A data structure validation library designed for user input
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

use validatron::{Error, Result, Validate};

#[derive(Validate)]
struct Dummy(#[validatron(equal = true)] bool);

#[test]
fn smoke() {
    #[derive(Validate)]
    enum MyEnum {
        Unit,
        NewType(i32),
        Tuple(i32, i32),
        Struct { a: i32 },
    }

    assert!(MyEnum::Unit.validate().is_ok());
    assert!(MyEnum::NewType(42).validate().is_ok());
    assert!(MyEnum::Tuple(42, 101).validate().is_ok());
    assert!(MyEnum::Struct { a: 42 }.validate().is_ok());
}

#[test]
fn enum_custom_func() {
    #[derive(Validate)]
    #[validatron(function = "evaluate")]
    enum MyEnum {
        Good,
        Bad,
    }

    fn evaluate(x: &MyEnum) -> Result<()> {
        match x {
            MyEnum::Good => Ok(()),
            MyEnum::Bad => Err(Error::new("is bad")),
        }
    }

    assert!(MyEnum::Good.validate().is_ok());
    assert!(MyEnum::Bad.validate().is_err());
}

#[test]
fn enum_new_type() {
    #[derive(Validate)]
    enum MyEnum {
        WithAttr(#[validatron] Dummy),

        WithCustomAttr(#[validatron(equal = "32")] i64),
    }

    assert!(MyEnum::WithAttr(Dummy(true)).validate().is_ok());
    assert!(MyEnum::WithAttr(Dummy(false)).validate().is_err());

    assert!(MyEnum::WithCustomAttr(32).validate().is_ok());
    assert!(MyEnum::WithCustomAttr(1).validate().is_err());
}

#[test]
fn enum_tuple_type() {
    #[derive(Validate)]
    enum MyEnum {
        Recurse(#[validatron] Dummy, #[validatron] Dummy),

        Custom(
            #[validatron(equal = true)] bool,
            #[validatron(equal = true)] bool,
        ),

        Mixed(#[validatron] Dummy, #[validatron(equal = true)] bool),
    }

    assert!(MyEnum::Recurse(Dummy(true), Dummy(true)).validate().is_ok());
    assert!(MyEnum::Recurse(Dummy(true), Dummy(false))
        .validate()
        .is_err());

    assert!(MyEnum::Custom(true, true).validate().is_ok());
    assert!(MyEnum::Custom(true, false).validate().is_err());

    assert!(MyEnum::Mixed(Dummy(true), true).validate().is_ok());
    assert!(MyEnum::Mixed(Dummy(false), true).validate().is_err());
    assert!(MyEnum::Mixed(Dummy(true), false).validate().is_err());
}

#[test]
fn enum_struct_var() {
    #[derive(Validate)]
    enum MyEnum {
        #[validatron]
        Recurse {
            #[validatron]
            a: Dummy,
        },

        #[validatron]
        Custom {
            #[validatron(equal = true)]
            a: bool,
        },

        #[validatron]
        Mixed {
            #[validatron]
            a: Dummy,

            #[validatron(equal = true)]
            b: bool,
        },
    }

    assert!(MyEnum::Recurse { a: Dummy(true) }.validate().is_ok());
    assert!(MyEnum::Recurse { a: Dummy(false) }.validate().is_err());

    assert!(MyEnum::Custom { a: true }.validate().is_ok());
    assert!(MyEnum::Custom { a: false }.validate().is_err());

    assert!(MyEnum::Mixed {
        a: Dummy(true),
        b: true
    }
    .validate()
    .is_ok());
    assert!(MyEnum::Mixed {
        a: Dummy(false),
        b: true
    }
    .validate()
    .is_err());
    assert!(MyEnum::Mixed {
        a: Dummy(true),
        b: false
    }
    .validate()
    .is_err());
}