Initial Dever 0.0.1

test/rust/runtime/http/limits.rs

@@ -0,0 +1,103 @@
+use super::*;
+
+#[test]
+fn body_budgets_timeouts_invalid_messages_and_recovery_are_bounded() {
+    runtime().run(async |scope| {
+        let listener = net::listen("127.0.0.1", 0, scope).await.unwrap();
+        let port = listener.port().unwrap();
+        let incoming = listener.clone();
+        let server = scope.spawn(move |child| async move {
+            let limits = Limits { body_bytes: 4, timeout_ms: 100, ..Limits::default() };
+            http::serve::<_, _, false>(&incoming, &limits, &child, route).await
+        }).unwrap();
+        scope.blocking(move || {
+            let query_only = format!("GET ?{} HTTP/1.1\r\nHost: t\r\n\r\n", "a".repeat(8163));
+            for (message, expected) in [
+                ("POST /echo HTTP/1.1\r\nHost: fixture.test\r\nContent-Length: 5\r\n\r\n12345", 413),
+                ("POST /echo HTTP/1.1\r\nHost: fixture.test\r\nContent-Length: 4\r\n\r\n1", 408),
+                ("GET /wait HTTP/1.1\r\nHost: fixture.test\r\n\r\n", 504),
+                ("GET /echo HTTP/1.1\r\nHost: one\r\nHost: two\r\n\r\n", 400),
+                (query_only.as_str(), 400),
+            ] {
+                let mut stream = connect(port);
+                stream.get_mut().write_all(message.as_bytes()).unwrap();
+                assert_eq!(read_response(&mut stream, false).0, expected);
+                assert_eq!(stream.read(&mut [0]).unwrap(), 0);
+            }
+            let mut stream = connect(port);
+            stream.get_mut().write_all(b"GET / HTTP/1.1\r\nHost:").unwrap();
+            assert_eq!(stream.read(&mut [0]).unwrap(), 0);
+        }).await.unwrap();
+        let response = http::send("127.0.0.1", port, request("/echo", b"ok"), &Limits::default()).await.unwrap();
+        assert_eq!(response.body.as_ref(), b"ok");
+        listener.close().unwrap();
+        server.wait().await.unwrap().unwrap();
+    }).unwrap();
+}
+
+#[test]
+fn outgoing_contracts_reject_framing_injection_and_bad_limits() {
+    runtime()
+        .run(async |_| {
+            for header in [
+                Header {
+                    name: "Content-Length".into(),
+                    value: b"0".to_vec().into(),
+                },
+                Header {
+                    name: "Transfer-Encoding".into(),
+                    value: b"chunked".to_vec().into(),
+                },
+                Header {
+                    name: "x-test".into(),
+                    value: b"a\r\nb".to_vec().into(),
+                },
+            ] {
+                let mut message = request("/", b"");
+                message.headers.push(header);
+                let error = http::send("127.0.0.1", 1, message, &Limits::default())
+                    .await
+                    .unwrap_err();
+                assert!(!error.contains("connection failed"), "{error}");
+            }
+            for limits in [
+                Limits {
+                    header_bytes: 0,
+                    ..Limits::default()
+                },
+                Limits {
+                    body_bytes: -1,
+                    ..Limits::default()
+                },
+                Limits {
+                    timeout_ms: 0,
+                    ..Limits::default()
+                },
+                Limits {
+                    connections: 65537,
+                    ..Limits::default()
+                },
+            ] {
+                assert!(
+                    http::send("127.0.0.1", 1, request("/", b""), &limits)
+                        .await
+                        .is_err()
+                );
+            }
+            let long_target = format!("/{}", "x".repeat(8192));
+            for (method, target) in [
+                ("CONNECT", "/"),
+                ("GET", "http://example.test/"),
+                ("GET", "/#fragment"),
+                ("GET", long_target.as_str()),
+            ] {
+                let mut message = request(target, b"");
+                message.method = method.into();
+                let error = http::send("127.0.0.1", 1, message, &Limits::default())
+                    .await
+                    .unwrap_err();
+                assert!(!error.contains("connection failed"), "{error}");
+            }
+        })
+        .unwrap();
+}