http_tiny 1.1.0

A simple, dependency-less HTTP-header builder and parser
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

mod helpers;

use http_tiny::{ Header, error::ErrorKind };
use std::{ collections::BTreeMap, ops::Deref };


struct Test {
    raw: &'static [u8],
    method: &'static [u8],
    target: &'static [u8],
    fields: BTreeMap<Vec<u8>, Vec<u8>>
}
impl Test {
    fn test(self) {
        let header = Header::read(&mut helpers::source(self.raw)).expect("Failed to read header");
        assert_eq!(self.method, header.start_line().request_method());
        assert_eq!(self.target, header.start_line().request_target());
        assert_eq!(&self.fields, header.fields().deref());
    }
}
#[test]
fn test() {
    Test {
        raw: b"HEAD / HTTP/1.1\r\n\r\n",
        method: b"HEAD",
        target: b"/",
        fields: BTreeMap::new(),
    }.test();
    
    Test {
        raw: concat!(
            "POST /upl%C3%B6ad/form.php HTTP/1.1\r\n",
            "Host: www.heise.de\r\n",
            "User-Agent: http_tiny/0.3.0\r\n",
            "\r\n",
            "Test\r\nBODY\r\nolope"
        ).as_bytes(),
        method: b"POST",
        target: b"/upl%C3%B6ad/form.php",
        fields: helpers::map([
            ("host", "www.heise.de"),
            ("user-agent", "http_tiny/0.3.0")
        ])
    }.test();
}


#[derive(Debug)]
struct TestErr {
    data: &'static[u8],
    error: ErrorKind
}
impl TestErr {
    fn test(self) {
        let error = match Header::read(&mut helpers::source(self.data)) {
            Err(error) => error,
            Ok(header) => panic!("Unexpected `Ok` for header: {} ({:?})", String::from_utf8_lossy(self.data), header)
        };
        assert_eq!(&self.error, error.err(), "Unexpected error for header: {}", String::from_utf8_lossy(self.data));
    }
}
#[test]
fn test_err() {
    TestErr {
        data: b"HEAD / HTTP/1.1\r\n",
        error: ErrorKind::InvalidValue
    }.test();
    TestErr {
        data: b"\r\n\r\n",
        error: ErrorKind::InvalidValue
    }.test();
    TestErr {
        data: b"HEAD / \r\n\r\n",
        error: ErrorKind::InvalidValue
    }.test();
    
    TestErr {
        data: concat!(
            "HEAD / HTTP/1.1\r\n",
            "Host: www.heise.de\r\n",
            "User-Agent \r\n",
            "\r\n"
        ).as_bytes(),
        error: ErrorKind::InvalidValue
    }.test();
}