validatable 0.1.0

Define validated data types once and share them between the frontend and backend of isomorphic Rust web applications, with plain, input, and form representations
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
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
496
497
498
499
500
501
502
503
504
505
506
507
508
509
510
511
512
513
514
515
516
517
518
519
use std::cmp::Ordering;
use std::collections::hash_map::DefaultHasher;
use std::hash::{Hash, Hasher};

use validatable::{Format::*, Message::*, *};

use super::util::*;

macro_rules! validate_string_eq {
    ($i: expr, $e: expr) => {
        let r: Result<T, Message> = ValidatedValue::from_input(&$i.to_owned());
        assert_eq!(r.map(|v| v.into_raw()), $e);
    };
    ($i: expr, $e1: expr, $e2: expr) => {
        let r: Result<T, Message> = ValidatedValue::from_input(&$i.to_owned());
        let r = r.map(|v| v.into_raw());
        if !(r == $e1 || r == $e2) {
            assert_eq!(r, $e1);
            assert_eq!(r, $e2);
        }
    };
}

#[test]
fn logic() {
    {
        type T = Validated<String, Or<LengthMin<5>, LengthMax<2>>>;
        validate_string_eq!("", Ok(s!("")));
        validate_string_eq!("a", Ok(s!("a")));
        validate_string_eq!("aa", Ok(s!("aa")));
        validate_string_eq!("aaa", Err(LengthExceedMin(s!("5"))));
        validate_string_eq!("aaaa", Err(LengthExceedMin(s!("5"))));
        validate_string_eq!("aaaaa", Ok(s!("aaaaa")));
    }
    {
        type T = Validated<String, Or<LengthMax<2>, LengthMin<5>>>;
        validate_string_eq!("", Ok(s!("")));
        validate_string_eq!("a", Ok(s!("a")));
        validate_string_eq!("aa", Ok(s!("aa")));
        validate_string_eq!("aaa", Err(LengthExceedMax(s!("2"))));
        validate_string_eq!("aaaa", Err(LengthExceedMax(s!("2"))));
        validate_string_eq!("aaaaa", Ok(s!("aaaaa")));
    }
    {
        type T = Validated<String, Chain<Trim, Or<LengthMax<2>, LengthMin<5>>>>;
        validate_string_eq!(" ", Ok(s!("")));
        validate_string_eq!(" a", Ok(s!("a")));
        validate_string_eq!(" aa", Ok(s!("aa")));
        validate_string_eq!(" aaa", Err(LengthExceedMax(s!("2"))));
        validate_string_eq!(" aaaa", Err(LengthExceedMax(s!("2"))));
        validate_string_eq!(" aaaaa", Ok(s!("aaaaa")));
    }
    {
        type T = Validated<String, Chain<Or<LengthMax<2>, LengthMin<5>>, Trim>>;
        validate_string_eq!(" ", Ok(s!("")));
        validate_string_eq!(" a", Ok(s!("a")));
        validate_string_eq!(" aa", Err(LengthExceedMax(s!("2"))));
        validate_string_eq!(" aaa", Err(LengthExceedMax(s!("2"))));
        validate_string_eq!(" aaaa", Ok(s!("aaaa")));
        validate_string_eq!(" aaaaa", Ok(s!("aaaaa")));
    }
    {
        type T = Validated<String, And<LengthMin<1>, LengthMax<5>>>;
        validate_string_eq!("", Err(Empty));
        validate_string_eq!("a", Ok(s!("a")));
        validate_string_eq!("aaaaa", Ok(s!("aaaaa")));
        validate_string_eq!("aaaaaa", Err(LengthExceedMax(s!("5"))));
    }
    {
        type T = Validated<String, Not<LengthMin<3>>>;
        validate_string_eq!("", Ok(s!("")));
        validate_string_eq!("aa", Ok(s!("aa")));
        validate_string_eq!("aaa", Err(ContentProblem));
    }
    {
        type T = Validated<String, Or<Trim, True>>;
        validate_string_eq!(" a ", Ok(s!("a")));
    }
}

#[test]
fn from_input_owned() {
    {
        type T = Validated<String, Chain<Trim, LengthRange<1, 8>>>;
        let v: T = ValidatedValue::from_input_owned(s!(" Ada ")).unwrap();
        assert_eq!(v.into_raw(), s!("Ada"));
        let r: Result<T, Message> = ValidatedValue::from_input_owned(s!("   "));
        assert_eq!(r.map(|v| v.into_raw()), Err(Empty));
    }
    {
        struct NotClone(String);
        impl Parsable<NotClone> for String {
            fn parse(i: NotClone) -> Result<Self, Message> {
                Ok(i.0)
            }
        }
        type T = ValidatedValue<String, NotClone, True, LengthMax<3>>;
        let v: T = ValidatedValue::from_input_owned(NotClone(s!("abc"))).unwrap();
        assert_eq!(v.into_raw(), s!("abc"));
    }
}

#[test]
fn or_clone_count() {
    use std::cell::Cell;
    use std::rc::Rc;

    struct Counted(Rc<Cell<usize>>);
    impl Clone for Counted {
        fn clone(&self) -> Self {
            self.0.set(self.0.get() + 1);
            Counted(Rc::clone(&self.0))
        }
    }

    let count = Rc::new(Cell::new(0));
    assert!(<Or<True, True> as Validator<Counted>>::validate(Counted(Rc::clone(&count))).is_ok());
    assert_eq!(count.get(), 1);

    let count = Rc::new(Cell::new(0));
    assert!(<Or<False, True> as Validator<Counted>>::validate(Counted(Rc::clone(&count))).is_ok());
    assert_eq!(count.get(), 2);
}

#[test]
fn integer() {
    macro_rules! signed_integer_test {
        ($t: ty) => {{
            type T = Validated<$t, True, SignedValueMin<-10>>;
            validate_string_eq!("-11", Err(ValueExceedMin(s!("-10"))));
            validate_string_eq!("-10", Ok(-10));
            validate_string_eq!("0", Ok(0));
            validate_string_eq!("-0", Ok(0));
            validate_string_eq!("5", Ok(5));
        }
        {
            type T = Validated<$t, True, SignedValueMax<-10>>;
            validate_string_eq!("-10", Ok(-10));
            validate_string_eq!("9", Err(ValueExceedMax(s!("-10"))));
            validate_string_eq!("0", Err(ValueExceedMax(s!("-10"))));
            validate_string_eq!("5", Err(ValueExceedMax(s!("-10"))));
        }};
    }

    signed_integer_test!(i8);
    signed_integer_test!(i16);
    signed_integer_test!(i32);
    signed_integer_test!(i64);

    macro_rules! unsigned_integer_test {
        ($t: ty) => {{
            type T = Validated<$t, True, UnsignedValueMin<10>>;
            validate_string_eq!("-11", Err(ValueExceedMin(s!("0"))));
            validate_string_eq!("0", Err(ValueExceedMin(s!("10"))));
            validate_string_eq!("-0", Err(ValueExceedMin(s!("10"))));
            validate_string_eq!("5", Err(ValueExceedMin(s!("10"))));
            validate_string_eq!("10", Ok(10));
            validate_string_eq!("11", Ok(11));
        }
        {
            type T = Validated<$t, True, UnsignedValueMax<10>>;
            validate_string_eq!("-11", Err(ValueExceedMin(s!("0"))));
            validate_string_eq!("0", Ok(0));
            validate_string_eq!("-0", Ok(0));
            validate_string_eq!("5", Ok(5));
            validate_string_eq!("10", Ok(10));
            validate_string_eq!("11", Err(ValueExceedMax(s!("10"))));
        }};
    }

    unsigned_integer_test!(u8);
    unsigned_integer_test!(u16);
    unsigned_integer_test!(u32);
    unsigned_integer_test!(u64);

    macro_rules! signed_with_unsigned_validator_test {
        ($t: ty) => {{
            type T = Validated<$t, True, UnsignedValueMax<10>>;
            validate_string_eq!("-11", Err(ValueExceedMin(s!("0"))));
            validate_string_eq!("-1", Err(ValueExceedMin(s!("0"))));
            validate_string_eq!("0", Ok(0));
            validate_string_eq!("-0", Ok(0));
            validate_string_eq!("10", Ok(10));
            validate_string_eq!("11", Err(ValueExceedMax(s!("10"))));
        }};
    }

    signed_with_unsigned_validator_test!(i8);
    signed_with_unsigned_validator_test!(i16);
    signed_with_unsigned_validator_test!(i32);
    signed_with_unsigned_validator_test!(i64);

    macro_rules! parse_test {
        ($t: ty) => {{
            type T = Validated<$t, True>;
            validate_string_eq!("0", Ok(0));
            validate_string_eq!("-0", Ok(0));
            validate_string_eq!("123", Ok(123));
            validate_string_eq!("", Err(Empty));
            validate_string_eq!(
                "a",
                Err(BadFormat(SignedInteger)),
                Err(BadFormat(UnsignedInteger))
            );
            validate_string_eq!("   123 ", Ok(123));
            validate_string_eq!("\n\t 45 ", Ok(45));
            validate_string_eq!("   ", Err(Empty));
            validate_string_eq!(
                " 1 2 ",
                Err(BadFormat(SignedInteger)),
                Err(BadFormat(UnsignedInteger))
            );
            validate_string_eq!(
                format!("{}9", <$t>::MAX),
                Err(ValueExceedMax(<$t>::MAX.to_string()))
            );
            validate_string_eq!(
                "-99999999999999999999999999999999999999",
                Err(ValueExceedMin(<$t>::MIN.to_string()))
            );
        }
        {
            type T = Validated<$t, Trim>;
            validate_string_eq!("0", Ok(0));
            validate_string_eq!(" -0 ", Ok(0));
            validate_string_eq!("123", Ok(123));
            validate_string_eq!("", Err(Empty));
            validate_string_eq!(
                "a",
                Err(BadFormat(SignedInteger)),
                Err(BadFormat(UnsignedInteger))
            );
            validate_string_eq!("   123 ", Ok(123));
            validate_string_eq!("\n\t 45 ", Ok(45));
        }};
    }

    parse_test!(i8);
    parse_test!(i16);
    parse_test!(i32);
    parse_test!(i64);
    parse_test!(u8);
    parse_test!(u16);
    parse_test!(u32);
    parse_test!(u64);
}

#[test]
fn float() {
    macro_rules! float_test {
        ($t: ty) => {{
            type T = Validated<$t, True, FloatValueMinX1000<1_500>>;
            validate_string_eq!("-1", Err(ValueExceedMin(s!("1.5"))));
            validate_string_eq!("0.0", Err(ValueExceedMin(s!("1.5"))));
            validate_string_eq!("1.50", Ok(1.5));
            validate_string_eq!("1.6", Ok(1.6));
        }
        {
            type T = Validated<$t, True, FloatValueMaxX1000<1_500>>;
            validate_string_eq!("-1", Ok(-1.0));
            validate_string_eq!("0.0", Ok(0.0));
            validate_string_eq!("1.50", Ok(1.5));
            validate_string_eq!("1.6", Err(ValueExceedMax(s!("1.5"))));
        }
        {
            type T = Validated<$t, True, FloatValueMaxX1000<100>>;
            assert_eq!(T::from_raw(0.1).map(|v| v.into_raw()), Ok(0.1));
            validate_string_eq!("0.1", Ok(0.1));
            validate_string_eq!("0.11", Err(ValueExceedMax(s!("0.1"))));
        }
        {
            type T = Validated<$t, True, FloatValueMinX1000<100>>;
            assert_eq!(T::from_raw(0.1).map(|v| v.into_raw()), Ok(0.1));
            validate_string_eq!("0.1", Ok(0.1));
            validate_string_eq!("0.09", Err(ValueExceedMin(s!("0.1"))));
        }
        {
            type T = Validated<$t, True>;
            validate_string_eq!("NaN", Err(BadFormat(Float)));
            validate_string_eq!("nan", Err(BadFormat(Float)));
            validate_string_eq!("inf", Err(ValueExceedMax(<$t>::MAX.to_string())));
            validate_string_eq!("-inf", Err(ValueExceedMin(<$t>::MIN.to_string())));
            validate_string_eq!("infinity", Err(ValueExceedMax(<$t>::MAX.to_string())));
            validate_string_eq!("1e999", Err(ValueExceedMax(<$t>::MAX.to_string())));
            validate_string_eq!("-1e999", Err(ValueExceedMin(<$t>::MIN.to_string())));
            validate_string_eq!("1.5", Ok(1.5));
            validate_string_eq!(" 1.5\t ", Ok(1.5));
            validate_string_eq!("   ", Err(Empty));
        }
        {
            type T = Validated<$t, True, FloatValueRangeX1000<0, 100_000>>;
            assert_eq!(
                T::from_raw(<$t>::NAN).map(|v| v.into_raw()),
                Err(BadFormat(Float))
            );
            assert_eq!(
                T::from_raw(<$t>::INFINITY).map(|v| v.into_raw()),
                Err(ValueExceedMax(s!("100")))
            );
            assert_eq!(
                T::from_raw(<$t>::NEG_INFINITY).map(|v| v.into_raw()),
                Err(ValueExceedMin(s!("0")))
            );
            validate_string_eq!("NaN", Err(BadFormat(Float)));
        }
        {
            type TMin = Validated<$t, True, FloatValueMinX1000<0>>;
            assert_eq!(
                TMin::from_raw(<$t>::INFINITY).map(|v| v.into_raw()),
                Ok(<$t>::INFINITY)
            );
            type TMax = Validated<$t, True, FloatValueMaxX1000<0>>;
            assert_eq!(
                TMax::from_raw(<$t>::NEG_INFINITY).map(|v| v.into_raw()),
                Ok(<$t>::NEG_INFINITY)
            );
        }
        {
            type T = Validated<$t, True, FloatValueMinX1000<16_777_219>>;
            assert!(T::from_raw(16777.219).is_ok());
        }};
    }
    float_test!(f32);
    float_test!(f64);
}

#[test]
fn string() {
    {
        type T = Validated<String, LengthMin<3>>;
        validate_string_eq!("", Err(Empty));
        validate_string_eq!("a", Err(LengthExceedMin(s!("3"))));
        validate_string_eq!("abc", Ok(s!("abc")));
        validate_string_eq!("abcd", Ok(s!("abcd")));
    }
    {
        type T = Validated<String, LengthMax<3>>;
        validate_string_eq!("", Ok(s!("")));
        validate_string_eq!("a", Ok(s!("a")));
        validate_string_eq!("abc", Ok(s!("abc")));
        validate_string_eq!("abcd", Err(LengthExceedMax(s!("3"))));
    }
    {
        type T = Validated<String, LengthRange<1, 3>>;
        validate_string_eq!("", Err(Empty));
        validate_string_eq!("a", Ok(s!("a")));
        validate_string_eq!("abc", Ok(s!("abc")));
        validate_string_eq!("abcd", Err(LengthExceedMax(s!("3"))));
    }
    {
        type T = Validated<String, LengthRange<0, 3>>;
        validate_string_eq!("", Ok(s!("")));
        validate_string_eq!("a", Ok(s!("a")));
        validate_string_eq!("abc", Ok(s!("abc")));
        validate_string_eq!("abcd", Err(LengthExceedMax(s!("3"))));
    }
    {
        type T = Validated<String, LengthMax<3>>;
        let v: T = ValidatedValue::from_input(&s!("abc")).unwrap();
        assert_eq!(v.len(), 3);
        assert_eq!(v.chars().next(), Some('a'));
    }
}

#[test]
fn string_char_class() {
    {
        type T = Validated<String, AllChars<CharClassAscii>>;
        validate_string_eq!("", Ok(s!("")));
        validate_string_eq!("a", Ok(s!("a")));
        validate_string_eq!("aあb, ", Err(InvalidChars(cs!(" あ"))));
    }
    {
        type T = Validated<
            String,
            AllChars<Or<CharClassAsciiPunctuation, CharClassDigit, CharClassLowercase>>,
        >;
        validate_string_eq!("", Ok(s!("")));
        validate_string_eq!("ABCa123", Err(InvalidChars(cs!("ABC"))));
        validate_string_eq!("-!a123", Ok(s!("-!a123")));
    }
    {
        type T = Validated<String, AllChars<And<CharClassAsciiHexdigit, CharClassAsciiUppercase>>>;
        validate_string_eq!("", Ok(s!("")));
        validate_string_eq!("ABC123", Err(InvalidChars(cs!("123"))));
        validate_string_eq!("ffAAZ", Err(InvalidChars(cs!("Zf"))));
        validate_string_eq!("ABFF", Ok(s!("ABFF")));
    }
    {
        type T = Validated<String, Chain<Trim, AllChars<CharClassJust<'J'>>>>;
        validate_string_eq!("", Ok(s!("")));
        validate_string_eq!(" JJJ ", Ok(s!("JJJ")));
        validate_string_eq!("AJJA", Err(InvalidChars(cs!("A"))));
    }
    {
        type T = Validated<String, Chain<Trim, AllChars<Not<CharClassJust<'J'>>>>>;
        validate_string_eq!("", Ok(s!("")));
        validate_string_eq!(" JJJ ", Err(InvalidChars(cs!("J"))));
        validate_string_eq!(" a b c ", Ok(s!("a b c")));
    }
    {
        type T = Validated<String, RemoveChars<CharClassWhitespace>>;
        validate_string_eq!("", Ok(s!("")));
        validate_string_eq!(" A  J Cc ", Ok(s!("AJCc")));
        validate_string_eq!("abc ", Ok(s!("abc")));
    }
    {
        type T = Validated<String, AllChars<CharClassAsciiDigit>>;
        validate_string_eq!(
            "0123456789abcdefghijklmnopqrstuvwxyz",
            Err(InvalidChars(cs!("abcdefghij")))
        );
    }
}

#[test]
fn non_empty_string() {
    {
        type T = Validated<NonEmptyString, AllChars<CharClassAsciiDigit>>;
        validate_string_eq!("123", Ok(ns!("123")));
        validate_string_eq!("", Err(Empty));
        validate_string_eq!("12a", Err(InvalidChars(cs!("a"))));
    }
    {
        type T = Validated<NonEmptyString, Chain<Trim, AllChars<CharClassAsciiAlphabetic>>>;
        validate_string_eq!(" abc ", Ok(ns!("abc")));
        validate_string_eq!("   ", Err(Empty));
    }
    {
        type T = Validated<NonEmptyString, Trim>;
        let v: T = ValidatedValue::from_input(&s!(" x ")).unwrap();
        assert_eq!(NonEmptyString::from(v.clone()), ns!("x"));
        assert_eq!(<T as ValidatableValue<String>>::into_input(v), s!("x"));
    }
    #[cfg(feature = "serde")]
    {
        type T = Validated<NonEmptyString, AllChars<CharClassAsciiDigit>>;
        let v: T = ValidatedValue::from_input(&s!("123")).unwrap();
        assert_eq!(serde_json::to_string(&v).unwrap(), r#""123""#);
        assert_eq!(serde_json::from_str::<T>(r#""123""#).unwrap(), v);
        assert!(serde_json::from_str::<T>(r#""""#).is_err());
    }
}

#[test]
fn implementations() {
    macro_rules! from_test {
        ($t: ty, $r: expr, $d: expr) => {{
            type T = Validated<$t, True, True>;
            let r: $t = $r;
            let v: T = T::from_raw(r.clone()).unwrap();
            let d: T = T::from_raw($d).unwrap();
            assert_eq!(<$t as From<T>>::from(v.clone()), r);
            assert_eq!(v.as_ref(), &r);
            assert_eq!(&*v, &r);
            assert_eq!(v, v);
            assert_ne!(v, d);
            assert_eq!(v.partial_cmp(&v), Some(Ordering::Equal));
            assert_eq!(v.partial_cmp(&d), Some(Ordering::Less));
            assert_eq!(v.cmp(&v), Ordering::Equal);
            assert_eq!(v.cmp(&d), Ordering::Less);
            assert_eq!(calculate_hash(&v), calculate_hash(&v));
            assert_ne!(calculate_hash(&v), calculate_hash(&d));
        }};
    }

    fn calculate_hash<T: Hash>(t: &T) -> u64 {
        let mut s = DefaultHasher::new();
        t.hash(&mut s);
        s.finish()
    }

    from_test!(i8, 123, 124);
    from_test!(i16, 234, 235);
    from_test!(i32, -10, -9);
    from_test!(i64, -20, 21);
    from_test!(u8, 0x5, 0x6);
    from_test!(u16, 1_000, 1_001);
    from_test!(u32, 123, 124);
    from_test!(u64, 123, 124);
    from_test!(String, s!("あいう"), s!("あいうえ"));
    from_test!(bool, false, true);
}

#[test]
fn fmt() {
    macro_rules! fmt_test {
        ($t: ty, $v: expr) => {{
            type T = Validated<$t, True, True>;
            let r = $v;
            let v: T = T::from_raw($v).unwrap();
            assert_eq!(format!("{} {:?}", v, v), format!("{} {:?}", r, r));
        }};
    }
    fmt_test!(i8, 123);
    fmt_test!(i16, 234);
    fmt_test!(i32, -10);
    fmt_test!(i64, -20);
    fmt_test!(u8, 0x5);
    fmt_test!(u16, 1_000);
    fmt_test!(u32, 123);
    fmt_test!(u64, 123);
    fmt_test!(String, s!("あいう"));
    fmt_test!(bool, true);
}

#[test]
#[cfg(feature = "serde")]
fn serde() {
    let b: Validated<String, True, LengthRange<2, 10>> = vs!("fooあいうえ");
    assert_eq!(serde_json::to_string(&b).unwrap(), r#""fooあいうえ""#);
    assert_eq!(
        serde_json::from_str::<Validated<String, True, LengthRange<2, 10>>>(r#""fooあいうえ""#)
            .unwrap(),
        b
    );
    assert!(serde_json::from_str::<Validated<String, True, LengthRange<2, 10>>>(r#""f""#).is_ok()); // allow valid deserialize
    assert!(serde_json::from_str::<Validated<String, True, LengthRange<2, 10>>>(r#"aaa"#).is_err());
}