Initial Dever 0.0.1

test/rust/runtime/upload/transport.rs

@@ -0,0 +1,85 @@
+use super::*;
+use dever_runtime::{api, http, net};
+use std::sync::Arc;
+
+#[test]
+fn http1_and_http2_stream_uploads_above_the_json_body_limit() {
+    let directory = Directory::new();
+    Runtime::new(TaskLimits::default())
+        .unwrap()
+        .run(async |scope| {
+            for http2 in [false, true] {
+                let listener = net::listen("127.0.0.1", 0, scope).await.unwrap();
+                let port = listener.port().unwrap();
+                let incoming = listener.clone();
+                let data = Arc::new(directory.0.clone());
+                let transport = http::Limits {
+                    body_bytes: 1024,
+                    http2: http2.then(Default::default),
+                    ..Default::default()
+                };
+                let client_limits = http::Limits {
+                    body_bytes: 1_048_576,
+                    ..transport.clone()
+                };
+                let server = scope
+                    .spawn(move |child| async move {
+                        api::serve_upload::<_, _, true>(
+                            &incoming,
+                            &transport,
+                            &child,
+                            None,
+                            move |request, body, child, _| {
+                                let data = data.clone();
+                                async move {
+                                    let mut parsed = upload::read(
+                                        &request,
+                                        body,
+                                        &data,
+                                        &Limits::default(),
+                                        &child,
+                                    )
+                                    .await
+                                    .unwrap();
+                                    let file = parsed.take("file").unwrap();
+                                    let size = file.size();
+                                    parsed
+                                        .finish()
+                                        .unwrap()
+                                        .decode::<Fields>(dever_runtime::wire::decode)
+                                        .unwrap();
+                                    file.close();
+                                    Ok(api::response(size.to_string()))
+                                }
+                            },
+                        )
+                        .await
+                    })
+                    .unwrap();
+                let request = http::Request {
+                    method: "POST".into(),
+                    target: "/upload".into(),
+                    headers: vec![
+                        http::Header {
+                            name: "host".into(),
+                            value: b"fixture.test".to_vec().into(),
+                        },
+                        http::Header {
+                            name: "content-type".into(),
+                            value: b"multipart/form-data; boundary=boundary".to_vec().into(),
+                        },
+                    ],
+                    body: content(&vec![b'x'; 170_001]).into(),
+                };
+                let response = http::send("127.0.0.1", port, request, &client_limits)
+                    .await
+                    .unwrap();
+                assert_eq!(response.status, 200);
+                assert_eq!(response.body.as_ref(), b"170001");
+                assert_eq!(directory.temporary_count(), 0);
+                listener.close().unwrap();
+                server.wait().await.unwrap().unwrap();
+            }
+        })
+        .unwrap();
+}