wasm-rquickjs-cli 0.2.4

Tool for wrapping JavaScript modules as WebAssembly components using the QuickJS engine
use axum::body::Body;
use axum::extract::{Multipart, Path};
use axum::http::HeaderMap;
use axum::response::{AppendHeaders, IntoResponse};
use axum::routing::{get, post};
use axum::{Json, Router};
use bytes::Bytes;
use http::{StatusCode, header};
use indoc::formatdoc;
use serde::{Deserialize, Serialize};
use std::io::Cursor;
use std::sync::Arc;
use tokio::sync::Mutex;
use tokio::task::JoinHandle;
use tokio_util::io::ReaderStream;

pub async fn start_test_server() -> (u16, JoinHandle<()>) {
    let listener = tokio::net::TcpListener::bind("0.0.0.0:0").await.unwrap();
    let host_http_port = listener.local_addr().unwrap().port();

    let handle = tokio::spawn(async move {
        let state_mutex = Arc::new(Mutex::new(State::default()));

        let state_mutex_1 = state_mutex.clone();
        let state_mutex_2 = state_mutex.clone();
        let state_mutex_3 = state_mutex.clone();

        let router = Router::new()
            .route(
                "/todos",
                post(async move |body: Bytes| {
                    let mut state = state_mutex_1.lock().await;

                    let req = serde_json::from_slice::<NewTodo>(&body).unwrap();

                    let todo_id = state.current_todo_id;
                    let todo = Todo {
                        id: todo_id,
                        user_id: req.user_id,
                        title: req.title,
                        body: req.body,
                        completed: false,
                    };

                    let response = (StatusCode::CREATED, Json(&todo)).into_response();

                    state.todos.push(todo);
                    state.current_todo_id += 1;

                    response
                }),
            )
            .route(
                "/todos",
                get(async move || {
                    let state = state_mutex_2.lock().await;

                    Json(&state.todos).into_response()
                }),
            )
            .route(
                "/todos/{todo_id}",
                get(async move |Path((todo_id,)): Path<(usize,)>| {
                    let state = state_mutex_3.lock().await;

                    let todo = state.todos.get(todo_id);

                    if let Some(todo) = todo {
                        Json(todo).into_response()
                    } else {
                        StatusCode::NOT_FOUND.into_response()
                    }
                }),
            )
            .route(
                "/todos-stream",
                get(async move || {
                    let mut todos = Vec::new();
                    for i in 0..100 {
                        todos.push(Todo {
                            id: i,
                            user_id: 1,
                            title: format!("todo_title_{i}"),
                            body: format!("todo_body_{i}"),
                            completed: i % 2 == 0,
                        });
                    }

                    let json_bytes = serde_json::to_vec(&todos).unwrap();

                    let body_stream = ReaderStream::with_capacity(Cursor::new(json_bytes), 100);

                    (
                        AppendHeaders([(header::CONTENT_TYPE, "application/json")]),
                        Body::from_stream(body_stream),
                    )
                }),
            )
            .route(
                "/echo",
                post(async move |body: Body| {
                    (
                        AppendHeaders([(header::CONTENT_TYPE, "application/octet-stream")]),
                        body,
                    )
                }),
            )
            .route(
                "/echo-form",
                post(async move |mut multipart: Multipart| {
                    let mut parts = Vec::new();

                    while let Some(field) = multipart.next_field().await.unwrap() {
                        let name = field.name().unwrap().to_string();
                        let data = field.bytes().await.unwrap();

                        parts.push(MultiPartPart {
                            name,
                            data: data.to_vec(),
                        });
                    }

                    Json(parts)
                }),
            )
            .route(
                "/form-echo",
                post(async move |body: Bytes| {
                    let body_str = String::from_utf8(body.to_vec()).unwrap_or_default();
                    Json(serde_json::json!({
                        "body": body_str,
                        "type": "application/x-www-form-urlencoded"
                    }))
                }),
            )
            .route(
                "/echo-referer",
                post(async move |headers: HeaderMap| {
                    let referer = headers
                        .get("referer")
                        .and_then(|h| h.to_str().ok())
                        .unwrap_or("")
                        .to_string();
                    Json(serde_json::json!({
                        "referer": referer
                    }))
                }),
            )
            .route(
                "/echo-credentials",
                post(async move |headers: HeaderMap| {
                    let authorization = headers
                        .get("authorization")
                        .and_then(|h| h.to_str().ok())
                        .unwrap_or("")
                        .to_string();
                    let cookie = headers
                        .get("cookie")
                        .and_then(|h| h.to_str().ok())
                        .unwrap_or("")
                        .to_string();
                    (
                        AppendHeaders([(header::SET_COOKIE, "test-cookie=test-value")]),
                        Json(serde_json::json!({
                            "authorization": authorization,
                            "cookie": cookie
                        })),
                    )
                }),
            )
            .route(
                "/redirect-to",
                axum::routing::any(async move |query: axum::extract::Query<RedirectParams>| {
                    let status = StatusCode::from_u16(query.status).unwrap_or(StatusCode::FOUND);
                    (status, [("Location", query.url.clone())]).into_response()
                }),
            )
            .route(
                "/redirect-loop",
                get(async move || {
                    (StatusCode::FOUND, [("Location", "/redirect-loop")]).into_response()
                }),
            )
            .route(
                "/form-response",
                get(|| async {
                    let boundary = "WebKitFormBoundary7MA4YWxkTrZu0gW";
                    let body = formatdoc! {
                    "--{boundary}
                     Content-Disposition: form-data; name=\"username\"

                     john_doe
                     --{boundary}
                     Content-Disposition: form-data; name=\"email\"

                     john@example.com
                     --{boundary}
                     Content-Disposition: form-data; name=\"file\"; filename=\"test.txt\"
                     Content-Type: text/plain

                     Hello World
                     --{boundary}--"};
                    (
                        [(
                            "Content-Type",
                            format!("multipart/form-data; boundary={}", boundary),
                        )],
                        body,
                    )
                        .into_response()
                }),
            );

        axum::serve(listener, router).await.unwrap();
    });

    (host_http_port, handle)
}

#[derive(Debug, Clone, Serialize)]
#[serde(rename_all = "camelCase")]
struct Todo {
    id: usize,
    user_id: u64,
    title: String,
    body: String,
    completed: bool,
}

#[derive(Debug, Clone, Deserialize)]
#[serde(rename_all = "camelCase")]
struct NewTodo {
    user_id: u64,
    title: String,
    body: String,
}

#[derive(Debug, Deserialize)]
struct RedirectParams {
    url: String,
    status: u16,
}

#[derive(Default)]
struct State {
    current_todo_id: usize,
    todos: Vec<Todo>,
}

#[derive(Debug, Clone, Serialize)]
#[serde(rename_all = "camelCase")]
struct MultiPartPart {
    name: String,
    data: Vec<u8>,
}