fn test_into_request()

in src/request.rs [444:557]
92 lines of code
1 McCabe index (conditional complexity)

    fn test_into_request() {
        let expected_request = Request {
            request_line: RequestLine {
                http_version: Version::Http10,
                method: Method::Get,
                uri: Uri::new("http://localhost/home"),
            },
            body: None,
            files: Vec::new(),
            headers: Headers::default(),
        };
        let request_bytes = b"GET http://localhost/home HTTP/1.0\r\n\
                                     Last-Modified: Tue, 15 Nov 1994 12:45:26 GMT\r\n\r\n";
        let request = Request::try_from(request_bytes, None).unwrap();
        assert_eq!(request, expected_request);
        assert_eq!(request.uri(), &Uri::new("http://localhost/home"));
        assert_eq!(request.http_version(), Version::Http10);
        assert!(request.body.is_none());

        // Test for invalid Request (missing CR LF).
        let request_bytes = b"GET / HTTP/1.1";
        assert_eq!(
            Request::try_from(request_bytes, None).unwrap_err(),
            RequestError::InvalidRequest
        );

        // Test for invalid Request (length is less than minimum).
        let request_bytes = b"GET";
        assert_eq!(
            Request::try_from(request_bytes, None).unwrap_err(),
            RequestError::InvalidRequest
        );

        // Test for invalid Request (`GET` requests should have no body).
        let request_bytes = b"GET /machine-config HTTP/1.1\r\n\
                                        Content-Length: 13\r\n\
                                        Content-Type: application/json\r\n\r\nwhatever body";
        assert_eq!(
            Request::try_from(request_bytes, None).unwrap_err(),
            RequestError::InvalidRequest
        );

        // Test for request larger than maximum len provided.
        let request_bytes = b"GET http://localhost/home HTTP/1.0\r\n\
                                     Last-Modified: Tue, 15 Nov 1994 12:45:26 GMT\r\n\r\n";
        assert_eq!(
            Request::try_from(request_bytes, Some(20)).unwrap_err(),
            RequestError::InvalidRequest
        );

        // Test request smaller than maximum len provided is ok.
        let request_bytes = b"GET http://localhost/home HTTP/1.0\r\n\
                                     Last-Modified: Tue, 15 Nov 1994 12:45:26 GMT\r\n\r\n";
        assert!(Request::try_from(request_bytes, Some(500)).is_ok());

        // Test for a request with the headers we are looking for.
        let request_bytes = b"PATCH http://localhost/home HTTP/1.1\r\n\
                              Expect: 100-continue\r\n\
                              Transfer-Encoding: chunked\r\n\
                              Content-Length: 26\r\n\r\nthis is not\n\r\na json \nbody";
        let request = Request::try_from(request_bytes, None).unwrap();
        assert_eq!(request.uri(), &Uri::new("http://localhost/home"));
        assert_eq!(request.http_version(), Version::Http11);
        assert_eq!(request.method(), Method::Patch);
        assert_eq!(request.headers.chunked(), true);
        assert_eq!(request.headers.expect(), true);
        assert_eq!(request.headers.content_length(), 26);
        assert_eq!(
            request.body.unwrap().body,
            String::from("this is not\n\r\na json \nbody")
                .as_bytes()
                .to_vec()
        );

        // Test for an invalid request format.
        Request::try_from(b"PATCH http://localhost/home HTTP/1.1\r\n", None).unwrap_err();

        // Test for an invalid encoding.
        let request_bytes = b"PATCH http://localhost/home HTTP/1.1\r\n\
                                Expect: 100-continue\r\n\
                                Transfer-Encoding: identity; q=0\r\n\
                                Content-Length: 26\r\n\r\nthis is not\n\r\na json \nbody";

        assert!(Request::try_from(request_bytes, None).is_ok());

        // Test for an invalid content length.
        let request_bytes = b"PATCH http://localhost/home HTTP/1.1\r\n\
                                Content-Length: 5000\r\n\r\nthis is a short body";
        let request = Request::try_from(request_bytes, None).unwrap_err();
        assert_eq!(request, RequestError::InvalidRequest);

        // Test for a request without a body and an optional header.
        let request_bytes = b"GET http://localhost/ HTTP/1.0\r\n\
                                Accept-Encoding: gzip\r\n\r\n";
        let request = Request::try_from(request_bytes, None).unwrap();
        assert_eq!(request.uri(), &Uri::new("http://localhost/"));
        assert_eq!(request.http_version(), Version::Http10);
        assert_eq!(request.method(), Method::Get);
        assert_eq!(request.headers.chunked(), false);
        assert_eq!(request.headers.expect(), false);
        assert_eq!(request.headers.content_length(), 0);
        assert!(request.body.is_none());

        let request_bytes = b"GET http://localhost/ HTTP/1.0\r\n\
                                Accept-Encoding: identity;q=0\r\n\r\n";
        let request = Request::try_from(request_bytes, None);
        assert_eq!(
            request.unwrap_err(),
            RequestError::HeaderError(HttpHeaderError::InvalidValue(
                "Accept-Encoding".to_string(),
                "identity;q=0".to_string()
            ))
        );
    }