Skip to content

armgit / moli

Public Imported from GitHub
0

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

68.4 KB
Raw Blame
use super::*;

#[test]
fn command_dispatch_completes_parse_errors_without_legacy_fallback() {
    let mut conn = CdpConnection::new();
    let step = conn.start_command_dispatch("{");
    assert_eq!(
        complete_messages(step),
        vec![json!({
            "id": null,
            "error": {"code": -32700, "message": "Parse error"}
        })]
    );
}

#[test]
fn command_dispatch_completes_invalid_methods_without_legacy_fallback() {
    let mut conn = CdpConnection::new();
    let raw = serde_json::to_string(&json!({
        "id": 7,
        "method": "MalformedMethod",
        "sessionId": "SID-1"
    }))
    .unwrap();
    let step = conn.start_command_dispatch(&raw);
    assert_eq!(
        complete_messages(step),
        vec![json!({
            "id": 7,
            "error": {"code": -32600, "message": "Invalid method"},
            "sessionId": "SID-1"
        })]
    );
}

#[test]
fn command_dispatch_completes_startup_commands_without_legacy_fallback() {
    let mut conn = CdpConnection::new();
    let raw = serde_json::to_string(&json!({
        "id": 8,
        "method": "Page.getFrameTree",
        "sessionId": "STARTUP"
    }))
    .unwrap();
    let step = conn.start_command_dispatch(&raw);
    let messages = complete_messages(step);
    assert_eq!(messages.len(), 1);
    assert_eq!(messages[0]["id"], json!(8));
    assert_eq!(messages[0]["sessionId"], json!("STARTUP"));
    assert_eq!(
        messages[0]["result"]["frameTree"]["frame"]["id"],
        json!("TID-STARTUP")
    );
}

#[test]
fn command_dispatch_completes_unknown_domains_without_legacy_fallback() {
    let mut conn = CdpConnection::new();
    let mut bc = BrowserContext::new("BID-1".into());
    bc.set_active_target_id("TID-1");
    bc.attach_active_session("SID-1");
    conn.install_browser_context_fixture_for_test(bc);
    let raw = serde_json::to_string(&json!({
        "id": 9,
        "method": "Nope.command",
        "sessionId": "SID-1"
    }))
    .unwrap();
    let step = conn.start_command_dispatch(&raw);
    assert_eq!(
        complete_messages(step),
        vec![json!({
            "id": 9,
            "error": {"code": -32601, "message": "Unknown domain"},
            "sessionId": "SID-1"
        })]
    );
}

#[test]
fn command_dispatch_completes_console_log_and_inspector_owner_commands() {
    let mut conn = CdpConnection::new();
    conn.browser_context = Some(BrowserContext::new("BID-dispatch".to_owned()));

    for (id, method) in [
        (10, "Console.enable"),
        (11, "Log.enable"),
        (12, "Inspector.enable"),
    ] {
        let raw = serde_json::to_string(&json!({ "id": id, "method": method })).unwrap();
        let step = conn.start_command_dispatch(&raw);
        let messages = complete_messages(step);
        assert_eq!(
            messages[0],
            json!({ "id": id, "result": {} }),
            "{method} should complete through the command dispatch entry"
        );
    }
}

#[test]
fn command_dispatch_completes_browser_sync_commands() {
    let mut conn = CdpConnection::new();
    conn.publish_default_browser_target();
    for (id, method) in [
        (20, "Browser.getVersion"),
        (21, "Browser.getWindowForTarget"),
        (22, "Browser.setWindowBounds"),
        (23, "Browser.setDownloadBehavior"),
    ] {
        let params = match method {
            "Browser.setWindowBounds" => json!({
                "windowId": 1_923_710_101_i64,
                "bounds": { "windowState": "normal", "width": 800, "height": 600 }
            }),
            "Browser.setDownloadBehavior" => json!({
                "behavior": "allow",
                "downloadPath": "/tmp/moli-downloads"
            }),
            _ => json!({}),
        };
        let raw = serde_json::to_string(&json!({ "id": id, "method": method, "params": params }))
            .unwrap();
        let step = conn.start_command_dispatch(&raw);
        let messages = complete_messages(step);
        assert_eq!(messages.len(), 1, "{method} should emit one response");
        assert_eq!(messages[0]["id"], json!(id));
        assert!(
            messages[0].get("result").is_some(),
            "{method} should complete successfully: {:?}",
            messages[0]
        );
    }
}

#[test]
fn command_dispatch_completes_browser_owner_commands_without_legacy_fallback() {
    let mut conn = CdpConnection::new();
    for (id, method, params, expects_result) in [
        (
            24,
            "Browser.openDownloadAsStream",
            json!({ "guid": "missing-download-guid" }),
            false,
        ),
        (
            25,
            "Browser.setPermission",
            json!({
                "permission": { "name": "geolocation" },
                "setting": "denied"
            }),
            true,
        ),
        (
            26,
            "Browser.grantPermissions",
            json!({
                "permissions": [{ "name": "notifications" }]
            }),
            true,
        ),
        (27, "Browser.resetPermissions", json!({}), true),
    ] {
        let raw = serde_json::to_string(&json!({ "id": id, "method": method, "params": params }))
            .unwrap();
        let step = conn.start_command_dispatch(&raw);
        let messages = complete_messages(step);
        assert_eq!(messages.len(), 1, "{method} should emit one response");
        assert_eq!(messages[0]["id"], json!(id));
        if expects_result {
            assert!(
                messages[0].get("result").is_some(),
                "{method} should complete successfully: {:?}",
                messages[0]
            );
        } else {
            assert!(
                messages[0].get("error").is_some(),
                "{method} should complete with a protocol error: {:?}",
                messages[0]
            );
        }
    }
}

#[tokio::test(flavor = "multi_thread")]
async fn command_dispatch_completes_live_browser_permission_without_legacy_fallback() {
    let mut conn = CdpConnection::new();
    let mut browser_context = BrowserContext::new("BID-browser-permission-live".to_owned());
    browser_context.set_active_target_id("TID-browser-permission-live".to_owned());
    conn.install_browser_context_fixture_for_test(browser_context);
    let page = conn
        .load_page_via_runtime_async("data:text/html,<p>browser permission</p>")
        .await
        .expect("page should load");
    conn.browser_context
        .as_mut()
        .expect("browser context")
        .active_page_target_mut()
        .runtime_slot
        .set_loaded_page_for_test(page);

    let raw = serde_json::to_string(&json!({
        "id": 28,
        "method": "Browser.setPermission",
        "params": {
            "permission": { "name": "geolocation" },
            "setting": "denied"
        }
    }))
    .unwrap();
    let pending = match conn.start_command_dispatch(&raw) {
        CdpCommandTaskStep::Pending(pending) => pending,
        CdpCommandTaskStep::Complete(_) => {
            panic!("live Browser.setPermission should update the live page")
        }
    };
    let completed = pending.wait().await;
    let step = conn.complete_pending_command_dispatch(completed).await;
    assert_eq!(
        complete_messages(step),
        vec![json!({ "id": 28, "result": {} })]
    );
    assert_eq!(conn.permission_overrides.len(), 1);
}

async fn browser_permission_fixture_connection() -> CdpConnection {
    let mut conn = CdpConnection::new();
    let mut context = BrowserContext::new("BID-permission-owner".to_owned());
    context.set_active_target_id("TID-permission-owner".to_owned());
    conn.install_browser_context_fixture_for_test(context);
    let seed = json!({
        "id": 90,
        "method": "Browser.setPermission",
        "params": {"permission": {"name": "geolocation"}, "setting": "prompt"}
    })
    .to_string();
    assert_eq!(
        complete_messages(conn.start_command_dispatch(&seed)),
        vec![json!({"id": 90, "result": {}})]
    );
    let page = conn
        .load_page_via_runtime_async("data:text/html,<p>permission owner</p>")
        .await
        .expect("permission owner should load");
    conn.browser_context
        .as_mut()
        .expect("browser context")
        .active_page_target_mut()
        .runtime_slot
        .set_loaded_page_for_test(page);
    conn
}

fn browser_permission_owner_cases() -> [(&'static str, Value, Option<&'static str>); 3] {
    [
        (
            "Browser.setPermission",
            json!({"permission": {"name": "geolocation"}, "setting": "denied"}),
            Some("denied"),
        ),
        (
            "Browser.grantPermissions",
            json!({"permissions": ["geolocation"]}),
            Some("granted"),
        ),
        ("Browser.resetPermissions", json!({}), None),
    ]
}

#[tokio::test(flavor = "multi_thread")]
async fn command_dispatch_completes_browser_permissions_after_page_closes() {
    for (method, params, expected_setting) in browser_permission_owner_cases() {
        let mut conn = browser_permission_fixture_connection().await;
        let raw = json!({"id": 91, "method": method, "params": params}).to_string();
        let pending = match conn.start_command_dispatch(&raw) {
            CdpCommandTaskStep::Pending(pending) => pending,
            CdpCommandTaskStep::Complete(_) => panic!("{method} should dispatch to the owner"),
        };
        let completed = pending.wait().await;
        let old_page = conn
            .browser_context
            .as_mut()
            .expect("browser context")
            .active_page_target_mut()
            .runtime_slot
            .clear_loaded_page_for_test_fixture();
        assert!(old_page.is_some());
        drop(old_page);

        let step = conn.complete_pending_command_dispatch(completed).await;
        assert_eq!(
            complete_messages(step),
            vec![json!({"id": 91, "result": {}})],
            "a settled {method} must survive removal of its renderer Page"
        );
        assert_eq!(
            conn.permission_overrides
                .last()
                .map(|entry| entry.setting.as_str()),
            expected_setting,
            "the browser retains the requested permission policy"
        );
    }
}

#[tokio::test(flavor = "multi_thread")]
async fn command_dispatch_completes_browser_permissions_when_owner_closes_before_reply() {
    for (method, params, expected_setting) in browser_permission_owner_cases() {
        let mut conn = browser_permission_fixture_connection().await;
        let raw = json!({"id": 93, "method": method, "params": params}).to_string();
        let pending = match conn.start_command_dispatch(&raw) {
            CdpCommandTaskStep::Pending(pending) => pending,
            CdpCommandTaskStep::Complete(_) => panic!("{method} should dispatch to the owner"),
        };
        let old_page = conn
            .browser_context
            .as_mut()
            .expect("browser context")
            .active_page_target_mut()
            .runtime_slot
            .clear_loaded_page_for_test_fixture();
        assert!(old_page.is_some());
        drop(old_page);

        let completed = pending.wait().await;
        let step = conn.complete_pending_command_dispatch(completed).await;
        assert_eq!(
            complete_messages(step),
            vec![json!({"id": 93, "result": {}})],
            "closing a renderer must not cancel the committed {method} policy"
        );
        assert_eq!(
            conn.permission_overrides
                .last()
                .map(|entry| entry.setting.as_str()),
            expected_setting
        );
    }
}

#[tokio::test(flavor = "multi_thread")]
async fn command_dispatch_does_not_replay_browser_permission_snapshot_on_replacement() {
    for (method, params, expected_setting) in browser_permission_owner_cases() {
        let mut conn = browser_permission_fixture_connection().await;
        let raw = json!({"id": 92, "method": method, "params": params}).to_string();
        let pending = match conn.start_command_dispatch(&raw) {
            CdpCommandTaskStep::Pending(pending) => pending,
            CdpCommandTaskStep::Complete(_) => panic!("{method} should dispatch to the owner"),
        };
        let completed = pending.wait().await;
        let replacement_url = "data:text/html,<p>replacement permission owner</p>";
        let replacement = conn
            .load_page_via_runtime_async(replacement_url)
            .await
            .expect("replacement should load");
        let replacement_id = replacement.page_id();
        conn.browser_context
            .as_mut()
            .expect("browser context")
            .active_page_target_mut()
            .runtime_slot
            .set_loaded_page_for_test(replacement);

        let step = conn.complete_pending_command_dispatch(completed).await;
        assert_eq!(
            complete_messages(step),
            vec![json!({"id": 92, "result": {}})]
        );
        let page = conn
            .browser_context
            .as_ref()
            .expect("browser context")
            .active_page_target()
            .loaded_page()
            .expect("replacement should remain loaded");
        assert_eq!(page.page_id(), replacement_id);
        assert_eq!(
            page.requested_url().as_str(),
            replacement_url,
            "{method} must not install the old PageState on the replacement"
        );
        assert_eq!(
            conn.permission_overrides
                .last()
                .map(|entry| entry.setting.as_str()),
            expected_setting
        );
    }
}

#[tokio::test]
async fn command_dispatch_completes_target_startup_commands_without_legacy_fallback() {
    let mut conn = CdpConnection::new();
    let create_raw = serde_json::to_string(&json!({
        "id": 29,
        "method": "Target.createTarget",
        "params": { "url": "about:blank" }
    }))
    .unwrap();
    let create_step = conn.start_command_dispatch(&create_raw);
    let create_messages = match create_step {
        CdpCommandTaskStep::Pending(pending) => {
            complete_command_task_for_test(&mut conn, *pending).await
        }
        CdpCommandTaskStep::Complete(outcome) => outcome.into_parts().0,
    };
    assert_eq!(create_messages.len(), 1);
    assert_eq!(create_messages[0]["id"], json!(29));
    let target_id = create_messages[0]["result"]["targetId"]
        .as_str()
        .expect("createTarget should return targetId")
        .to_owned();
    let browser_context = conn.browser_context.as_ref().expect("browser context");
    assert_eq!(browser_context.active_target_id(), Some(target_id.as_str()));
    assert!(
        browser_context
            .active_page_target()
            .runtime_slot
            .has_loaded_page(),
        "Target.createTarget should complete target lifecycle initial document ensure"
    );

    let attach_raw = serde_json::to_string(&json!({
        "id": 30,
        "method": "Target.attachToTarget",
        "params": { "targetId": target_id }
    }))
    .unwrap();
    let attach_step = conn.start_command_dispatch(&attach_raw);
    let attach_messages = match attach_step {
        CdpCommandTaskStep::Pending(pending) => {
            complete_command_task_for_test(&mut conn, *pending).await
        }
        CdpCommandTaskStep::Complete(outcome) => outcome.into_parts().0,
    };
    assert_eq!(attach_messages.len(), 2);
    assert_eq!(
        attach_messages[0]["method"],
        json!("Target.attachedToTarget")
    );
    let attached_session_id = attach_messages[0]["params"]["sessionId"]
        .as_str()
        .expect("attachedToTarget should identify the new session");
    assert_eq!(attach_messages[1]["id"], json!(30));
    assert_eq!(
        attach_messages[1]["result"]["sessionId"],
        json!(attached_session_id)
    );
}

#[test]
fn command_dispatch_completes_network_sync_settings() {
    let mut conn = CdpConnection::new();
    conn.browser_context = Some(BrowserContext::new_with_page_for_test(
        "BID-network",
        "TID-network",
    ));

    for (id, method, params) in [
        (30, "Network.enable", json!({})),
        (31, "Network.disable", json!({})),
        (
            32,
            "Network.setCacheDisabled",
            json!({"cacheDisabled": true}),
        ),
        (
            33,
            "Network.setBypassServiceWorker",
            json!({"bypass": true}),
        ),
    ] {
        let raw = serde_json::to_string(&json!({ "id": id, "method": method, "params": params }))
            .unwrap();
        let step = conn.start_command_dispatch(&raw);
        assert_eq!(
            complete_messages(step),
            vec![json!({ "id": id, "result": {} })],
            "{method} should complete through the command dispatch entry"
        );
    }
}

#[test]
fn command_dispatch_completes_page_dialog_without_legacy_fallback() {
    let mut conn = CdpConnection::new();
    let raw = serde_json::to_string(&json!({
        "id": 40,
        "method": "Page.handleJavaScriptDialog",
        "params": {"accept": true}
    }))
    .unwrap();
    let step = conn.start_command_dispatch(&raw);
    assert_eq!(
        complete_messages(step),
        vec![json!({
            "id": 40,
            "error": {"code": -32602, "message": "No dialog is showing"}
        })]
    );
}

#[test]
fn command_dispatch_reports_no_document_for_default_page_screenshot() {
    let mut conn = crate::testing::real_layout_test_connection();
    conn.browser_context = Some(BrowserContext::new("BID-page-shot".to_owned()));
    let raw = serde_json::to_string(&json!({
        "id": 41,
        "method": "Page.captureScreenshot"
    }))
    .unwrap();
    let step = conn.start_command_dispatch(&raw);
    assert_eq!(
        complete_messages(step),
        vec![json!({
            "id": 41,
            "error": {
                "code": -32000,
                "message": "NoDocumentLoaded"
            }
        })]
    );
}

#[test]
fn command_dispatch_preserves_page_screenshot_unsupported_for_mock_layout() {
    let mut conn = CdpConnection::new_with_initial_storage_partition_and_runtime_config(
        crate::CdpInitialStoragePartition::memory(),
        moli_core::runtime::NavigationRuntimeConfig::new(
            moli_fetch::FetchConfig::default(),
            moli_core::OptionalResourceFetchMask::NONE,
            true,
            moli_core::LayoutPolicy::Mock,
        ),
    );
    conn.browser_context = Some(BrowserContext::new("BID-page-shot-mock".to_owned()));
    let raw = serde_json::to_string(&json!({
        "id": 42,
        "method": "Page.captureScreenshot"
    }))
    .unwrap();
    let step = conn.start_command_dispatch(&raw);
    assert_eq!(
        complete_messages(step),
        vec![json!({
            "id": 42,
            "error": {
                "code": -32000,
                "message": "Page.captureScreenshot is not supported: renderer layout is disabled; start Moli with --layout."
            }
        })]
    );
}

#[test]
fn command_dispatch_completes_additional_page_sync_commands_without_legacy_fallback() {
    let mut conn = CdpConnection::new();
    let mut browser_context = BrowserContext::new("BID-page-sync".to_owned());
    browser_context.set_active_target_id("TID-page-sync");
    conn.install_browser_context_fixture_for_test(browser_context);

    let download_raw = serde_json::to_string(&json!({
        "id": 411,
        "method": "Page.setDownloadBehavior",
        "params": { "behavior": "allow", "downloadPath": "/tmp/moli-downloads" }
    }))
    .unwrap();
    let step = conn.start_command_dispatch(&download_raw);
    assert_eq!(
        complete_messages(step),
        vec![json!({ "id": 411, "result": {} })]
    );
    let settings = conn
        .download_behavior
        .effective_for_browser_context(Some("BID-page-sync"));
    assert_eq!(settings.behavior, "allow");

    let metrics_raw = serde_json::to_string(&json!({
        "id": 412,
        "method": "Page.getLayoutMetrics"
    }))
    .unwrap();
    let step = conn.start_command_dispatch(&metrics_raw);
    let messages = complete_messages(step);
    assert_eq!(messages.len(), 1);
    assert_eq!(messages[0]["id"], json!(412));
    assert_eq!(messages[0]["error"]["code"], -32000);
    assert_eq!(messages[0]["error"]["message"], "NoDocumentLoaded");

    let print_raw = serde_json::to_string(&json!({
        "id": 413,
        "method": "Page.printToPDF"
    }))
    .unwrap();
    let step = conn.start_command_dispatch(&print_raw);
    assert_eq!(
        complete_messages(step),
        vec![json!({
            "id": 413,
            "error": {
                "code": -32000,
                "message": "Page.printToPDF is not supported: renderer layout is disabled; start Moli with --layout."
            }
        })]
    );
}

#[test]
fn command_dispatch_migrates_page_navigation_and_termination_without_legacy_fallback() {
    let mut conn = CdpConnection::new();
    let navigate_raw = serde_json::to_string(&json!({
        "id": 413,
        "method": "Page.navigate",
        "params": { "url": "data:text/html,navigate" }
    }))
    .unwrap();
    let _navigate_step = conn.start_command_dispatch(&navigate_raw);

    for (method, params) in [
        ("Page.navigateToHistoryEntry", json!({"entryId": 1})),
        ("Page.reload", json!({})),
    ] {
        let raw = serde_json::to_string(&json!({
            "id": 414,
            "method": method,
            "params": params
        }))
        .unwrap();
        let _step = conn.start_command_dispatch(&raw);
    }

    for method in ["Page.crash", "Page.stopLoading", "Page.close"] {
        let raw = serde_json::to_string(&json!({ "id": 414, "method": method })).unwrap();
        let _step = conn.start_command_dispatch(&raw);
    }
}

#[test]
fn command_dispatch_completes_page_create_isolated_world_errors_without_legacy_fallback() {
    let mut conn = CdpConnection::new();
    let raw = serde_json::to_string(&json!({
        "id": 415,
        "method": "Page.createIsolatedWorld",
        "params": {
            "frameId": "TID-1",
            "worldName": "utility"
        }
    }))
    .unwrap();
    let step = conn.start_command_dispatch(&raw);
    assert_eq!(
        complete_messages(step),
        vec![json!({
            "id": 415,
            "error": {
                "code": -31998,
                "message": "BrowserContextNotLoaded"
            }
        })]
    );
}

#[test]
fn command_dispatch_completes_dom_sync_and_error_commands_without_legacy_fallback() {
    let mut conn = CdpConnection::new();

    let enable_raw = serde_json::to_string(&json!({
        "id": 421,
        "method": "DOM.enable"
    }))
    .unwrap();
    let step = conn.start_command_dispatch(&enable_raw);
    assert_eq!(
        complete_messages(step),
        vec![json!({ "id": 421, "result": {} })]
    );

    let get_document_raw = serde_json::to_string(&json!({
        "id": 422,
        "method": "DOM.getDocument"
    }))
    .unwrap();
    let step = conn.start_command_dispatch(&get_document_raw);
    assert_eq!(
        complete_messages(step),
        vec![json!({
            "id": 422,
            "error": {
                "code": -31998,
                "message": "BrowserContextNotLoaded"
            }
        })]
    );

    let discard_raw = serde_json::to_string(&json!({
        "id": 423,
        "method": "DOM.discardSearchResults",
        "params": { "searchId": "missing" }
    }))
    .unwrap();
    let step = conn.start_command_dispatch(&discard_raw);
    assert_eq!(
        complete_messages(step),
        vec![json!({ "id": 423, "result": {} })]
    );

    conn.browser_context = Some(BrowserContext::new("BID-dom-sync".to_owned()));
    let unknown_raw = serde_json::to_string(&json!({
        "id": 424,
        "method": "DOM.noSuchMethod"
    }))
    .unwrap();
    let step = conn.start_command_dispatch(&unknown_raw);
    assert_eq!(
        complete_messages(step),
        vec![json!({
            "id": 424,
            "error": {
                "code": -32601,
                "message": "UnknownMethod"
            }
        })]
    );
}

#[tokio::test(flavor = "multi_thread")]
async fn command_dispatch_completes_live_page_preload_without_legacy_fallback() {
    let mut ctx = crate::testing::TestContext::new();
    let mut browser_context = BrowserContext::new("BID-page-preload-live".to_owned());
    browser_context.set_active_target_id("TID-page-preload-live".to_owned());
    browser_context.attach_active_session("SID-page-preload-live");
    ctx.conn
        .install_browser_context_fixture_for_test(browser_context);
    let page = ctx
        .conn
        .load_page_via_runtime_async("data:text/html,<p>preload</p>")
        .await
        .expect("page should load");
    ctx.conn
        .browser_context
        .as_mut()
        .expect("browser context")
        .active_page_target_mut()
        .runtime_slot
        .set_loaded_page_for_test(page);

    let add_raw = serde_json::to_string(&json!({
        "id": 42,
        "method": "Page.addScriptToEvaluateOnNewDocument",
        "sessionId": "SID-page-preload-live",
        "params": {
            "source": "globalThis.__dispatchPreload = true;",
            "worldName": "__dispatch_world"
        }
    }))
    .unwrap();
    let add_pending = match ctx.conn.start_command_dispatch(&add_raw) {
        CdpCommandTaskStep::Pending(pending) => pending,
        CdpCommandTaskStep::Complete(_) => {
            panic!("live Page.addScriptToEvaluateOnNewDocument should update the live page")
        }
    };
    let (add_messages, _) = ctx
        .complete_command_task_step_for_test(CdpCommandTaskStep::Pending(add_pending))
        .await;
    assert_eq!(add_messages.len(), 1);
    assert_eq!(add_messages[0]["id"], json!(42));
    assert_eq!(add_messages[0]["sessionId"], json!("SID-page-preload-live"));
    let identifier = add_messages[0]["result"]["identifier"]
        .as_str()
        .expect("preload identifier")
        .to_owned();
    assert!(
        ctx.conn
            .browser_context
            .as_ref()
            .expect("browser context")
            .active_page_target()
            .owner_state
            .document_start_scripts
            .iter()
            .any(|(stored_id, script)| {
                stored_id == &identifier
                    && script.source == "globalThis.__dispatchPreload = true;"
                    && script.world_name.as_deref() == Some("__dispatch_world")
            }),
        "preload should be persisted on the owner state"
    );

    let remove_raw = serde_json::to_string(&json!({
        "id": 43,
        "method": "Page.removeScriptToEvaluateOnNewDocument",
        "sessionId": "SID-page-preload-live",
        "params": { "identifier": identifier }
    }))
    .unwrap();
    let remove_pending = match ctx.conn.start_command_dispatch(&remove_raw) {
        CdpCommandTaskStep::Pending(pending) => pending,
        CdpCommandTaskStep::Complete(_) => {
            panic!("live Page.removeScriptToEvaluateOnNewDocument should update the live page")
        }
    };
    let (remove_messages, _) = ctx
        .complete_command_task_step_for_test(CdpCommandTaskStep::Pending(remove_pending))
        .await;
    assert_eq!(
        remove_messages,
        vec![json!({
            "id": 43,
            "sessionId": "SID-page-preload-live",
            "result": {}
        })]
    );
    assert!(
        ctx.conn
            .browser_context
            .as_ref()
            .expect("browser context")
            .active_page_target()
            .owner_state
            .document_start_scripts
            .is_empty(),
        "preload removal should clear persisted owner state"
    );

    let create_world_raw = serde_json::to_string(&json!({
        "id": 44,
        "method": "Page.createIsolatedWorld",
        "sessionId": "SID-page-preload-live",
        "params": {
            "frameId": "TID-page-preload-live",
            "worldName": "__dispatch_world"
        }
    }))
    .unwrap();
    let create_world_pending = match ctx.conn.start_command_dispatch(&create_world_raw) {
        CdpCommandTaskStep::Pending(pending) => pending,
        CdpCommandTaskStep::Complete(_) => {
            panic!("live Page.createIsolatedWorld should use explicit pending page dispatch")
        }
    };
    let (create_world_messages, _) = ctx
        .complete_command_task_step_for_test(CdpCommandTaskStep::Pending(create_world_pending))
        .await;
    assert_eq!(create_world_messages.len(), 1);
    assert_eq!(create_world_messages[0]["id"], json!(44));
    assert_eq!(
        create_world_messages[0]["sessionId"],
        json!("SID-page-preload-live")
    );
    assert!(
        create_world_messages[0]["result"]["executionContextId"]
            .as_i64()
            .is_some(),
        "createIsolatedWorld should return an execution context id"
    );
}

#[test]
fn command_dispatch_completes_target_sync_commands() {
    let mut conn = CdpConnection::new();

    for (id, method) in [
        (50, "Target.createBrowserContext"),
        (51, "Target.getBrowserContexts"),
        (52, "Target.getTargets"),
        (53, "Target.attachToBrowserTarget"),
        (54, "Target.getTargetInfo"),
        (55, "Target.setDiscoverTargets"),
    ] {
        let params = match method {
            "Target.setDiscoverTargets" => json!({"discover": true}),
            _ => json!({}),
        };
        let raw = serde_json::to_string(&json!({ "id": id, "method": method, "params": params }))
            .unwrap();
        let step = conn.start_command_dispatch(&raw);
        let messages = complete_messages(step);
        assert!(
            messages.iter().any(
                |message| message.get("id").and_then(Value::as_u64) == Some(id)
                    && message.get("result").is_some()
            ),
            "{method} should emit a successful command response: {messages:?}"
        );
    }
}

#[tokio::test(flavor = "multi_thread")]
async fn command_dispatch_completes_target_activate_without_legacy_fallback() {
    let mut conn = CdpConnection::new();
    let mut browser_context = BrowserContext::new("BID-target-activate".to_owned());
    browser_context.set_active_target_id("TID-target-activate".to_owned());
    conn.install_browser_context_fixture_for_test(browser_context);

    let raw = serde_json::to_string(&json!({
        "id": 56,
        "method": "Target.activateTarget",
        "params": { "targetId": "TID-target-activate" }
    }))
    .unwrap();
    let pending = match conn.start_command_dispatch(&raw) {
        CdpCommandTaskStep::Pending(pending) => pending,
        CdpCommandTaskStep::Complete(_) => {
            panic!("Target.activateTarget should use the Target pending dispatcher")
        }
    };
    assert_eq!(
        complete_command_task_for_test(&mut conn, *pending).await,
        vec![json!({ "id": 56, "result": {} })]
    );
}

#[tokio::test(flavor = "multi_thread")]
async fn command_dispatch_completes_target_set_auto_attach_without_legacy_fallback() {
    let mut conn = CdpConnection::new();
    let mut browser_context = BrowserContext::new("BID-target-auto-attach".to_owned());
    browser_context.set_active_target_id("TID-target-auto-attach".to_owned());
    conn.install_browser_context_fixture_for_test(browser_context);

    let raw = serde_json::to_string(&json!({
        "id": 57,
        "method": "Target.setAutoAttach",
        "params": {
            "autoAttach": true,
            "waitForDebuggerOnStart": false
        }
    }))
    .unwrap();
    let pending = match conn.start_command_dispatch(&raw) {
        CdpCommandTaskStep::Pending(pending) => pending,
        CdpCommandTaskStep::Complete(_) => {
            panic!("Target.setAutoAttach should use the Target pending dispatcher")
        }
    };
    let messages = complete_command_task_for_test(&mut conn, *pending).await;
    assert_eq!(messages.len(), 2);
    assert_eq!(messages[0]["method"], json!("Target.attachedToTarget"));
    assert_eq!(messages[0]["params"]["waitingForDebugger"], json!(false));
    assert!(
        messages[0]["params"]["sessionId"].as_str().is_some(),
        "auto attach should assign a session"
    );
    assert_eq!(messages[1], json!({ "id": 57, "result": {} }));
}

#[tokio::test(flavor = "multi_thread")]
async fn command_dispatch_completes_page_bring_to_front_without_legacy_fallback() {
    let mut conn = CdpConnection::new();
    let mut browser_context = BrowserContext::new("BID-page-bring".to_owned());
    browser_context.set_active_target_id("TID-page-bring".to_owned());
    browser_context.attach_active_session("SID-page-bring".to_owned());
    conn.install_browser_context_fixture_for_test(browser_context);

    let raw = serde_json::to_string(&json!({
        "id": 5701,
        "method": "Page.bringToFront",
        "sessionId": "SID-page-bring"
    }))
    .unwrap();
    let pending = match conn.start_command_dispatch(&raw) {
        CdpCommandTaskStep::Pending(pending) => pending,
        CdpCommandTaskStep::Complete(_) => {
            panic!("Page.bringToFront should use the Page pending dispatcher")
        }
    };
    assert_eq!(
        complete_command_task_for_test(&mut conn, *pending).await,
        vec![json!({
            "id": 5701,
            "result": {},
            "sessionId": "SID-page-bring"
        })]
    );
}

#[tokio::test(flavor = "multi_thread")]
async fn command_dispatch_completes_target_detach_without_legacy_fallback() {
    let mut conn = CdpConnection::new();
    let mut browser_context = BrowserContext::new("BID-target-detach".to_owned());
    browser_context.set_active_target_id("TID-target-detach".to_owned());
    browser_context.attach_active_session("SID-target-detach".to_owned());
    conn.install_browser_context_fixture_for_test(browser_context);

    let raw = serde_json::to_string(&json!({
        "id": 58,
        "method": "Target.detachFromTarget",
        "params": {
            "targetId": "TID-target-detach",
            "sessionId": "SID-target-detach"
        }
    }))
    .unwrap();
    let pending = match conn.start_command_dispatch(&raw) {
        CdpCommandTaskStep::Pending(pending) => pending,
        CdpCommandTaskStep::Complete(_) => {
            panic!("Target.detachFromTarget should use the Target pending dispatcher")
        }
    };
    let messages = complete_command_task_for_test(&mut conn, *pending).await;
    assert_eq!(messages.len(), 2);
    assert_eq!(messages[0], json!({ "id": 58, "result": {} }));
    assert_eq!(messages[1]["method"], json!("Target.detachedFromTarget"));
    assert_eq!(
        messages[1]["params"],
        json!({
            "targetId": "TID-target-detach",
            "sessionId": "SID-target-detach"
        })
    );
    assert!(
        !conn
            .browser_context
            .as_ref()
            .expect("browser context should remain loaded")
            .has_active_session()
    );
}

#[tokio::test(flavor = "multi_thread")]
async fn command_dispatch_completes_target_close_without_legacy_fallback() {
    let mut conn = CdpConnection::new();
    let mut browser_context = BrowserContext::new("BID-target-close".to_owned());
    browser_context.set_active_target_id("TID-target-close".to_owned());
    browser_context.attach_active_session("SID-target-close".to_owned());
    conn.install_browser_context_fixture_for_test(browser_context);

    let raw = serde_json::to_string(&json!({
        "id": 59,
        "method": "Target.closeTarget",
        "params": { "targetId": "TID-target-close" }
    }))
    .unwrap();
    let pending = match conn.start_command_dispatch(&raw) {
        CdpCommandTaskStep::Pending(pending) => pending,
        CdpCommandTaskStep::Complete(_) => {
            panic!("Target.closeTarget should use the Target pending dispatcher")
        }
    };
    let messages = complete_command_task_for_test(&mut conn, *pending).await;
    assert_eq!(messages.len(), 3);
    assert_eq!(
        messages[0],
        json!({ "id": 59, "result": { "success": true } })
    );
    assert_eq!(messages[1]["method"], json!("Inspector.detached"));
    assert_eq!(messages[1]["sessionId"], json!("SID-target-close"));
    assert_eq!(
        messages[1]["params"],
        json!({ "reason": "Render process gone." })
    );
    assert_eq!(messages[2]["method"], json!("Target.detachedFromTarget"));
    assert_eq!(
        messages[2]["params"],
        json!({
            "targetId": "TID-target-close",
            "sessionId": "SID-target-close"
        })
    );
    assert!(
        conn.browser_context
            .as_ref()
            .expect("browser context should remain loaded")
            .active_target_identity()
            .is_none(),
        "closing the selected target should leave the context without an active target"
    );
}

#[tokio::test(flavor = "multi_thread")]
async fn command_dispatch_completes_target_dispose_browser_context_without_legacy_fallback() {
    let mut conn = CdpConnection::new();
    let mut browser_context = BrowserContext::new("BID-target-dispose".to_owned());
    browser_context.set_active_target_id("TID-target-dispose".to_owned());
    browser_context.attach_active_session("SID-target-dispose".to_owned());
    conn.install_browser_context_fixture_for_test(browser_context);

    let raw = serde_json::to_string(&json!({
        "id": 60,
        "method": "Target.disposeBrowserContext",
        "params": { "browserContextId": "BID-target-dispose" }
    }))
    .unwrap();
    let pending = match conn.start_command_dispatch(&raw) {
        CdpCommandTaskStep::Pending(pending) => pending,
        CdpCommandTaskStep::Complete(_) => {
            panic!("Target.disposeBrowserContext should use the Target pending dispatcher")
        }
    };
    let messages = complete_command_task_for_test(&mut conn, *pending).await;
    assert_eq!(messages.len(), 3);
    assert_eq!(messages[0], json!({ "id": 60, "result": {} }));
    assert_eq!(messages[1]["method"], json!("Inspector.detached"));
    assert_eq!(
        messages[1]["params"],
        json!({ "reason": "Render process gone." })
    );
    assert_eq!(messages[1]["sessionId"], json!("SID-target-dispose"));
    assert_eq!(messages[2]["method"], json!("Target.detachedFromTarget"));
    assert_eq!(
        messages[2]["params"],
        json!({
            "targetId": "TID-target-dispose",
            "sessionId": "SID-target-dispose"
        })
    );
    assert!(
        conn.browser_context.is_none(),
        "disposing the active browser context should remove it"
    );
}

#[tokio::test(flavor = "multi_thread")]
async fn command_dispatch_completes_target_send_message_without_legacy_fallback() {
    let mut conn = CdpConnection::new();
    let mut browser_context = BrowserContext::new("BID-target-send".to_owned());
    browser_context.set_active_target_id("TID-target-send".to_owned());
    browser_context.attach_active_session("SID-target-send".to_owned());
    conn.install_browser_context_fixture_for_test(browser_context);

    let nested = serde_json::to_string(&json!({
        "id": 6101,
        "method": "Target.getBrowserContexts"
    }))
    .unwrap();
    let raw = serde_json::to_string(&json!({
        "id": 61,
        "method": "Target.sendMessageToTarget",
        "params": {
            "message": nested,
            "sessionId": "SID-target-send"
        }
    }))
    .unwrap();
    let pending = match conn.start_command_dispatch(&raw) {
        CdpCommandTaskStep::Pending(pending) => pending,
        CdpCommandTaskStep::Complete(_) => {
            panic!("Target.sendMessageToTarget should use the Target pending dispatcher")
        }
    };
    let messages = complete_command_task_for_test(&mut conn, *pending).await;
    assert_eq!(messages.len(), 2);
    assert_eq!(messages[0], json!({ "id": 61, "result": {} }));
    assert_eq!(
        messages[1]["method"],
        json!("Target.receivedMessageFromTarget")
    );
    assert_eq!(messages[1]["params"]["sessionId"], "SID-target-send");
    let nested: Value = serde_json::from_str(
        messages[1]["params"]["message"]
            .as_str()
            .expect("nested message should be stringified"),
    )
    .expect("nested message should be valid JSON");
    assert_eq!(nested["id"], 6101);
    assert_eq!(
        nested["result"]["browserContextIds"],
        json!(["BID-target-send"])
    );
}

#[test]
fn command_dispatch_completes_cookie_read_commands() {
    let mut conn = CdpConnection::new();
    conn.browser_context = Some(BrowserContext::new("BID-cookie".to_owned()));

    for (id, method) in [
        (60, "Storage.getCookies"),
        (61, "Storage.clearCookies"),
        (62, "Storage.deleteCookies"),
        (63, "Storage.setCookies"),
        (64, "Network.getCookies"),
        (65, "Network.getAllCookies"),
        (66, "Network.clearBrowserCookies"),
        (67, "Network.setCookie"),
        (68, "Network.setCookies"),
    ] {
        let params = match method {
            "Storage.deleteCookies" | "Network.deleteCookies" => json!({"name": "missing"}),
            "Network.setCookie" => json!({
                "name": "network_sid",
                "value": "1",
                "url": "https://example.com/app"
            }),
            "Storage.setCookies" | "Network.setCookies" => json!({
                "cookies": [{
                    "name": "sid",
                    "value": "1",
                    "url": "https://example.com/app"
                }]
            }),
            _ => json!({}),
        };
        let raw = serde_json::to_string(&json!({ "id": id, "method": method, "params": params }))
            .unwrap();
        let step = conn.start_command_dispatch(&raw);
        let messages = complete_messages(step);
        assert_eq!(messages.len(), 1, "{method} should emit one response");
        assert_eq!(messages[0]["id"], json!(id));
        assert!(
            messages[0].get("result").is_some(),
            "{method} should complete successfully: {:?}",
            messages[0]
        );
    }
}

#[tokio::test(flavor = "multi_thread")]
async fn command_dispatch_completes_live_storage_set_cookies_without_legacy_fallback() {
    let mut conn = CdpConnection::new();
    let mut browser_context = BrowserContext::new("BID-storage-live".to_owned());
    browser_context.set_active_target_id("TID-storage-live".to_owned());
    conn.install_browser_context_fixture_for_test(browser_context);
    let page = conn
        .load_page_via_runtime_async("data:text/html,<p>storage</p>")
        .await
        .expect("page should load");
    conn.browser_context
        .as_mut()
        .expect("browser context")
        .active_page_target_mut()
        .runtime_slot
        .set_loaded_page_for_test(page);

    let raw = serde_json::to_string(&json!({
        "id": 67,
        "method": "Storage.setCookies",
        "params": {
            "browserContextId": "BID-storage-live",
            "cookies": [{
                "name": "sid",
                "value": "1",
                "url": "https://example.com/app"
            }]
        }
    }))
    .unwrap();
    let pending = match conn.start_command_dispatch(&raw) {
        CdpCommandTaskStep::Pending(pending) => pending,
        CdpCommandTaskStep::Complete(_) => {
            panic!("live Storage.setCookies should snapshot the page cookie owner")
        }
    };
    let completed = pending.wait().await;
    let step = conn.complete_pending_command_dispatch(completed).await;
    let messages = complete_messages(step);
    assert_eq!(messages.len(), 1);
    assert_eq!(messages[0]["id"], json!(67));
    assert_eq!(messages[0]["result"]["success"], json!(true));
    assert_eq!(
        messages[0]["result"]["cookieReports"][0]["status"]["kind"],
        json!("Accepted")
    );
}

#[tokio::test(flavor = "multi_thread")]
async fn command_dispatch_completes_live_network_extra_headers_without_legacy_fallback() {
    let mut conn = CdpConnection::new();
    let mut browser_context = BrowserContext::new("BID-network-live".to_owned());
    browser_context.set_active_target_id("TID-network-live".to_owned());
    conn.install_browser_context_fixture_for_test(browser_context);
    let page = conn
        .load_page_via_runtime_async("data:text/html,<p>network</p>")
        .await
        .expect("page should load");
    conn.browser_context
        .as_mut()
        .expect("browser context")
        .active_page_target_mut()
        .runtime_slot
        .set_loaded_page_for_test(page);

    let raw = serde_json::to_string(&json!({
        "id": 68,
        "method": "Network.setExtraHTTPHeaders",
        "params": { "headers": { "x-dispatch-test": "ok" } }
    }))
    .unwrap();
    let pending = match conn.start_command_dispatch(&raw) {
        CdpCommandTaskStep::Pending(pending) => pending,
        CdpCommandTaskStep::Complete(_) => {
            panic!("live Network.setExtraHTTPHeaders should update the live page")
        }
    };
    let completed = pending.wait().await;
    let step = conn.complete_pending_command_dispatch(completed).await;
    assert_eq!(
        complete_messages(step),
        vec![json!({ "id": 68, "result": {} })]
    );
}

#[tokio::test(flavor = "multi_thread")]
async fn command_dispatch_completes_live_network_blocked_urls_without_legacy_fallback() {
    let mut conn = CdpConnection::new();
    let mut browser_context = BrowserContext::new("BID-network-blocked-live".to_owned());
    browser_context.set_active_target_id("TID-network-blocked-live".to_owned());
    conn.install_browser_context_fixture_for_test(browser_context);
    let page = conn
        .load_page_via_runtime_async("data:text/html,<p>network blocked</p>")
        .await
        .expect("page should load");
    conn.browser_context
        .as_mut()
        .expect("browser context")
        .active_page_target_mut()
        .runtime_slot
        .set_loaded_page_for_test(page);

    let raw = serde_json::to_string(&json!({
        "id": 681,
        "method": "Network.setBlockedURLs",
        "params": { "urls": ["*://blocked-dispatch.test/*"] }
    }))
    .unwrap();
    let pending = match conn.start_command_dispatch(&raw) {
        CdpCommandTaskStep::Pending(pending) => pending,
        CdpCommandTaskStep::Complete(_) => {
            panic!("live Network.setBlockedURLs should update the live page")
        }
    };
    let completed = pending.wait().await;
    let step = conn.complete_pending_command_dispatch(completed).await;
    assert_eq!(
        complete_messages(step),
        vec![json!({ "id": 681, "result": {} })]
    );
}

#[tokio::test(flavor = "multi_thread")]
async fn command_dispatch_completes_live_network_set_cookie_without_legacy_fallback() {
    let mut conn = CdpConnection::new();
    let mut browser_context = BrowserContext::new("BID-network-cookie-live".to_owned());
    browser_context.set_active_target_id("TID-network-cookie-live".to_owned());
    conn.install_browser_context_fixture_for_test(browser_context);
    let page = conn
        .load_page_via_runtime_async("data:text/html,<p>network cookie</p>")
        .await
        .expect("page should load");
    conn.browser_context
        .as_mut()
        .expect("browser context")
        .active_page_target_mut()
        .runtime_slot
        .set_loaded_page_for_test(page);

    let raw = serde_json::to_string(&json!({
        "id": 69,
        "method": "Network.setCookie",
        "params": {
            "name": "network_sid",
            "value": "1",
            "url": "https://example.com/app"
        }
    }))
    .unwrap();
    let pending = match conn.start_command_dispatch(&raw) {
        CdpCommandTaskStep::Pending(pending) => pending,
        CdpCommandTaskStep::Complete(_) => {
            panic!("live Network.setCookie should snapshot the page cookie owner")
        }
    };
    let completed = pending.wait().await;
    let step = conn.complete_pending_command_dispatch(completed).await;
    let messages = complete_messages(step);
    assert_eq!(messages.len(), 1);
    assert_eq!(messages[0]["id"], json!(69));
    assert_eq!(messages[0]["result"]["success"], json!(true));
    assert_eq!(
        messages[0]["result"]["cookieReports"][0]["status"]["kind"],
        json!("Accepted")
    );
}

#[tokio::test(flavor = "multi_thread")]
async fn command_dispatch_completes_live_network_emulation_without_legacy_fallback() {
    let mut conn = CdpConnection::new();
    let mut browser_context = BrowserContext::new("BID-network-emulated-live".to_owned());
    browser_context.set_active_target_id("TID-network-emulated-live".to_owned());
    conn.install_browser_context_fixture_for_test(browser_context);
    let page = conn
        .load_page_via_runtime_async("data:text/html,<p>network emulated</p>")
        .await
        .expect("page should load");
    conn.browser_context
        .as_mut()
        .expect("browser context")
        .active_page_target_mut()
        .runtime_slot
        .set_loaded_page_for_test(page);

    let raw = serde_json::to_string(&json!({
        "id": 682,
        "method": "Network.emulateNetworkConditions",
        "params": {
            "offline": true,
            "latency": 0,
            "downloadThroughput": -1,
            "uploadThroughput": -1,
        }
    }))
    .unwrap();
    let pending = match conn.start_command_dispatch(&raw) {
        CdpCommandTaskStep::Pending(pending) => pending,
        CdpCommandTaskStep::Complete(_) => {
            panic!("live Network.emulateNetworkConditions should update the live page")
        }
    };
    let completed = pending.wait().await;
    let step = conn.complete_pending_command_dispatch(completed).await;
    assert_eq!(
        complete_messages(step),
        vec![json!({ "id": 682, "result": {} })]
    );
}

#[tokio::test(flavor = "multi_thread")]
async fn command_dispatch_completes_live_network_user_agent_without_legacy_fallback() {
    let mut conn = CdpConnection::new();
    let mut browser_context = BrowserContext::new("BID-network-ua-live".to_owned());
    browser_context.set_active_target_id("TID-network-ua-live".to_owned());
    conn.install_browser_context_fixture_for_test(browser_context);
    let page = conn
        .load_page_via_runtime_async("data:text/html,<p>network ua</p>")
        .await
        .expect("page should load");
    conn.browser_context
        .as_mut()
        .expect("browser context")
        .active_page_target_mut()
        .runtime_slot
        .set_loaded_page_for_test(page);

    let raw = serde_json::to_string(&json!({
        "id": 683,
        "method": "Network.setUserAgentOverride",
        "params": { "userAgent": "MoliDispatchNetworkUA/1.0" }
    }))
    .unwrap();
    let pending = match conn.start_command_dispatch(&raw) {
        CdpCommandTaskStep::Pending(pending) => pending,
        CdpCommandTaskStep::Complete(_) => {
            panic!("live Network.setUserAgentOverride should update the live page loader")
        }
    };
    let completed = pending.wait().await;
    let step = conn.complete_pending_command_dispatch(completed).await;
    assert_eq!(
        complete_messages(step),
        vec![json!({ "id": 683, "result": {} })]
    );
}

#[tokio::test(flavor = "multi_thread")]
async fn command_dispatch_completes_live_emulation_user_agent_without_legacy_fallback() {
    let mut conn = CdpConnection::new();
    let mut browser_context = BrowserContext::new("BID-emulation-ua-live".to_owned());
    browser_context.set_active_target_id("TID-emulation-ua-live".to_owned());
    conn.install_browser_context_fixture_for_test(browser_context);
    let page = conn
        .load_page_via_runtime_async("data:text/html,<p>emulation ua</p>")
        .await
        .expect("page should load");
    conn.browser_context
        .as_mut()
        .expect("browser context")
        .active_page_target_mut()
        .runtime_slot
        .set_loaded_page_for_test(page);

    let raw = serde_json::to_string(&json!({
        "id": 684,
        "method": "Emulation.setUserAgentOverride",
        "params": { "userAgent": "MoliDispatchEmulationUA/1.0" }
    }))
    .unwrap();
    let pending = match conn.start_command_dispatch(&raw) {
        CdpCommandTaskStep::Pending(pending) => pending,
        CdpCommandTaskStep::Complete(_) => {
            panic!("live Emulation.setUserAgentOverride should update the live page loader")
        }
    };
    let completed = pending.wait().await;
    let step = conn.complete_pending_command_dispatch(completed).await;
    assert_eq!(
        complete_messages(step),
        vec![json!({ "id": 684, "result": {} })]
    );
}

#[tokio::test(flavor = "multi_thread")]
async fn command_dispatch_completes_live_emulation_locale_without_legacy_fallback() {
    let mut conn = CdpConnection::new();
    let mut browser_context = BrowserContext::new("BID-emulation-locale-live".to_owned());
    browser_context.set_active_target_id("TID-emulation-locale-live".to_owned());
    conn.install_browser_context_fixture_for_test(browser_context);
    let page = conn
        .load_page_via_runtime_async("data:text/html,<p>emulation locale</p>")
        .await
        .expect("page should load");
    conn.browser_context
        .as_mut()
        .expect("browser context")
        .active_page_target_mut()
        .runtime_slot
        .set_loaded_page_for_test(page);

    let raw = serde_json::to_string(&json!({
        "id": 685,
        "method": "Emulation.setLocaleOverride",
        "params": { "locale": "fr-FR" }
    }))
    .unwrap();
    assert_eq!(
        complete_messages(conn.start_command_dispatch(&raw)),
        vec![json!({ "id": 685, "result": {} })]
    );
}

#[tokio::test(flavor = "multi_thread")]
async fn command_dispatch_completes_live_security_tls_without_legacy_fallback() {
    let mut conn = CdpConnection::new();
    let mut browser_context = BrowserContext::new("BID-security-tls-live".to_owned());
    browser_context.set_active_target_id("TID-security-tls-live".to_owned());
    conn.install_browser_context_fixture_for_test(browser_context);
    let page = conn
        .load_page_via_runtime_async("data:text/html,<p>security tls</p>")
        .await
        .expect("page should load");
    conn.browser_context
        .as_mut()
        .expect("browser context")
        .active_page_target_mut()
        .runtime_slot
        .set_loaded_page_for_test(page);

    let raw = serde_json::to_string(&json!({
        "id": 686,
        "method": "Security.setIgnoreCertificateErrors",
        "params": { "ignore": true }
    }))
    .unwrap();
    let pending = match conn.start_command_dispatch(&raw) {
        CdpCommandTaskStep::Pending(pending) => pending,
        CdpCommandTaskStep::Complete(_) => {
            panic!("live Security.setIgnoreCertificateErrors should update the live page loader")
        }
    };
    let completed = pending.wait().await;
    let step = conn.complete_pending_command_dispatch(completed).await;
    assert_eq!(
        complete_messages(step),
        vec![json!({ "id": 686, "result": {} })]
    );
    assert!(!conn.tls_verify_host());
}

#[tokio::test(flavor = "multi_thread")]
async fn command_dispatch_completes_live_fetch_enable_without_legacy_fallback() {
    let mut ctx = crate::testing::TestContext::new();
    let mut browser_context = BrowserContext::new("BID-fetch-live".to_owned());
    browser_context.set_active_target_id("TID-fetch-live".to_owned());
    ctx.conn
        .install_browser_context_fixture_for_test(browser_context);
    let page = ctx
        .conn
        .load_page_via_runtime_async("data:text/html,<p>fetch</p>")
        .await
        .expect("page should load");
    ctx.conn
        .browser_context
        .as_mut()
        .expect("browser context")
        .active_page_target_mut()
        .runtime_slot
        .set_loaded_page_for_test(page);

    let raw = serde_json::to_string(&json!({
        "id": 69,
        "method": "Fetch.enable",
        "params": {
            "patterns": [{ "urlPattern": "*", "requestStage": "Request" }]
        }
    }))
    .unwrap();
    let pending = match ctx.conn.start_command_dispatch(&raw) {
        CdpCommandTaskStep::Pending(pending) => pending,
        CdpCommandTaskStep::Complete(_) => {
            panic!("live Fetch.enable should update live page interception state")
        }
    };
    let completed = pending.wait().await;
    let step = ctx.conn.complete_pending_command_dispatch(completed).await;
    let (messages, _) = ctx.complete_command_task_step_for_test(step).await;
    assert_eq!(messages, vec![json!({ "id": 69, "result": {} })]);
}

#[tokio::test(flavor = "multi_thread")]
async fn command_dispatch_completes_live_fetch_disable_without_legacy_fallback() {
    let mut ctx = crate::testing::TestContext::new();
    let mut browser_context = BrowserContext::new("BID-fetch-disable-live".to_owned());
    browser_context.set_active_target_id("TID-fetch-disable-live".to_owned());
    browser_context
        .active_page_target_mut()
        .fetch_owner
        .configure(None, true, Vec::new());
    ctx.conn
        .install_browser_context_fixture_for_test(browser_context);
    let page = ctx
        .conn
        .load_page_via_runtime_async("data:text/html,<p>fetch disable</p>")
        .await
        .expect("page should load");
    ctx.conn
        .browser_context
        .as_mut()
        .expect("browser context")
        .active_page_target_mut()
        .runtime_slot
        .set_loaded_page_for_test(page);

    let raw = serde_json::to_string(&json!({
        "id": 6901,
        "method": "Fetch.disable"
    }))
    .unwrap();
    let pending = match ctx.conn.start_command_dispatch(&raw) {
        CdpCommandTaskStep::Pending(pending) => pending,
        CdpCommandTaskStep::Complete(_) => {
            panic!("live Fetch.disable should clear live page interception state")
        }
    };
    let completed = pending.wait().await;
    let step = ctx.conn.complete_pending_command_dispatch(completed).await;
    let (messages, _) = ctx.complete_command_task_step_for_test(step).await;
    assert_eq!(messages, vec![json!({ "id": 6901, "result": {} })]);
    assert!(
        !ctx.conn
            .browser_context
            .as_ref()
            .expect("browser context should remain loaded")
            .active_page_target()
            .fetch_owner
            .is_enabled()
    );
}

#[test]
fn command_dispatch_completes_fetch_fulfill_request_without_legacy_fallback() {
    let mut conn = CdpConnection::new();

    let raw = serde_json::to_string(&json!({
        "id": 6902,
        "method": "Fetch.fulfillRequest",
        "params": {
            "requestId": "INT-6902",
            "responseCode": 204
        }
    }))
    .unwrap();
    let step = conn.start_command_dispatch(&raw);
    assert_eq!(
        complete_messages(step),
        vec![json!({
            "id": 6902,
            "error": {
                "code": -31998,
                "message": "BrowserContextNotLoaded"
            }
        })]
    );
}

#[test]
fn command_dispatch_completes_fetch_fail_request_without_legacy_fallback() {
    let mut conn = CdpConnection::new();

    let raw = serde_json::to_string(&json!({
        "id": 6903,
        "method": "Fetch.failRequest",
        "params": {
            "requestId": "INT-6903",
            "errorReason": "Aborted"
        }
    }))
    .unwrap();
    let step = conn.start_command_dispatch(&raw);
    assert_eq!(
        complete_messages(step),
        vec![json!({
            "id": 6903,
            "error": {
                "code": -31998,
                "message": "BrowserContextNotLoaded"
            }
        })]
    );
}

#[test]
fn command_dispatch_completes_fetch_websocket_commands_without_legacy_fallback() {
    let mut conn = CdpConnection::new();

    for (id, method, params) in [
        (
            6904,
            "Fetch.dispatchWebSocketMessage",
            json!({
                "requestId": "missing-websocket",
                "opcode": "text",
                "data": "hello"
            }),
        ),
        (
            6905,
            "Fetch.closeWebSocket",
            json!({
                "requestId": "missing-websocket",
                "code": 1000,
                "reason": "done"
            }),
        ),
    ] {
        let raw = serde_json::to_string(&json!({
            "id": id,
            "method": method,
            "params": params
        }))
        .unwrap();
        let step = conn.start_command_dispatch(&raw);
        assert_eq!(
            complete_messages(step),
            vec![json!({
                "id": id,
                "error": {
                    "code": -32000,
                    "message": "RequestNotFound"
                }
            })]
        );
    }
}

#[test]
fn command_dispatch_completes_fetch_body_commands_without_legacy_fallback() {
    let mut conn = CdpConnection::new();

    for (id, method, request_id) in [
        (6906, "Fetch.getResponseBody", "INT-6906"),
        (6907, "Fetch.takeResponseBodyAsStream", "INT-6907"),
    ] {
        let raw = serde_json::to_string(&json!({
            "id": id,
            "method": method,
            "params": { "requestId": request_id }
        }))
        .unwrap();
        let step = conn.start_command_dispatch(&raw);
        assert_eq!(
            complete_messages(step),
            vec![json!({
                "id": id,
                "error": {
                    "code": -31998,
                    "message": "BrowserContextNotLoaded"
                }
            })]
        );
    }
}

#[test]
fn command_dispatch_completes_fetch_continue_commands_without_legacy_fallback() {
    let mut conn = CdpConnection::new();

    for (id, method, request_id, extra_params) in [
        (6908, "Fetch.continueRequest", "INT-6908", json!({})),
        (
            6909,
            "Fetch.continueWithAuth",
            "INT-6909",
            json!({
                "authChallengeResponse": { "response": "Default" }
            }),
        ),
        (6910, "Fetch.continueResponse", "INT-6910", json!({})),
    ] {
        let mut params = serde_json::Map::new();
        params.insert("requestId".to_owned(), json!(request_id));
        if let Some(extra) = extra_params.as_object() {
            params.extend(extra.clone());
        }
        let raw = serde_json::to_string(&json!({
            "id": id,
            "method": method,
            "params": params
        }))
        .unwrap();
        let step = conn.start_command_dispatch(&raw);
        assert_eq!(
            complete_messages(step),
            vec![json!({
                "id": id,
                "error": {
                    "code": -31998,
                    "message": "BrowserContextNotLoaded"
                }
            })]
        );
    }
}

#[test]
fn command_dispatch_completes_fetch_unknown_method_without_legacy_fallback() {
    let mut conn = CdpConnection::new();

    let raw = serde_json::to_string(&json!({
        "id": 6911,
        "method": "Fetch.noSuchMethod",
        "params": {}
    }))
    .unwrap();
    let step = conn.start_command_dispatch(&raw);
    assert_eq!(
        complete_messages(step),
        vec![json!({
            "id": 6911,
            "error": {
                "code": -32601,
                "message": "UnknownMethod"
            }
        })]
    );
}

#[test]
fn command_dispatch_completes_shim_domains_without_legacy_fallback() {
    let mut conn = CdpConnection::new();

    for (id, method) in [
        (70, "Audits.enable"),
        (71, "Audits.disable"),
        (72, "SystemInfo.getInfo"),
        (73, "SystemInfo.getProcessInfo"),
        (74, "WebAuthn.enable"),
        (75, "WebAuthn.disable"),
        (76, "WebMCP.enable"),
        (77, "WebMCP.disable"),
    ] {
        let raw = serde_json::to_string(&json!({ "id": id, "method": method })).unwrap();
        let step = conn.start_command_dispatch(&raw);
        let messages = complete_messages(step);
        assert_eq!(messages.len(), 1, "{method} should emit one response");
        assert_eq!(messages[0]["id"], json!(id));
        assert!(
            messages[0].get("result").is_some(),
            "{method} should complete successfully: {:?}",
            messages[0]
        );
    }
}

#[test]
fn command_dispatch_completes_shim_domain_unknown_methods_without_legacy_fallback() {
    let mut conn = CdpConnection::new();

    for (id, method) in [
        (80, "Audits.noSuchMethod"),
        (81, "SystemInfo.noSuchMethod"),
        (82, "WebAuthn.noSuchMethod"),
        (83, "WebMCP.noSuchMethod"),
    ] {
        let raw = serde_json::to_string(&json!({ "id": id, "method": method })).unwrap();
        let step = conn.start_command_dispatch(&raw);
        assert_eq!(
            complete_messages(step),
            vec![json!({
                "id": id,
                "error": {"code": -32601, "message": "UnknownMethod"}
            })],
            "{method} should return UnknownMethod through the command dispatch entry"
        );
    }
}

#[test]
fn command_dispatch_completes_additional_sync_domains_without_legacy_fallback() {
    let mut conn = CdpConnection::new();

    for (id, method, expects_result) in [
        (90, "DOMSnapshot.enable", true),
        (91, "DOMSnapshot.disable", true),
        (92, "DOMSnapshot.captureSnapshot", false),
        (93, "Security.enable", true),
        (94, "Security.disable", true),
        (95, "Security.handleCertificateError", true),
        (96, "Security.setOverrideCertificateErrors", true),
        (97, "Network.clearBrowserCache", false),
        (98, "Network.getResponseBody", false),
        (981, "Network.getRequestPostData", false),
        (99, "IO.close", false),
        (100, "IO.read", false),
        (1003, "Accessibility.enable", true),
        (1004, "Accessibility.disable", true),
        (1005, "CSS.enable", true),
        (1006, "CSS.disable", true),
        (1007, "Runtime.disable", true),
        (1008, "Runtime.discardConsoleEntries", true),
    ] {
        let params = match method {
            "IO.close" | "IO.read" => json!({ "handle": "missing-stream" }),
            "Network.getResponseBody" | "Network.getRequestPostData" => {
                json!({ "requestId": "missing-request" })
            }
            _ => json!({}),
        };
        let raw = serde_json::to_string(&json!({ "id": id, "method": method, "params": params }))
            .unwrap();
        let step = conn.start_command_dispatch(&raw);
        let messages = complete_messages(step);
        assert_eq!(messages.len(), 1, "{method} should emit one response");
        assert_eq!(messages[0]["id"], json!(id));
        if expects_result {
            assert!(
                messages[0].get("result").is_some(),
                "{method} should complete successfully: {:?}",
                messages[0]
            );
        } else {
            assert!(
                messages[0].get("error").is_some(),
                "{method} should complete with a protocol error: {:?}",
                messages[0]
            );
        }
    }
}

#[test]
fn command_dispatch_completes_input_owner_commands_without_legacy_fallback() {
    let mut conn = crate::testing::real_layout_test_connection();
    conn.browser_context = Some(BrowserContext::new_with_page_for_test(
        "BID-input",
        "TID-input",
    ));

    let raw = serde_json::to_string(&json!({
        "id": 1001,
        "method": "Input.setInterceptDrags",
        "params": { "enabled": true }
    }))
    .unwrap();
    let step = conn.start_command_dispatch(&raw);
    assert_eq!(
        complete_messages(step),
        vec![json!({
            "id": 1001,
            "error": {
                "code": -32000,
                "message": crate::domains::input::SET_INTERCEPT_DRAGS_UNSUPPORTED_MESSAGE
            }
        })]
    );
    assert!(
        conn.browser_context
            .as_ref()
            .is_some_and(|context| !context.active_page_target().input_intercept_drags_enabled)
    );

    let raw = serde_json::to_string(&json!({
        "id": 1002,
        "method": "Input.dispatchDragEvent",
        "params": {
            "type": "drop",
            "x": 0,
            "y": 0,
            "data": { "items": [], "files": [], "dragOperationsMask": 0 }
        }
    }))
    .unwrap();
    let step = conn.start_command_dispatch(&raw);
    assert_eq!(
        complete_messages(step),
        vec![json!({
            "id": 1002,
            "error": {
                "code": -32000,
                "message": "NoDocumentLoaded"
            }
        })]
    );
}

#[test]
fn command_dispatch_completes_additional_sync_domain_unknown_methods_without_legacy_fallback() {
    let mut conn = CdpConnection::new();

    for (id, method) in [
        (101, "Browser.noSuchMethod"),
        (102, "Target.noSuchMethod"),
        (103, "DOMSnapshot.noSuchMethod"),
        (104, "Security.noSuchMethod"),
        (105, "IO.noSuchMethod"),
        (106, "Network.noSuchMethod"),
        (107, "Emulation.noSuchMethod"),
        (108, "Performance.noSuchMethod"),
        (109, "Input.noSuchMethod"),
        (110, "Accessibility.noSuchMethod"),
        (111, "CSS.noSuchMethod"),
        (112, "Runtime.noSuchMethod"),
        (113, "Page.noSuchMethod"),
    ] {
        let raw = serde_json::to_string(&json!({ "id": id, "method": method })).unwrap();
        let step = conn.start_command_dispatch(&raw);
        assert_eq!(
            complete_messages(step),
            vec![json!({
                "id": id,
                "error": {"code": -32601, "message": "UnknownMethod"}
            })],
            "{method} should return UnknownMethod through the command dispatch entry"
        );
    }
}