finchers 0.13.5

A combinator library for builidng asynchronous HTTP services
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

use finchers::endpoint::syntax;
use finchers::endpoint::IntoEndpointExt;
use finchers::endpoints::{body, query};
use finchers::test;

use http::Request;
use serde::de;
use serde::de::IntoDeserializer;
use std::fmt;
use std::iter::FromIterator;
use std::marker::PhantomData;

#[allow(missing_debug_implementations)]
struct CSVSeqVisitor<I, T> {
    _marker: PhantomData<fn() -> (I, T)>,
}

impl<'de, I, T> de::Visitor<'de> for CSVSeqVisitor<I, T>
where
    I: FromIterator<T>,
    T: de::Deserialize<'de>,
{
    type Value = I;

    fn expecting(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        f.write_str("a string")
    }

    fn visit_str<E>(self, s: &str) -> Result<Self::Value, E>
    where
        E: de::Error,
    {
        s.split(',')
            .map(|s| de::Deserialize::deserialize(s.into_deserializer()))
            .collect()
    }
}

fn from_csv<'de, D, I, T>(de: D) -> Result<I, D::Error>
where
    D: de::Deserializer<'de>,
    I: FromIterator<T>,
    T: de::Deserialize<'de>,
{
    de.deserialize_str(CSVSeqVisitor {
        _marker: PhantomData,
    })
}

#[derive(Debug, Deserialize, PartialEq)]
struct Param {
    query: String,
    count: Option<u32>,
    #[serde(deserialize_with = "from_csv", default)]
    tags: Vec<String>,
}

#[test]
fn test_or_strict() {
    let query_str = "query=rustlang&count=42&tags=tokio,hyper";

    let mut runner = test::runner({
        let query = syntax::verb::get().and(query::required::<Param>());
        let form = syntax::verb::post().and(body::urlencoded::<Param>());
        query.or_strict(form)
    });

    assert_matches!(
        runner.apply(format!("/?{}", query_str)),
        Ok(ref param) if *param == Param {
            query: "rustlang".into(),
            count: Some(42),
            tags: vec!["tokio".into(), "hyper".into()]
        }
    );

    assert_matches!(
        runner.apply(Request::post("/")
            .header("content-type", "application/x-www-form-urlencoded")
            .body(query_str)),
        Ok(ref param) if *param == Param {
            query: "rustlang".into(),
            count: Some(42),
            tags: vec!["tokio".into(), "hyper".into()]
        }
    );

    assert_matches!(
        runner.apply("/"),
        Err(ref e) if e.status_code().as_u16() == 400
    );

    assert_matches!(
        runner.apply(Request::delete(format!("/?{}", query_str))),
        Err(ref e) if e.status_code().as_u16() == 405
    );

    assert_matches!(
        runner.apply(Request::put("/")
            .header("content-type", "application/x-www-form-urlencoded")
            .body(query_str)),
        Err(ref e) if e.status_code().as_u16() == 405
    );
}