actix-web-validator 7.0.0

Validation mechanism for actix-web
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

use actix_web_validator::{error::DeserializeErrors, Error};
use serde::{Deserialize, Serialize};
use validator::{Validate, ValidationErrorsKind};

#[derive(Deserialize)]
#[allow(dead_code)]
struct Query {
    test: i32,
    value: i32,
}

#[test]
fn test_serde_urlencoded_error_transformation() {
    let error = serde_urlencoded::from_str::<Query>("test=42&value=[").map_err(Error::from);
    assert!(matches!(
        error,
        Err(Error::Deserialize(DeserializeErrors::DeserializeQuery(_)))
    ));
}

#[test]
fn test_serde_json_error_transformation() {
    let error =
        serde_json::from_str::<Query>("{\"test\": 42, \"value\": null}").map_err(Error::from);
    assert!(matches!(
        error,
        Err(Error::Deserialize(DeserializeErrors::DeserializeJson(_)))
    ));
}

#[derive(Serialize, Deserialize, Validate, Debug)]
#[serde(rename_all = "camelCase")]
pub struct SearchParams {
    #[validate(nested)]
    page_params: PageParams,
    #[validate(url)]
    redirect_results: String,
}

#[derive(Serialize, Deserialize, Validate, Debug)]
#[serde(rename_all = "camelCase")]
pub struct PageParams {
    #[validate(range(min = 1))]
    page: u16,
    #[validate(range(min = 1, max = 100))]
    page_size: u8,
}

macro_rules! cast {
    ($target: expr, $pat: path) => {{
        if let $pat(a) = $target {
            a
        } else {
            panic!("mismatch variant when cast to {}", stringify!($pat));
        }
    }};
}

#[test]
fn test_flatten_error() {
    let params = serde_json::from_str::<SearchParams>(
        "{\"pageParams\":{\"page\":0,\"pageSize\":101},\"redirectResults\":\"invalid url\"}",
    )
    .map_err(crate::Error::from)
    .expect("invalid json");
    let validation = params.validate().unwrap_err();
    let errors = actix_web_validator::error::flatten_errors(&validation);
    assert_eq!(
        (
            &1u16,
            &cast!(
                &validation.errors().get("page_params").unwrap(),
                ValidationErrorsKind::Struct
            )
            .field_errors()
            .get("page_size")
            .unwrap()[0]
        ),
        errors
            .iter()
            .find(|(_, field, _)| field == "page_params.page_size")
            .map(|(indent, _, e)| (indent, *e))
            .unwrap()
    );
    assert_eq!(
        (
            &0u16,
            &validation.field_errors().get("redirect_results").unwrap()[0]
        ),
        errors
            .iter()
            .find(|(_, field, _)| field == "redirect_results")
            .map(|(indent, _, e)| (indent, *e))
            .unwrap()
    );
}