serde_valid 2.0.1

JSON Schema based validation tool using serde.
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

#[cfg(feature = "fluent")]
mod tests {
    use fluent::{FluentBundle, FluentResource};
    use serde::Deserialize;
    use serde_json::json;
    use serde_valid::{fluent::Localize, Validate};
    use unic_langid::LanguageIdentifier;

    fn get_bundle(source: impl Into<String>) -> FluentBundle<FluentResource> {
        let res = FluentResource::try_new(source.into()).expect("Failed to parse an FTL string.");

        let langid_en: LanguageIdentifier = "en-US".parse().expect("Parsing failed");
        let mut bundle = FluentBundle::new(vec![langid_en]);
        bundle.add_resource(res).unwrap();

        bundle
    }

    #[test]
    fn fluent_error() {
        #[derive(Debug, Deserialize, Validate)]
        struct Test {
            #[validate(minimum = 5, fluent("hello-world"))]
            a: u32,
            #[validate(maximum = 10, fluent("intro", name = "taro"))]
            b: u32,
        }

        let test = Test { a: 1, b: 11 };
        let a = test.validate().unwrap_err().localize(&get_bundle(
            ["hello-world = Hello, world!", "intro = Welcome, { $name }."].join("\n"),
        ));

        assert_eq!(
            a.to_string(),
            json!({
                "errors": [],
                "properties": {
                    "a": {
                        "errors": [
                            "Hello, world!"
                        ]
                    },
                    "b": {
                        "errors": [
                            "Welcome, \u{2068}taro\u{2069}."
                        ]
                    }
                }
            })
            .to_string()
        );
    }
}