Skip to content

armgit / moli

Public Imported from GitHub
0

Best headless browser for AI agents. Lite, Fast, High-Compatibility. Built in Rust

27.4 KB
Raw Blame
use super::*;

#[derive(Clone)]
struct RefererGatedDynamicScriptState {
    expected_referer: String,
    observed_referer: Arc<Mutex<Option<String>>>,
}

async fn dynamic_script_page() -> impl IntoResponse {
    (
        [(CONTENT_TYPE.as_str(), "text/html")],
        r#"<!doctype html>
<html><head>
<base href="/assets/">
<script>
const dynamicScript = document.createElement('script');
dynamicScript.src = 'dynamic.js';
document.head.appendChild(dynamicScript);
</script>
</head><body>dynamic script referer probe</body></html>"#,
    )
}

async fn referer_gated_dynamic_script(
    State(state): State<RefererGatedDynamicScriptState>,
    headers: HeaderMap,
) -> impl IntoResponse {
    let observed_referer = headers
        .get("referer")
        .and_then(|value| value.to_str().ok())
        .map(str::to_owned);
    let accepted = observed_referer.as_deref() == Some(state.expected_referer.as_str());
    *state.observed_referer.lock() = observed_referer;
    let status = if accepted {
        StatusCode::OK
    } else {
        StatusCode::FORBIDDEN
    };
    let body = if accepted {
        "globalThis.__lm_dynamic_script_base = document.baseURI;"
    } else {
        ""
    };
    (
        status,
        [(CONTENT_TYPE.as_str(), "application/javascript")],
        body,
    )
}

#[tokio::test(flavor = "multi_thread")]
async fn runtime_capture_without_network_listener_does_not_advance_subresource_cursor() {
    async fn page() -> impl IntoResponse {
        (
            [(CONTENT_TYPE.as_str(), "text/html")],
            r#"<!doctype html><script src="/no-listener.js"></script>"#,
        )
    }

    async fn script() -> impl IntoResponse {
        (
            [(CONTENT_TYPE.as_str(), "application/javascript")],
            "globalThis.__no_listener_script = true;",
        )
    }

    let listener = TcpListener::bind("127.0.0.1:0").await.unwrap();
    let addr = listener.local_addr().unwrap();
    let server = tokio::spawn(async move {
        axum::serve(
            listener,
            Router::new()
                .route("/page", get(page))
                .route("/no-listener.js", get(script)),
        )
        .await
        .unwrap();
    });

    let page_url = format!("http://{addr}/page");
    let mut ctx = TestContext::new();
    let mut bc = BrowserContext::new("BID-1".into());
    bc.set_active_target_id("TID-1");
    bc.attach_active_session("SID-1");
    ctx.conn.install_browser_context_fixture_for_test(bc);

    ctx.install_navigation_fixture_for_session_owner(&page_url, Some("SID-1"))
        .await;
    assert_eq!(
        ctx.conn
            .runtime_session_owner_slot(Some("SID-1"))
            .unwrap()
            .loaded_page()
            .unwrap()
            .subresource_network_records()
            .len(),
        1
    );
    ctx.sent.clear();

    ctx.process_async(json!({
        "id": 10_116,
        "method": "Runtime.evaluate",
        "sessionId": "SID-1",
        "params": { "expression": "globalThis.__no_listener_script" }
    }))
    .await;
    ctx.expect_result(
        10_116,
        json!({ "result": { "type": "boolean", "value": true }}),
        Some("SID-1"),
    );

    let bc = ctx.conn.browser_context.as_ref().unwrap();
    assert_eq!(
        bc.subresource_network_emitted_record_count_for_test(),
        0,
        "without a Network listener, post-eval work must not claim subresource history"
    );

    server.abort();
}

#[tokio::test(flavor = "multi_thread")]
async fn runtime_script_uses_document_referer_and_script_cdp_initiator() {
    let listener = TcpListener::bind("127.0.0.1:0").await.unwrap();
    let addr = listener.local_addr().unwrap();
    let page_url = format!("http://{addr}/page/index.html");
    let script_url = format!("http://{addr}/assets/dynamic.js");
    let base_url = format!("http://{addr}/assets/");
    let observed_referer = Arc::new(Mutex::new(None));
    let state = RefererGatedDynamicScriptState {
        expected_referer: page_url.clone(),
        observed_referer: Arc::clone(&observed_referer),
    };
    let server = tokio::spawn(async move {
        axum::serve(
            listener,
            Router::new()
                .route("/page/index.html", get(dynamic_script_page))
                .route("/assets/dynamic.js", get(referer_gated_dynamic_script))
                .with_state(state),
        )
        .await
        .unwrap();
    });

    let mut ctx = TestContext::new();
    let mut bc = BrowserContext::new("BID-1".into());
    bc.set_active_target_id("TID-1");
    bc.attach_active_session("SID-1");
    ctx.conn.install_browser_context_fixture_for_test(bc);
    ctx.enable_page_events_for_test(Some("SID-1"));

    ctx.process_async(json!({
        "id": 10_120,
        "method": "Network.enable",
        "sessionId": "SID-1"
    }))
    .await;
    ctx.expect_result(10_120, json!({}), Some("SID-1"));

    ctx.process_async(json!({
        "id": 10_121,
        "method": "Page.navigate",
        "sessionId": "SID-1",
        "params": { "url": page_url }
    }))
    .await;
    let _ = ctx.take_response_by_id(10_121);

    flush_until_subresource_finished(&mut ctx, "Script", 1, "runtime script network completion")
        .await;
    wait_until_messages(
        &mut ctx,
        Some("SID-1"),
        "runtime script releases window load",
        |messages| {
            messages
                .iter()
                .any(|message| message["method"] == json!("Page.loadEventFired"))
        },
    )
    .await;

    let messages = ctx.take_all();
    let script_request = messages
        .iter()
        .find(|message| {
            message["method"] == json!("Network.requestWillBeSent")
                && message["params"]["request"]["url"] == json!(script_url)
        })
        .expect("runtime script request event");
    assert_eq!(script_request["params"]["documentURL"], page_url);
    assert_eq!(script_request["params"]["initiator"]["type"], "script");
    let request_id = script_request["params"]["requestId"]
        .as_str()
        .expect("runtime script request id");
    let script_response = messages
        .iter()
        .find(|message| {
            message["method"] == json!("Network.responseReceived")
                && message["params"]["requestId"] == json!(request_id)
        })
        .expect("runtime script response event");
    assert_eq!(script_response["params"]["response"]["status"], 200);
    assert_eq!(observed_referer.lock().as_deref(), Some(page_url.as_str()));

    ctx.process_async(json!({
        "id": 10_122,
        "method": "Runtime.evaluate",
        "sessionId": "SID-1",
        "params": { "expression": "globalThis.__lm_dynamic_script_base" }
    }))
    .await;
    ctx.expect_result(
        10_122,
        json!({ "result": { "type": "string", "value": base_url } }),
        Some("SID-1"),
    );

    server.abort();
}

#[tokio::test(flavor = "multi_thread")]
async fn runtime_fetch_post_body_is_available_by_network_request_id() {
    async fn page() -> impl IntoResponse {
        ([(CONTENT_TYPE.as_str(), "text/html")], "<!doctype html>")
    }

    async fn post_body(body: String) -> impl IntoResponse {
        body
    }

    let listener = TcpListener::bind("127.0.0.1:0").await.unwrap();
    let addr = listener.local_addr().unwrap();
    let server = tokio::spawn(async move {
        axum::serve(
            listener,
            Router::new()
                .route("/page", get(page))
                .route("/post", post(post_body)),
        )
        .await
        .unwrap();
    });

    let page_url = format!("http://{addr}/page");
    let mut ctx = TestContext::new();
    let mut bc = BrowserContext::new("BID-1".into());
    bc.set_active_target_id("TID-1".to_owned());
    bc.attach_active_session("SID-1".to_owned());
    ctx.conn.install_browser_context_fixture_for_test(bc);
    ctx.install_navigation_fixture_for_session_owner(&page_url, Some("SID-1"))
        .await;
    ctx.sent.clear();

    ctx.process_async(json!({
        "id": 10_117,
        "method": "Network.enable",
        "sessionId": "SID-1"
    }))
    .await;
    ctx.expect_result(10_117, json!({}), Some("SID-1"));

    ctx.process_async(json!({
        "id": 10_118,
        "method": "Runtime.evaluate",
        "sessionId": "SID-1",
        "params": {
            "expression": "fetch('/post',{method:'POST',body:'captured-post-body'}).catch(()=>{}); 'scheduled'"
        }
    }))
    .await;
    let _ = ctx.take_response_by_id(10_118);

    wait_until_messages(&mut ctx, "SID-1", "POST requestWillBeSent", |messages| {
        messages.iter().any(|message| {
            message["method"] == json!("Network.requestWillBeSent")
                && message["params"]["request"]["method"] == json!("POST")
        })
    })
    .await;
    let request_id = ctx
        .sent
        .iter()
        .find(|message| {
            message["method"] == json!("Network.requestWillBeSent")
                && message["params"]["request"]["method"] == json!("POST")
        })
        .and_then(|message| message["params"]["requestId"].as_str())
        .expect("POST request id")
        .to_owned();

    ctx.process_async(json!({
        "id": 10_119,
        "method": "Network.getRequestPostData",
        "sessionId": "SID-1",
        "params": { "requestId": request_id }
    }))
    .await;
    ctx.expect_result(
        10_119,
        json!({ "postData": "captured-post-body", "base64Encoded": false }),
        Some("SID-1"),
    );

    server.abort();
}

#[tokio::test(flavor = "multi_thread")]
async fn runtime_form_post_navigation_body_is_available_by_network_request_id() {
    async fn page() -> impl IntoResponse {
        (
            [(CONTENT_TYPE.as_str(), "text/html")],
            r#"<!doctype html><form id="f" method="POST" action="/post"><input name="username" value="alice"><input name="pw" value="s3cret"></form>"#,
        )
    }

    async fn post_body(body: String) -> impl IntoResponse {
        body
    }

    let listener = TcpListener::bind("127.0.0.1:0").await.unwrap();
    let addr = listener.local_addr().unwrap();
    let server = tokio::spawn(async move {
        axum::serve(
            listener,
            Router::new()
                .route("/page", get(page))
                .route("/post", post(post_body)),
        )
        .await
        .unwrap();
    });

    let page_url = format!("http://{addr}/page");
    let mut ctx = TestContext::new();
    let mut bc = BrowserContext::new("BID-1".into());
    bc.set_active_target_id("TID-1".to_owned());
    bc.attach_active_session("SID-1".to_owned());
    ctx.conn.install_browser_context_fixture_for_test(bc);
    ctx.install_navigation_fixture_for_session_owner(&page_url, Some("SID-1"))
        .await;
    ctx.sent.clear();

    ctx.process_async(json!({
        "id": 10_210,
        "method": "Network.enable",
        "sessionId": "SID-1"
    }))
    .await;
    ctx.expect_result(10_210, json!({}), Some("SID-1"));

    ctx.process_async(json!({
        "id": 10_211,
        "method": "Runtime.evaluate",
        "sessionId": "SID-1",
        "params": {
            "expression": "document.getElementById('f').submit(); 'scheduled'"
        }
    }))
    .await;
    let _ = ctx.take_response_by_id(10_211);

    wait_until_messages(
        &mut ctx,
        "SID-1",
        "POST navigation requestWillBeSent",
        |messages| {
            messages.iter().any(|message| {
                message["method"] == json!("Network.requestWillBeSent")
                    && message["params"]["request"]["method"] == json!("POST")
            })
        },
    )
    .await;
    let request_id = ctx
        .sent
        .iter()
        .find(|message| {
            message["method"] == json!("Network.requestWillBeSent")
                && message["params"]["request"]["method"] == json!("POST")
        })
        .and_then(|message| message["params"]["requestId"].as_str())
        .expect("POST navigation request id")
        .to_owned();

    ctx.process_async(json!({
        "id": 10_212,
        "method": "Network.getRequestPostData",
        "sessionId": "SID-1",
        "params": { "requestId": request_id }
    }))
    .await;
    ctx.expect_result(
        10_212,
        json!({ "postData": "username=alice&pw=s3cret", "base64Encoded": false }),
        Some("SID-1"),
    );

    server.abort();
}

#[tokio::test(flavor = "multi_thread")]
async fn websocket_runtime_activity_emits_cdp_websocket_events_without_payload() {
    assert_websocket_runtime_activity_events(axum::http::Version::HTTP_11).await;
}

#[tokio::test(flavor = "multi_thread")]
async fn http10_websocket_upgrade_emits_cdp_frames_and_closes_cleanly() {
    assert_websocket_runtime_activity_events(axum::http::Version::HTTP_10).await;
}

async fn assert_websocket_runtime_activity_events(version: axum::http::Version) {
    use futures_util::{SinkExt, StreamExt};
    use tokio_tungstenite::tungstenite::{Message, handshake::server};

    let listener = TcpListener::bind("127.0.0.1:0").await.unwrap();
    let addr = listener.local_addr().unwrap();
    let server = tokio::spawn(async move {
        axum::serve(listener, Router::new().route("/page", get(plain_page)))
            .await
            .unwrap();
    });
    let websocket_listener = TcpListener::bind("127.0.0.1:0").await.unwrap();
    let socket_url = format!("ws://{}/socket", websocket_listener.local_addr().unwrap());
    let websocket_server = tokio::spawn(async move {
        let (stream, _) = websocket_listener.accept().await.unwrap();
        // tungstenite requires its unboxed HTTP error response in this callback.
        #[allow(clippy::result_large_err)]
        let response_version = move |_: &server::Request, mut response: server::Response| {
            *response.version_mut() = version;
            Ok(response)
        };
        let mut socket = tokio_tungstenite::accept_hdr_async(stream, response_version)
            .await
            .unwrap();
        let message = socket.next().await.unwrap().unwrap();
        assert_eq!(message, Message::Text("hello".into()));
        socket.send(message).await.unwrap();
        assert!(matches!(socket.next().await, Some(Ok(Message::Close(_)))));
        socket.flush().await.unwrap();
    });

    let page_url = format!("http://{addr}/page");
    let socket_literal = serde_json::to_string(&socket_url).unwrap();
    let mut ctx = TestContext::new();
    let mut bc = BrowserContext::new("BID-1".into());
    bc.set_active_target_id("TID-1".to_owned());
    bc.attach_active_session("SID-1".to_owned());
    ctx.conn.insert_browser_context(bc);
    ctx.install_navigation_fixture_for_session_owner(&page_url, Some("SID-1"))
        .await;
    ctx.conn
        .runtime_session_owner_slot_mut(Some("SID-1"))
        .expect("websocket fixture target")
        .enable_primary_network_events();
    ctx.sent.clear();

    ctx.process_async(json!({
        "id": 7_001,
        "method": "Runtime.evaluate",
        "sessionId": "SID-1",
        "params": {
            "expression": format!(r#"(() => {{
                globalThis.__lm_ws_done = false;
                const socket = new WebSocket({socket_literal});
                globalThis.__lm_ws_closed = new Promise(resolve => {{
                    socket.addEventListener('close', event => resolve(event.wasClean));
                }});
                socket.addEventListener('open', () => socket.send('hello'));
                socket.addEventListener('message', () => {{
                    globalThis.__lm_ws_done = true;
                    socket.close(1000, 'done');
                }});
                return 'scheduled';
            }})()"#)
        }
    }))
    .await;
    let _ = ctx.take_response_by_id(7_001);

    wait_until_messages(&mut ctx, "SID-1", "websocket CDP creation", |messages| {
        messages
            .iter()
            .any(|message| message["method"] == json!("Network.webSocketCreated"))
    })
    .await;

    let created = ctx
        .sent
        .iter()
        .find(|message| message["method"] == json!("Network.webSocketCreated"))
        .expect("webSocketCreated event");
    assert_eq!(created["params"]["url"], socket_url);
    let request_id = created["params"]["requestId"]
        .as_str()
        .expect("websocket request id")
        .to_owned();

    wait_until_messages(
        &mut ctx,
        "SID-1",
        "complete websocket CDP lifecycle",
        |messages| {
            let has_event = |method: &str| {
                messages.iter().any(|message| {
                    message["method"] == json!(method)
                        && message["params"]["requestId"] == json!(request_id)
                })
            };
            has_event("Network.webSocketWillSendHandshakeRequest")
                && has_event("Network.webSocketHandshakeResponseReceived")
                && has_event("Network.webSocketFrameSent")
                && has_event("Network.webSocketFrameReceived")
                && has_event("Network.webSocketClosed")
        },
    )
    .await;

    assert!(ctx.sent.iter().any(|message| {
        message["method"] == json!("Network.webSocketWillSendHandshakeRequest")
            && message["params"]["requestId"] == json!(request_id)
            && message["params"]["request"]["headers"]["origin"] == json!(format!("http://{addr}"))
    }));
    assert!(ctx.sent.iter().any(|message| {
        message["method"] == json!("Network.webSocketHandshakeResponseReceived")
            && message["params"]["requestId"] == json!(request_id)
            && message["params"]["response"]["status"] == json!(101)
    }));
    assert!(ctx.sent.iter().any(|message| {
        message["method"] == json!("Network.webSocketFrameSent")
            && message["params"]["requestId"] == json!(request_id)
            && message["params"]["response"]["opcode"] == json!(1)
            && message["params"]["response"]["payloadData"] == json!("")
            && message["params"]["response"]["payloadLength"] == json!(5)
    }));
    assert!(ctx.sent.iter().any(|message| {
        message["method"] == json!("Network.webSocketFrameReceived")
            && message["params"]["requestId"] == json!(request_id)
            && message["params"]["response"]["opcode"] == json!(1)
            && message["params"]["response"]["payloadData"] == json!("")
            && message["params"]["response"]["payloadLength"] == json!(5)
    }));
    assert!(ctx.sent.iter().all(|message| {
        message["method"] != json!("Network.webSocketFrameError")
            || message["params"]["requestId"] != json!(request_id)
    }));

    ctx.process_async(json!({
        "id": 7_005,
        "method": "Runtime.evaluate",
        "sessionId": "SID-1",
        "params": { "expression": "globalThis.__lm_ws_closed", "awaitPromise": true }
    }))
    .await;
    ctx.expect_result(
        7_005,
        json!({ "result": { "type": "boolean", "value": true } }),
        Some("SID-1"),
    );

    ctx.sent.clear();
    ctx.process_async(json!({
        "id": 7_002,
        "method": "Network.disable",
        "sessionId": "SID-1"
    }))
    .await;
    ctx.expect_result(7_002, json!({}), Some("SID-1"));
    ctx.process_async(json!({
        "id": 7_003,
        "method": "Network.enable",
        "sessionId": "SID-1"
    }))
    .await;
    ctx.expect_result(7_003, json!({}), Some("SID-1"));
    ctx.process_async(json!({
        "id": 7_004,
        "method": "Runtime.evaluate",
        "sessionId": "SID-1",
        "params": { "expression": "42" }
    }))
    .await;
    let _ = ctx.take_response_by_id(7_004);
    assert!(
        ctx.sent.iter().all(|message| {
            !message["method"]
                .as_str()
                .is_some_and(|method| method.starts_with("Network.webSocket"))
        }),
        "Network.disable/enable must not replay old WebSocket events: {:?}",
        ctx.sent
    );

    websocket_server.await.unwrap();
    server.abort();
}

#[tokio::test(flavor = "multi_thread")]
async fn rejected_websocket_handshake_emits_frame_error_then_closed() {
    let listener = TcpListener::bind("127.0.0.1:0").await.unwrap();
    let addr = listener.local_addr().unwrap();
    let server = tokio::spawn(async move {
        axum::serve(listener, Router::new().route("/page", get(plain_page)))
            .await
            .unwrap();
    });

    let page_url = format!("http://{addr}/page");
    let socket_url = format!("ws://{addr}/rejected");
    let socket_literal = serde_json::to_string(&socket_url).unwrap();
    let mut ctx = TestContext::new();
    let mut bc = BrowserContext::new("BID-1".into());
    bc.set_active_target_id("TID-1".to_owned());
    bc.attach_active_session("SID-1".to_owned());
    ctx.conn.install_browser_context_fixture_for_test(bc);
    ctx.install_navigation_fixture_for_session_owner(&page_url, Some("SID-1"))
        .await;
    ctx.sent.clear();

    ctx.process_async(json!({
        "id": 7_101,
        "method": "Network.enable",
        "sessionId": "SID-1"
    }))
    .await;
    ctx.expect_result(7_101, json!({}), Some("SID-1"));

    ctx.process_async(json!({
        "id": 7_102,
        "method": "Runtime.evaluate",
        "sessionId": "SID-1",
        "params": {
            "expression": format!(r#"(() => {{
                const socket = new WebSocket({socket_literal});
                socket.addEventListener('error', () => {{}});
                socket.addEventListener('close', () => {{}});
                return 'scheduled';
            }})()"#)
        }
    }))
    .await;
    let _ = ctx.take_response_by_id(7_102);

    wait_until_messages(
        &mut ctx,
        "SID-1",
        "rejected WebSocket close event",
        |messages| {
            messages
                .iter()
                .any(|message| message["method"] == json!("Network.webSocketClosed"))
        },
    )
    .await;

    let websocket_messages = ctx
        .sent
        .iter()
        .filter(|message| {
            message["method"]
                .as_str()
                .is_some_and(|method| method.starts_with("Network.webSocket"))
        })
        .collect::<Vec<_>>();
    let methods = websocket_messages
        .iter()
        .filter_map(|message| message["method"].as_str())
        .collect::<Vec<_>>();
    let created_index = methods
        .iter()
        .position(|method| *method == "Network.webSocketCreated")
        .expect("webSocketCreated event");
    let request_index = methods
        .iter()
        .position(|method| *method == "Network.webSocketWillSendHandshakeRequest")
        .expect("webSocketWillSendHandshakeRequest event");
    let error_index = methods
        .iter()
        .position(|method| *method == "Network.webSocketFrameError")
        .expect("webSocketFrameError event");
    let closed_index = methods
        .iter()
        .position(|method| *method == "Network.webSocketClosed")
        .expect("webSocketClosed event");
    assert!(
        created_index < request_index && request_index < error_index && error_index < closed_index,
        "rejected WebSocket CDP events must preserve Chromium order: {methods:?}"
    );

    let request_id = websocket_messages[created_index]["params"]["requestId"]
        .as_str()
        .expect("WebSocket request id");
    for index in [request_index, error_index, closed_index] {
        assert_eq!(
            websocket_messages[index]["params"]["requestId"], request_id,
            "all rejected WebSocket events must share one requestId"
        );
    }
    assert!(
        websocket_messages[error_index]["params"]["errorMessage"]
            .as_str()
            .is_some_and(|message| !message.is_empty()),
        "webSocketFrameError must expose the transport failure reason"
    );
    assert!(
        ctx.sent.iter().all(|message| {
            message["method"] != json!("Network.webSocketHandshakeResponseReceived")
                || message["params"]["requestId"] != json!(request_id)
        }),
        "a rejected handshake must not emit webSocketHandshakeResponseReceived"
    );

    server.abort();
}

#[tokio::test(flavor = "multi_thread")]
async fn document_write_external_script_emits_subresource_network_events_and_captures_body() {
    const SCRIPT_BODY: &str =
        r#"globalThis.__lm_document_write_script_loaded = "document-write script body";"#;

    async fn page() -> impl IntoResponse {
        (
            [(CONTENT_TYPE.as_str(), "text/html")],
            r#"<!doctype html>
<html><body>
<script>
document.write('<script src="/written.js"><\/script>');
</script>
</body></html>"#,
        )
    }

    async fn script() -> impl IntoResponse {
        (
            [
                (CONTENT_TYPE.as_str(), "application/javascript"),
                ("x-script", "document-write"),
            ],
            SCRIPT_BODY,
        )
    }

    let listener = TcpListener::bind("127.0.0.1:0").await.unwrap();
    let addr = listener.local_addr().unwrap();
    let server = tokio::spawn(async move {
        axum::serve(
            listener,
            Router::new()
                .route("/page", get(page))
                .route("/written.js", get(script)),
        )
        .await
        .unwrap();
    });

    let page_url = format!("http://{addr}/page");
    let script_url = format!("http://{addr}/written.js");
    let mut ctx = TestContext::new();
    let mut bc = BrowserContext::new("BID-1".into());
    bc.set_active_target_id("TID-1");
    bc.attach_active_session("SID-1");
    ctx.conn.install_browser_context_fixture_for_test(bc);

    ctx.process_async(json!({
        "id": 70_007,
        "method": "Network.enable",
        "sessionId": "SID-1"
    }))
    .await;
    ctx.expect_result(70_007, json!({}), Some("SID-1"));

    ctx.process_async(json!({
        "id": 70_008,
        "method": "Page.navigate",
        "sessionId": "SID-1",
        "params": { "url": page_url }
    }))
    .await;

    flush_until_subresource_finished(
        &mut ctx,
        "Script",
        1,
        "document.write script network completion",
    )
    .await;

    let messages = ctx.take_all();
    let script_request = messages
        .iter()
        .find(|message| {
            message["method"] == json!("Network.requestWillBeSent")
                && message["params"]["type"] == json!("Script")
                && message["params"]["request"]["url"] == json!(script_url)
        })
        .expect("document.write script request event");
    assert_eq!(script_request["params"]["documentURL"], page_url);
    assert_eq!(script_request["params"]["request"]["method"], "GET");
    let script_request_id = script_request["params"]["requestId"]
        .as_str()
        .expect("document.write script request id")
        .to_owned();

    let script_response = messages
        .iter()
        .find(|message| {
            message["method"] == json!("Network.responseReceived")
                && message["params"]["requestId"] == json!(script_request_id)
        })
        .expect("document.write script response event");
    assert_eq!(script_response["params"]["type"], "Script");
    assert_eq!(script_response["params"]["response"]["url"], script_url);
    assert_eq!(script_response["params"]["response"]["status"], 200);
    assert_eq!(
        script_response["params"]["response"]["headers"]["x-script"],
        "document-write"
    );

    assert!(messages.iter().any(|message| {
        message["method"] == json!("Network.loadingFinished")
            && message["params"]["requestId"] == json!(script_request_id)
    }));

    ctx.process_async(json!({
        "id": 70_009,
        "method": "Network.getResponseBody",
        "sessionId": "SID-1",
        "params": { "requestId": script_request_id }
    }))
    .await;
    ctx.expect_result(
        70_009,
        json!({
            "body": SCRIPT_BODY,
            "base64Encoded": false
        }),
        Some("SID-1"),
    );

    server.abort();
}