actix-multiresponse 0.2.0

actix-multiresponse intents to allow supporting multiple response/request data formats depending on the Content-Type and Accept headers
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

use actix_web::HttpRequest;

#[derive(Debug, PartialEq, Eq, Clone)]
pub enum ContentType {
    #[cfg(feature = "json")]
    Json,
    #[cfg(feature = "protobuf")]
    Protobuf,
    Other,
}

impl Default for ContentType {
    fn default() -> Self {
        cfg_if::cfg_if! {
            if #[cfg(feature = "json")] {
                Self::Json
            } else if #[cfg(feature = "protobuf")] {
                Self::Protobuf
            } else {
                Self::Other
            }
        }
    }
}

impl ContentType {
    #[inline]
    pub fn from_request_content_type(req: &HttpRequest) -> Self {
        Self::from_request_header(req, "Content-Type")
    }

    #[inline]
    pub fn from_request_accepts(req: &HttpRequest) -> Self {
        Self::from_request_header(req, "Accept")
    }

    #[inline]
    pub fn from_request_header<S: AsRef<str>>(req: &HttpRequest, name: S) -> Self {
        if let Some(header_value) = req.headers().get(name.as_ref()) {
            if let Ok(hv_str) = header_value.to_str() {
                let l = hv_str.to_lowercase();

                if l.starts_with("application/json") {
                    #[cfg(feature = "json")]
                    return Self::Json;
                    #[cfg(not(feature = "json"))]
                    return Self::Other;
                } else if l.starts_with("application/protobuf") {
                    #[cfg(feature = "protobuf")]
                    return Self::Protobuf;
                    #[cfg(not(feature = "protobuf"))]
                    return Self::Other;
                } else {
                    return Self::Other;
                }
            }
        }

        ContentType::Other
    }
}

#[cfg(test)]
mod test {
    use super::*;
    use actix_web::test::TestRequest;

    #[test]
    #[cfg(feature = "json")]
    fn test_json_plain() {
        let req = TestRequest::get()
            .insert_header(("Content-Type", "application/json"))
            .to_http_request();

        assert_eq!(
            ContentType::Json,
            ContentType::from_request_content_type(&req)
        )
    }

    #[test]
    #[cfg(feature = "json")]
    fn test_json_with_charset() {
        let req = TestRequest::get()
            .insert_header(("Content-Type", "application/json; charset=UTF-8"))
            .to_http_request();

        assert_eq!(
            ContentType::Json,
            ContentType::from_request_content_type(&req)
        )
    }

    #[test]
    #[cfg(feature = "protobuf")]
    fn test_protobuf() {
        let req = TestRequest::get()
            .insert_header(("Content-Type", "application/protobuf"))
            .to_http_request();

        assert_eq!(
            ContentType::Protobuf,
            ContentType::from_request_content_type(&req)
        )
    }

    #[test]
    #[cfg(feature = "protobuf")]
    fn test_protobuf_with_charset() {
        let req = TestRequest::get()
            .insert_header(("Content-Type", "application/protobuf; charset=UTF-8"))
            .to_http_request();

        assert_eq!(
            ContentType::Protobuf,
            ContentType::from_request_content_type(&req)
        )
    }

    #[test]
    fn test_other() {
        let req = TestRequest::get()
            .insert_header(("Content-Type", "foo/bar"))
            .to_http_request();

        assert_eq!(
            ContentType::Other,
            ContentType::from_request_content_type(&req)
        );
    }
}