francoisgib_webserver 1.0.3

HTTP Webserver
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

#[cfg(test)]
mod tests {
    use std::str::FromStr;

    use smallvec::smallvec;

    use crate::{
        http::{
            headers::{Connection, ContentType, HeaderEntry, HttpHeader, HttpHeaderValue},
            methods::HttpMethod,
            requests::{BodyType, HttpRequest},
        },
        utils::buffer::Buffer,
    };

    #[test]
    fn test_process_headers_set_keep_alive() {
        let mut req = dummy_request();
        assert!(!req.keep_alive);

        req.process_headers();
        assert!(req.keep_alive);
    }

    #[test]
    fn test_process_headers_set_content_type() {
        let mut req = dummy_request();
        assert!(req.content_type.is_none());

        req.process_headers();
        assert_eq!(ContentType::TextPlain, req.content_type.unwrap());
    }

    #[test]
    fn test_process_headers_set_content_length() {
        let mut req = dummy_request();
        assert!(req.body_type.is_none());

        req.process_headers();
        assert_eq!(BodyType::Fixed(128), req.body_type.unwrap());
    }

    #[test]
    fn test_find_existing_header() {
        let mut req = dummy_request();
        let header = req.find_header(HttpHeader::ContentType);
        assert!(header.is_some());
    }

    #[test]
    fn test_find_nonexistent_header() {
        let mut req = dummy_request();
        let header = req.find_header(HttpHeader::Range);
        assert!(header.is_none());
    }

    #[test]
    fn test_request_to_string_contains_correct_data() {
        let req = dummy_request();
        let req_str = req.to_string();

        println!("{req_str}");

        assert!(req_str.starts_with("GET /test HTTP/1.1"));
        assert!(req_str.contains("Content-Length: 128"));
        assert!(req_str.contains("Content-Type: text/plain"));
        assert!(req_str.contains("Hello world!"));
    }

    fn dummy_request() -> HttpRequest {
        let headers = smallvec![
            HeaderEntry::new(
                HttpHeader::ContentLength,
                HttpHeaderValue::ContentLength(128)
            ),
            HeaderEntry::new(
                HttpHeader::ContentType,
                HttpHeaderValue::ContentType(ContentType::TextPlain)
            ),
            HeaderEntry::new(
                HttpHeader::Connection,
                HttpHeaderValue::Connection(Connection::KeepAlive)
            ),
        ];

        HttpRequest::new(
            HttpMethod::GET,
            "/test".into(),
            (1, 1),
            headers,
            Some(Buffer::from_str("Hello world!").unwrap()),
        )
    }
}