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
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113

#[cfg(test)]
mod tests {
    use tokio::io::BufReader;

    use crate::http::{
        errors::HttpError,
        headers::{ContentType, HttpHeader, HttpHeaderValue},
        methods::HttpMethod,
        requests::parser::{parse_headers, parse_http_version, parse_method, parse_uri},
    };

    #[test]
    fn test_parse_uri() {
        assert_eq!(Ok(("/uri", "")), parse_uri("/uri "))
    }

    #[test]
    fn test_parse_uri_without_space_at_the_end() {
        let res = parse_uri("/uri");
        assert!(matches!(res, Err(HttpError::BadRequest)));
    }

    #[test]
    fn test_parse_http_version() {
        let res = parse_http_version("HTTP/1\r\n");
        println!("{res:?}");
        assert!(matches!(res, Ok((1, 0))));
        let res = parse_http_version("HTTP/1.1\r\n");
        assert!(matches!(res, Ok((1, 1))));
    }

    #[test]
    fn test_parse_http_version_not_an_http_version() {
        let res = parse_http_version("NOT_HTTP_VERSION/1.1\r\n");
        assert!(matches!(res, Err(HttpError::BadRequest)));
    }

    #[test]
    fn test_parse_method() {
        assert_eq!(Ok((HttpMethod::GET, "")), parse_method("GET "));
        assert_eq!(Ok((HttpMethod::POST, "")), parse_method("POST "));
        assert_eq!(Ok((HttpMethod::DELETE, "")), parse_method("DELETE "));
        assert_eq!(Ok((HttpMethod::PUT, "")), parse_method("PUT "));
        assert_eq!(Ok((HttpMethod::PATCH, "")), parse_method("PATCH "));
    }

    #[test]
    fn test_parse_method_unknown_method() {
        let res = parse_method("UNKNOWN");
        assert!(matches!(res, Err(HttpError::BadRequest)));
    }

    #[test]
    fn test_parse_method_method_lowercase() {
        let res = parse_method("get");
        assert!(matches!(res, Err(HttpError::BadRequest)));

        let res = parse_method("post");
        assert!(matches!(res, Err(HttpError::BadRequest)));
    }

    #[tokio::test]
    async fn test_parse_single_valid_header() {
        let data = b"Content-Type: text/html\r\n\r\n";
        let mut reader = BufReader::new(&data[..]);

        let headers = parse_headers(&mut reader).await.unwrap();

        assert_eq!(headers.len(), 1);
        assert_eq!(headers[0].name, HttpHeader::ContentType);
        assert_eq!(
            headers[0].value,
            HttpHeaderValue::ContentType(ContentType::TextHtml)
        );
    }

    #[tokio::test]
    async fn test_parse_multiple_valid_headers() {
        let data = b"Content-Type: text/html\r\nContent-Length: 123\r\n\r\n";
        let mut reader = BufReader::new(&data[..]);

        let headers = parse_headers(&mut reader).await.unwrap();

        assert_eq!(headers.len(), 2);
        assert_eq!(headers[0].name, HttpHeader::ContentType);
        assert_eq!(headers[1].name, HttpHeader::ContentLength);
    }

    #[tokio::test]
    async fn test_parse_headers_with_unexpected_eof() {
        let data = b"Content-Type: text/html\r\nContent-Length: 123";
        let mut reader = BufReader::new(&data[..]);
        let res = parse_headers(&mut reader).await;

        assert!(res.is_err());
        assert_eq!(res.unwrap_err(), "Missing end line in header");

        let data = b"Content-Type: text/html\r\nContent-Length: 123\r\n";
        let mut reader = BufReader::new(&data[..]);
        let res = parse_headers(&mut reader).await;

        assert!(res.is_err());
        assert_eq!(res.unwrap_err(), "Unexpected EOF");
    }

    #[tokio::test]
    async fn test_parse_headers_with_invalid_header() {
        let data = b"Invalid-Header\r\n\r\n";
        let mut reader = BufReader::new(&data[..]);
        let headers = parse_headers(&mut reader).await.unwrap();
        assert!(headers.is_empty());
    }
}