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();
}