httpal 0.1.0

Work in progress: HTTP client for Rust
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

use std::collections::HashMap;
use std::io::{empty, Read, BufReader};

use parser;
use http::{Method, Version, Header, Error};

pub struct Request {
    pub method: Method,
    pub path: String,
    pub version: Version,
    pub headers: HashMap<Header, String>,
    pub body: Box<Read>,
}

impl Request {
    pub fn new<P: Into<String>>(method: Method, path: P) -> Self {
        Request {
            method: method,
            path: path.into(),
            version: Version::Http11,
            headers: HashMap::new(),
            body: Box::new(empty()),
        }
    }

    pub fn from_reader(reader: &mut Read) -> Result<Self, Error> {
        let mut reader = BufReader::new(reader);

        let (method, path, version) = try!(parser::request_line::parse(&mut reader));
        let headers = try!(parser::headers::parse(&mut reader));

        let request = Request {
            method: method,
            path: path,
            version: version,
            headers: headers,
            body: Box::new(empty()),
        };

        Ok(request)
    }

    pub fn set_header<F: Into<Header>, V: Into<String>>(&mut self, field: F, value: V) -> &mut Self {
        self.headers.insert(field.into(), value.into());
        self
    }
}

#[cfg(test)]
mod tests {
    use super::Request;
    use http::{Method, Version, Header};

    #[test]
    fn test_new_request() {
        let req = Request::new(Method::Get, "/");

        assert_eq!(Method::Get, req.method);
        assert_eq!("/".to_owned(), req.path);
        assert_eq!(Version::Http11, req.version);
    }

    #[test]
    fn test_set_header_from_str_to_str() {
        let mut req = Request::new(Method::Get, "/");
        req.set_header("content-type", "application/json");

        let value = req.headers.get(&"content-type".into());
        assert_eq!(Some(&"application/json".to_owned()), value);
    }

    #[test]
    fn test_set_header_from_header_to_str() {
        let mut req = Request::new(Method::Get, "/");
        req.set_header(Header::ContentType, "application/json");

        let value = req.headers.get(&"content-type".into());
        assert_eq!(Some(&"application/json".to_owned()), value);
    }

    #[test]
    fn test_set_header_from_header_to_string() {
        let mut req = Request::new(Method::Get, "/");
        req.set_header(Header::ContentType, "application/json".to_owned());

        let value = req.headers.get(&"content-type".into());
        assert_eq!(Some(&"application/json".to_owned()), value);
    }
}