From fed98c8e1dd04bd48c8eb561ee40f2fd554a96e0 Mon Sep 17 00:00:00 2001 From: ldm0 Date: Sat, 14 Nov 2026 17:21:33 +0800 Subject: [PATCH] fix(cdp): keep WebSocket handshakes outside Fetch interception Exclude WebSockets from wildcard and authentication interception classes and reject explicit WebSocket Fetch filters. Publish their handshake and failure through dedicated Network.webSocket events without ordinary HTTP requests. Keep URL blocking and Worker WebSocket diagnostics covered. --- .../browser_context/target_session_owner.rs | 4 + moli-protocol/src/conn/fetch_support.rs | 27 +- moli-protocol/src/conn/state/fetch.rs | 8 +- moli-protocol/src/conn/state/tests.rs | 28 +- .../src/domains/fetch/tests/basics.rs | 14 +- moli-protocol/src/domains/fetch/tests/mod.rs | 24 - .../domains/fetch/tests/runtime_websocket.rs | 1381 ++--------------- moli-protocol/src/domains/network/backlog.rs | 40 +- .../src/domains/network/tests/blocked_urls.rs | 133 +- 9 files changed, 240 insertions(+), 1419 deletions(-) diff --git a/moli-protocol/src/conn/browser_context/target_session_owner.rs b/moli-protocol/src/conn/browser_context/target_session_owner.rs index 6b2d544bb72..4d9e303ea46 100644 --- a/moli-protocol/src/conn/browser_context/target_session_owner.rs +++ b/moli-protocol/src/conn/browser_context/target_session_owner.rs @@ -3206,6 +3206,7 @@ mod tests { assert_eq!( owner.configure_fetch(Some("SID-active".to_owned()), true, patterns.clone()), SubresourceInterceptionClasses::ALL + .difference(SubresourceInterceptionClasses::WEBSOCKET) ); assert!(owner.register_pending_subresource_fetch_request( "FETCH-active".to_owned(), @@ -3242,6 +3243,7 @@ mod tests { assert_eq!( owner.configure_fetch(Some("SID-background".to_owned()), true, patterns), SubresourceInterceptionClasses::ALL + .difference(SubresourceInterceptionClasses::WEBSOCKET) ); assert!(owner.register_pending_subresource_fetch_request( "FETCH-background".to_owned(), @@ -3712,6 +3714,7 @@ mod tests { assert_eq!( inputs.fetch_subresource_interception, SubresourceInterceptionClasses::ALL + .difference(SubresourceInterceptionClasses::WEBSOCKET) ); } @@ -3813,6 +3816,7 @@ mod tests { assert_eq!( inputs.fetch_subresource_interception, SubresourceInterceptionClasses::ALL + .difference(SubresourceInterceptionClasses::WEBSOCKET) ); } diff --git a/moli-protocol/src/conn/fetch_support.rs b/moli-protocol/src/conn/fetch_support.rs index 2cc48763883..d5b270699d0 100644 --- a/moli-protocol/src/conn/fetch_support.rs +++ b/moli-protocol/src/conn/fetch_support.rs @@ -47,8 +47,10 @@ pub struct FetchInterceptionPattern { impl FetchInterceptionPattern { pub fn matches_request(&self, resource_type: DevToolsNetworkResourceType, url: &Url) -> bool { - self.resource_type_filter - .is_none_or(|filter| filter.matches_resource_type(resource_type)) + resource_type != DevToolsNetworkResourceType::WebSocket + && self + .resource_type_filter + .is_none_or(|filter| filter.matches_resource_type(resource_type)) && url_pattern_matches(&self.url_pattern, url.as_str()) } } @@ -138,7 +140,7 @@ impl FetchResourceTypeFilter { } Self::Ping => SubresourceInterceptionClasses::PING, Self::CspViolationReport => SubresourceInterceptionClasses::CSP_VIOLATION_REPORT, - Self::WebSocket => SubresourceInterceptionClasses::WEBSOCKET, + Self::WebSocket => SubresourceInterceptionClasses::NONE, Self::Other => SubresourceInterceptionClasses::OTHER, } } @@ -152,19 +154,20 @@ pub fn fetch_subresource_interception_config_for_patterns( return SubresourceInterceptionClasses::NONE; } if patterns.is_empty() { - // Fetch.enable without patterns can pause any resource class, so the - // renderer must route everything through the protocol and let it - // match per request. - return SubresourceInterceptionClasses::ALL; + // WebSocket handshakes use Network.webSocket* events and are not + // intercepted by Fetch, including an unfiltered Fetch.enable. + return SubresourceInterceptionClasses::ALL + .difference(SubresourceInterceptionClasses::WEBSOCKET); } - // Type-less patterns route every class; typed patterns contribute only + // Type-less patterns route HTTP classes; typed patterns contribute only // their supported classes. URL and stage matching stay in the protocol. patterns .iter() .map(|pattern| { pattern.resource_type_filter.map_or( - SubresourceInterceptionClasses::ALL, + SubresourceInterceptionClasses::ALL + .difference(SubresourceInterceptionClasses::WEBSOCKET), FetchResourceTypeFilter::interception_classes, ) }) @@ -1877,7 +1880,6 @@ mod tests { FetchResourceTypeFilter::Xhr, FetchResourceTypeFilter::Ping, FetchResourceTypeFilter::CspViolationReport, - FetchResourceTypeFilter::WebSocket, FetchResourceTypeFilter::Other, ] { let patterns = [FetchInterceptionPattern { @@ -2042,7 +2044,7 @@ mod tests { } #[test] - fn type_less_and_missing_patterns_intercept_every_class() { + fn type_less_and_missing_patterns_intercept_http_classes() { let type_less = vec![FetchInterceptionPattern { url_pattern: "*://example.test/*".to_owned(), resource_type_filter: None, @@ -2051,6 +2053,7 @@ mod tests { assert_eq!( fetch_subresource_interception_config_for_patterns(true, &type_less), SubresourceInterceptionClasses::ALL + .difference(SubresourceInterceptionClasses::WEBSOCKET) ); // A typed pattern next to a type-less one still routes everything. let mixed = vec![ @@ -2064,10 +2067,12 @@ mod tests { assert_eq!( fetch_subresource_interception_config_for_patterns(true, &mixed), SubresourceInterceptionClasses::ALL + .difference(SubresourceInterceptionClasses::WEBSOCKET) ); assert_eq!( fetch_subresource_interception_config_for_patterns(true, &[]), SubresourceInterceptionClasses::ALL + .difference(SubresourceInterceptionClasses::WEBSOCKET) ); } diff --git a/moli-protocol/src/conn/state/fetch.rs b/moli-protocol/src/conn/state/fetch.rs index 26e8ed32e5b..886b149909c 100644 --- a/moli-protocol/src/conn/state/fetch.rs +++ b/moli-protocol/src/conn/state/fetch.rs @@ -1134,9 +1134,11 @@ impl TargetFetchConfig { { // Auth challenges are matched by URL alone, regardless of the // resource classes named by Fetch.enable patterns. The renderer - // must route every class through the protocol so no class scope - // can silently disable Fetch.authRequired pauses. - return moli_core::page::SubresourceInterceptionClasses::ALL; + // must route HTTP classes through the protocol so no class scope + // can silently disable Fetch.authRequired pauses. WebSocket + // handshakes are outside Fetch interception. + return moli_core::page::SubresourceInterceptionClasses::ALL + .difference(moli_core::page::SubresourceInterceptionClasses::WEBSOCKET); } fetch_subresource_interception_config_for_patterns(self.enabled, &self.patterns) } diff --git a/moli-protocol/src/conn/state/tests.rs b/moli-protocol/src/conn/state/tests.rs index 304cd34511b..9c303cfb715 100644 --- a/moli-protocol/src/conn/state/tests.rs +++ b/moli-protocol/src/conn/state/tests.rs @@ -166,8 +166,8 @@ fn target_fetch_owner_projects_config_without_exposing_slots() { let snapshot = owner.subresource_interception_snapshot(); assert_eq!( owner.subresource_interception_config(), - SubresourceInterceptionClasses::ALL, - "handleAuthRequests routes every class through the protocol" + SubresourceInterceptionClasses::ALL.difference(SubresourceInterceptionClasses::WEBSOCKET), + "handleAuthRequests routes HTTP classes through the protocol" ); assert_eq!( snapshot.event_session_id(None), @@ -186,7 +186,7 @@ fn target_fetch_owner_projects_config_without_exposing_slots() { DevToolsNetworkResourceType::WebSocket, &Url::parse("wss://example.test/ws").unwrap(), ), - Some(FetchRequestStage::Request) + None ); assert_eq!( owner.matching_document_request_stage(&Url::parse("https://example.test/api").unwrap()), @@ -209,7 +209,7 @@ fn target_fetch_owner_projects_config_without_exposing_slots() { ); assert_eq!( owner.subresource_interception_config(), - SubresourceInterceptionClasses::ALL, + SubresourceInterceptionClasses::ALL.difference(SubresourceInterceptionClasses::WEBSOCKET), "aggregate subresource config keeps handleAuthRequests broad admission" ); let root_config = owner.config_snapshot_for_session(None); @@ -345,7 +345,7 @@ fn target_fetch_owner_keeps_fetch_enable_configs_per_session() { assert!(aggregate.handle_auth_requests()); assert_eq!( owner.subresource_interception_config(), - SubresourceInterceptionClasses::ALL, + SubresourceInterceptionClasses::ALL.difference(SubresourceInterceptionClasses::WEBSOCKET), "aggregate handleAuthRequests broadens the renderer class set" ); @@ -359,7 +359,7 @@ fn target_fetch_owner_keeps_fetch_enable_configs_per_session() { ); assert_eq!( primary.subresource_interception_config(), - SubresourceInterceptionClasses::ALL, + SubresourceInterceptionClasses::ALL.difference(SubresourceInterceptionClasses::WEBSOCKET), "session handleAuthRequests broadens the renderer class set" ); @@ -782,7 +782,7 @@ fn target_fetch_owner_reports_matching_auth_required_network_intercepts() { let config = owner.config_snapshot(); assert_eq!( owner.subresource_interception_config(), - SubresourceInterceptionClasses::ALL + SubresourceInterceptionClasses::ALL.difference(SubresourceInterceptionClasses::WEBSOCKET) ); assert!(config.matches_auth_required(&matching_url)); assert!(config.matches_auth_required(&other_url)); @@ -851,7 +851,7 @@ fn cdp_auth_is_independent_of_network_intercept_registration() { assert!(config.matches_auth_required(&any_url)); assert_eq!( owner.subresource_interception_config(), - SubresourceInterceptionClasses::ALL + SubresourceInterceptionClasses::ALL.difference(SubresourceInterceptionClasses::WEBSOCKET) ); assert!(owner.remove_network_intercept("intercept-no-auth")); assert!(owner.config_snapshot().matches_auth_required(&any_url)); @@ -895,7 +895,7 @@ fn cdp_auth_is_independent_of_network_intercept_registration() { assert!(owner.config_snapshot().matches_auth_required(&any_url)); assert_eq!( owner.subresource_interception_config(), - SubresourceInterceptionClasses::ALL + SubresourceInterceptionClasses::ALL.difference(SubresourceInterceptionClasses::WEBSOCKET) ); owner.configure(Some("SID-other".to_owned()), false, image_patterns); @@ -915,11 +915,11 @@ fn cdp_auth_is_independent_of_network_intercept_registration() { snapshot.auth_required_owner_kind(&other_url), Some(PendingSubresourceFetchOwnerKind::NetworkOrBidi) ); - // A real auth rule still requires all resource classes even though it + // A real auth rule still requires all HTTP resource classes even though it // no longer authorizes unrelated URLs after the last CDP handler stops. assert_eq!( owner.subresource_interception_config(), - SubresourceInterceptionClasses::ALL + SubresourceInterceptionClasses::ALL.difference(SubresourceInterceptionClasses::WEBSOCKET) ); assert!(owner.remove_network_intercept("intercept-auth")); assert_eq!( @@ -1965,7 +1965,7 @@ fn interception_eligibility_includes_authentication_independent_of_resource_type ); assert_eq!( owner.subresource_interception_config(), - SubresourceInterceptionClasses::ALL + SubresourceInterceptionClasses::ALL.difference(SubresourceInterceptionClasses::WEBSOCKET) ); owner.configure( Some("CDP".to_owned()), @@ -1978,12 +1978,12 @@ fn interception_eligibility_includes_authentication_independent_of_resource_type ); assert_eq!( owner.subresource_interception_config(), - SubresourceInterceptionClasses::ALL + SubresourceInterceptionClasses::ALL.difference(SubresourceInterceptionClasses::WEBSOCKET) ); owner.remove_fetch_session(Some("CDP")); assert_eq!( owner.subresource_interception_config(), - SubresourceInterceptionClasses::ALL + SubresourceInterceptionClasses::ALL.difference(SubresourceInterceptionClasses::WEBSOCKET) ); owner.remove_network_intercept("auth"); assert_eq!( diff --git a/moli-protocol/src/domains/fetch/tests/basics.rs b/moli-protocol/src/domains/fetch/tests/basics.rs index 3bd8e0b7650..876283d6b5c 100644 --- a/moli-protocol/src/domains/fetch/tests/basics.rs +++ b/moli-protocol/src/domains/fetch/tests/basics.rs @@ -993,7 +993,7 @@ async fn enable_with_csp_violation_report_resource_type_filter_sets_csp_report_f } #[tokio::test] -async fn enable_with_websocket_resource_type_filter_sets_websocket_filter() { +async fn enable_with_websocket_resource_type_filter_is_rejected() { let mut ctx = TestContext::new(); { let fixture_value = Some(BrowserContext::new_with_page_for_test("BID-1", "TID-1")); @@ -1010,18 +1010,10 @@ async fn enable_with_websocket_resource_type_filter_sets_websocket_filter() { } })) .await; - ctx.expect_result(20, json!({}), None); - + ctx.expect_error(20, -32602, "InvalidParams"); ctx.with_fixture(|conn| { let bc = conn.browser_context.as_ref().unwrap(); - assert!(bc.active_page_target().fetch_owner.is_enabled()); - assert_eq!( - bc.active_page_target() - .fetch_owner - .config_snapshot() - .resource_type_filter(), - Some(FetchResourceTypeFilter::WebSocket) - ); + assert!(!bc.active_page_target().fetch_owner.is_enabled()); }); } diff --git a/moli-protocol/src/domains/fetch/tests/mod.rs b/moli-protocol/src/domains/fetch/tests/mod.rs index 2fcd6ffce13..3afe52351bb 100644 --- a/moli-protocol/src/domains/fetch/tests/mod.rs +++ b/moli-protocol/src/domains/fetch/tests/mod.rs @@ -60,30 +60,6 @@ async fn with_loaded_http_document( }); } -async fn with_loaded_http_background_document( - ctx: &mut TestContext, - url: &str, - active_session_id: &str, - active_target_id: &str, - background_session_id: &str, - background_target_id: &str, -) { - let background = PageTargetHost::with_url( - background_target_id.to_owned(), - Some(background_session_id.to_owned()), - url.to_owned(), - ); - - let mut bc = BrowserContext::new("BID-1".into()); - bc.set_active_target_id(active_target_id.to_owned()); - bc.attach_active_session(active_session_id.to_owned()); - bc.insert_page_target_host(background); - ctx.with_fixture(|conn| conn.install_browser_context_fixture_for_test(bc)); - ctx.enable_page_events_for_test(Some(background_session_id)); - ctx.install_navigation_fixture_for_session_owner(url, Some(background_session_id)) - .await; -} - async fn loaded_page_html_for_test(ctx: &mut TestContext) -> String { ctx.serialize_fixture_document(None) .await diff --git a/moli-protocol/src/domains/fetch/tests/runtime_websocket.rs b/moli-protocol/src/domains/fetch/tests/runtime_websocket.rs index 0e5df15a3be..b66a86cc117 100644 --- a/moli-protocol/src/domains/fetch/tests/runtime_websocket.rs +++ b/moli-protocol/src/domains/fetch/tests/runtime_websocket.rs @@ -4,1301 +4,144 @@ async fn websocket_echo_handler(ws: WebSocketUpgrade) -> impl IntoResponse { ws.on_upgrade(|mut socket| async move { while let Some(Ok(message)) = socket.recv().await { match message { - Message::Text(text) => { - let _ = socket.send(Message::Text(text)).await; - } - Message::Binary(bytes) => { - let _ = socket.send(Message::Binary(bytes)).await; - } - Message::Close(_frame) => { - // recv already queued the Close reply; flush before releasing TCP. + Message::Close(_) => { let _ = futures_util::SinkExt::flush(&mut socket).await; break; } - Message::Ping(bytes) => { - let _ = socket.send(Message::Pong(bytes)).await; + message => { + let _ = socket.send(message).await; } - Message::Pong(_) => {} } } }) } -async fn websocket_header_report_handler( - headers: HeaderMap, - ws: WebSocketUpgrade, -) -> impl IntoResponse { - let x_override = headers - .get("x-override") - .and_then(|value| value.to_str().ok()) - .unwrap_or_default() - .to_owned(); - let cookie = headers - .get("cookie") - .and_then(|value| value.to_str().ok()) - .unwrap_or_default() - .to_owned(); - ws.on_upgrade(move |mut socket| async move { - let _ = socket - .send(Message::Text( - format!("x:{x_override};cookie:{cookie}").into(), - )) - .await; - let _ = socket.send(Message::Close(None)).await; - }) -} - -async fn page() -> impl IntoResponse { - ( - [(CONTENT_TYPE.as_str(), "text/html")], - "ready", - ) -} - -async fn spawn_websocket_page_server() -> (String, String, tokio::task::JoinHandle<()>) { +#[tokio::test(flavor = "multi_thread")] +async fn fetch_interception_never_pauses_or_announces_websocket_handshakes() { 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("/headers", get(websocket_header_report_handler)) + .route("/page", get(|| async { "ready" })) .route("/socket", get(websocket_echo_handler)), ) .await .unwrap(); }); - ( - format!("http://{addr}/page"), - format!("ws://{addr}/socket"), - server, - ) -} - -async fn open_auto_attached_popup_from_session( - ctx: &mut TestContext, - id: u64, - session_id: &str, - url: &str, -) -> (String, String) { - ctx.process_async(json!({ - "id": id, - "method": "Runtime.evaluate", - "sessionId": session_id, - "params": { - "expression": format!("window.open('{url}', '_blank') !== null"), - "returnByValue": true - } - })) - .await; - let messages = ctx.take_all(); - let response = messages - .iter() - .find(|message| message["id"] == json!(id)) - .unwrap_or_else(|| panic!("missing popup open response in {messages:?}")); - assert_eq!(response["result"]["result"]["value"], json!(true)); - let created = messages - .iter() - .find(|message| message["method"] == json!("Target.targetCreated")) - .unwrap_or_else(|| panic!("missing popup targetCreated in {messages:?}")); - let target_id = created["params"]["targetInfo"]["targetId"] - .as_str() - .expect("popup target id") - .to_owned(); - let attached = messages - .iter() - .find(|message| { - message["method"] == json!("Target.attachedToTarget") - && message["params"]["targetInfo"]["targetId"] == json!(target_id) - }) - .unwrap_or_else(|| panic!("missing popup attachedToTarget in {messages:?}")); - let popup_session_id = attached["params"]["sessionId"] - .as_str() - .expect("popup session id") - .to_owned(); - ctx.wait_for_initial_document_for_target(&target_id).await; - ctx.with_fixture(|conn| { - let popup_runtime = conn.runtime_session_owner_slot(Some(&popup_session_id)) - .expect("auto-attached popup runtime slot"); - assert!(popup_runtime.has_loaded_page(), - "joining initialization must leave a command-addressable popup Document; diagnostics={}", - popup_runtime.moli_memory_diagnostics()); - }); - (target_id, popup_session_id) -} - -#[tokio::test(flavor = "multi_thread")] -async fn websocket_handshake_pauses_until_fetch_continue_request_then_opens() { - let (page_url, socket_url, server) = spawn_websocket_page_server().await; - let socket_literal = serde_json::to_string(&socket_url).expect("socket URL literal"); - let mut ctx = TestContext::new(); - with_loaded_http_document(&mut ctx, &page_url, "SID-1", "TID-1").await; - ctx.sent.clear(); - - ctx.process_async(json!({ - "id": 51_000, - "method": "Fetch.enable", - "sessionId": "SID-1", - "params": { - "patterns": [{ "urlPattern": "*", "requestStage": "Request", "resourceType": "WebSocket" }] - } - })) - .await; - ctx.expect_result(51_000, json!({}), Some("SID-1")); - enable_runtime_async(&mut ctx, "SID-1", 51_001).await; - - ctx.process_async(json!({ - "id": 51_002, - "method": "Runtime.evaluate", - "sessionId": "SID-1", - "params": { - "expression": format!(r#"(() => {{ - globalThis.__lm_ws_fetch_result = "pending"; - const socket = new WebSocket({socket_literal}); - socket.addEventListener('open', () => socket.send('hello')); - socket.addEventListener('message', (event) => {{ - globalThis.__lm_ws_fetch_result = event.data; - socket.close(1000, 'done'); - }}); - socket.addEventListener('error', () => {{ - globalThis.__lm_ws_fetch_result = "error"; - }}); - return "scheduled"; - }})()"#) - } - })) - .await; - let _ = take_response_by_id(&mut ctx, 51_002); - - let paused = ctx - .sent - .iter() - .find(|message| { - message["method"] == json!("Fetch.requestPaused") - && message["params"]["resourceType"] == json!("WebSocket") - }) - .cloned() - .expect("WebSocket Fetch.requestPaused event"); - let request_id = paused["params"]["requestId"] - .as_str() - .expect("WebSocket fetch request id") - .to_owned(); - assert_eq!(paused["params"]["request"]["url"], socket_url); - assert_eq!(paused["params"]["request"]["method"], "GET"); - ctx.sent.clear(); - - ctx.process_async(json!({ - "id": 51_003, - "method": "Fetch.continueRequest", - "sessionId": "SID-1", - "params": { "requestId": request_id } - })) - .await; - ctx.expect_result(51_003, json!({}), Some("SID-1")); - - evaluate_until_value_async( - &mut ctx, - "SID-1", - 51_004, - "globalThis.__lm_ws_fetch_result", - &json!("hello"), - "WebSocket to open after Fetch.continueRequest", - ) - .await; - - server.abort(); -} - -#[tokio::test(flavor = "multi_thread")] -async fn popup_websocket_request_stage_pause_routes_to_popup_session() { - let (page_url, socket_url, server) = spawn_websocket_page_server().await; - let socket_literal = serde_json::to_string(&socket_url).expect("socket URL literal"); - let mut ctx = TestContext::new(); - with_loaded_http_document(&mut ctx, &page_url, "SID-1", "TID-1").await; - ctx.sent.clear(); - - ctx.process_async(json!({ - "id": 51_050, - "method": "Target.setAutoAttach", - "params": { - "autoAttach": true, - "waitForDebuggerOnStart": false, - "flatten": true - } - })) - .await; - ctx.expect_result(51_050, json!({}), None); - ctx.sent.clear(); - - let (_popup_target_id, popup_session_id) = - open_auto_attached_popup_from_session(&mut ctx, 51_051, "SID-1", "about:blank#ws-popup") - .await; - - ctx.process_async(json!({ - "id": 51_052, - "method": "Fetch.enable", - "sessionId": popup_session_id, - "params": { - "patterns": [{ "urlPattern": "*", "requestStage": "Request", "resourceType": "WebSocket" }] - } - })) - .await; - ctx.expect_result(51_052, json!({}), Some(&popup_session_id)); - enable_runtime_async(&mut ctx, &popup_session_id, 51_053).await; - ctx.sent.clear(); - - ctx.process_async(json!({ - "id": 51_054, - "method": "Runtime.evaluate", - "sessionId": popup_session_id, - "params": { - "expression": format!(r#"(() => {{ - globalThis.__lm_popup_ws_fetch_result = "pending"; - const socket = new WebSocket({socket_literal}); - socket.addEventListener('open', () => socket.send('popup')); - socket.addEventListener('message', (event) => {{ - globalThis.__lm_popup_ws_fetch_result = event.data; - socket.close(1000, 'done'); - }}); - socket.addEventListener('error', () => {{ - globalThis.__lm_popup_ws_fetch_result = "error"; - }}); - return "scheduled"; - }})()"#) - } - })) - .await; - let _ = take_response_by_id(&mut ctx, 51_054); - - wait_until_messages( - &mut ctx, - Some(popup_session_id.as_str()), - "popup WebSocket requestPaused", - |messages| { - messages.iter().any(|message| { - message["method"] == json!("Fetch.requestPaused") - && message["sessionId"] == json!(popup_session_id) - && message["params"]["resourceType"] == json!("WebSocket") - && message["params"]["request"]["url"] == json!(socket_url) - }) - }, - ) - .await; - let paused = ctx.take_first_matching("popup WebSocket Fetch.requestPaused event", |message| { - message["method"] == json!("Fetch.requestPaused") - && message["sessionId"] == json!(popup_session_id) - && message["params"]["resourceType"] == json!("WebSocket") - && message["params"]["request"]["url"] == json!(socket_url) - }); - assert!( - !ctx.sent.iter().any(|message| { - message["method"] == json!("Fetch.requestPaused") - && message["sessionId"] == json!("SID-1") - && message["params"]["request"]["url"] == json!(socket_url) - }), - "popup WebSocket pause must not be delivered to opener session: {:?}", - ctx.sent - ); - let request_id = paused["params"]["requestId"] - .as_str() - .expect("popup WebSocket fetch request id") - .to_owned(); - ctx.sent.clear(); - - ctx.process_async(json!({ - "id": 51_055, - "method": "Fetch.continueRequest", - "sessionId": popup_session_id, - "params": { "requestId": request_id } - })) - .await; - ctx.expect_result(51_055, json!({}), Some(&popup_session_id)); - - evaluate_until_value_async( - &mut ctx, - &popup_session_id, - 51_056, - "globalThis.__lm_popup_ws_fetch_result", - &json!("popup"), - "popup WebSocket to open after popup-session Fetch.continueRequest", - ) - .await; - - server.abort(); -} - -#[tokio::test(flavor = "multi_thread")] -async fn websocket_continue_request_header_override_replaces_cookie_header() { - let (page_url, socket_url, server) = spawn_websocket_page_server().await; - let socket_url = socket_url.replace("/socket", "/headers"); - let socket_literal = serde_json::to_string(&socket_url).expect("socket URL literal"); - let mut ctx = TestContext::new(); - with_loaded_http_document(&mut ctx, &page_url, "SID-1", "TID-1").await; - ctx.sent.clear(); - - ctx.process_async(json!({ - "id": 51_100, - "method": "Fetch.enable", - "sessionId": "SID-1", - "params": { - "patterns": [{ "urlPattern": "*", "requestStage": "Request", "resourceType": "WebSocket" }] - } - })) - .await; - ctx.expect_result(51_100, json!({}), Some("SID-1")); - enable_runtime_async(&mut ctx, "SID-1", 51_101).await; - - ctx.process_async(json!({ - "id": 51_102, - "method": "Runtime.evaluate", - "sessionId": "SID-1", - "params": { - "expression": format!(r#"(() => {{ - document.cookie = "ws_continue_cookie=old; Path=/"; - globalThis.__lm_ws_fetch_result = "pending"; - const socket = new WebSocket({socket_literal}); - socket.addEventListener('message', (event) => {{ - globalThis.__lm_ws_fetch_result = event.data; - socket.close(1000, 'done'); - }}); - return "scheduled"; - }})()"#) - } - })) - .await; - let _ = take_response_by_id(&mut ctx, 51_102); - - let paused = ctx - .sent - .iter() - .find(|message| { - message["method"] == json!("Fetch.requestPaused") - && message["params"]["resourceType"] == json!("WebSocket") - }) - .cloned() - .expect("WebSocket Fetch.requestPaused event"); - assert_eq!( - paused["params"]["request"]["headers"]["Cookie"], - json!("ws_continue_cookie=old") - ); - let request_id = paused["params"]["requestId"] - .as_str() - .expect("WebSocket fetch request id") - .to_owned(); - ctx.sent.clear(); - - ctx.process_async(json!({ - "id": 51_103, - "method": "Fetch.continueRequest", - "sessionId": "SID-1", - "params": { - "requestId": request_id, - "headers": [{ "name": "X-Override", "value": "yes" }] - } - })) - .await; - ctx.expect_result(51_103, json!({}), Some("SID-1")); - - evaluate_until_value_async( - &mut ctx, - "SID-1", - 51_104, - "globalThis.__lm_ws_fetch_result", - &json!("x:yes;cookie:"), - "WebSocket header override to replace original Cookie header", - ) - .await; - - server.abort(); -} - -#[tokio::test(flavor = "multi_thread")] -async fn websocket_handshake_fetch_fail_request_dispatches_error_and_close() { - let (page_url, socket_url, server) = spawn_websocket_page_server().await; - let socket_literal = serde_json::to_string(&socket_url).expect("socket URL literal"); - let mut ctx = TestContext::new(); - with_loaded_http_document(&mut ctx, &page_url, "SID-1", "TID-1").await; - ctx.sent.clear(); - - ctx.process_async(json!({ - "id": 51_100, - "method": "Fetch.enable", - "sessionId": "SID-1", - "params": { - "patterns": [{ "urlPattern": "*", "requestStage": "Request", "resourceType": "WebSocket" }] - } - })) - .await; - ctx.expect_result(51_100, json!({}), Some("SID-1")); - enable_runtime_async(&mut ctx, "SID-1", 51_101).await; - - ctx.process_async(json!({ - "id": 51_102, - "method": "Runtime.evaluate", - "sessionId": "SID-1", - "params": { - "expression": format!(r#"(() => {{ - globalThis.__lm_ws_fetch_result = "pending"; - const events = []; - const socket = new WebSocket({socket_literal}); - socket.addEventListener('open', () => events.push('open')); - socket.addEventListener('error', () => events.push('error')); - socket.addEventListener('close', (event) => {{ - events.push(`close:${{event.code}}`); - globalThis.__lm_ws_fetch_result = events.join(','); - }}); - return "scheduled"; - }})()"#) - } - })) - .await; - let _ = take_response_by_id(&mut ctx, 51_102); - - let paused = ctx - .sent - .iter() - .find(|message| { - message["method"] == json!("Fetch.requestPaused") - && message["params"]["resourceType"] == json!("WebSocket") - }) - .cloned() - .expect("WebSocket Fetch.requestPaused event"); - let request_id = paused["params"]["requestId"] - .as_str() - .expect("WebSocket fetch request id") - .to_owned(); - ctx.sent.clear(); - - ctx.process_async(json!({ - "id": 51_103, - "method": "Fetch.failRequest", - "sessionId": "SID-1", - "params": { - "requestId": request_id, - "errorReason": "Aborted" - } - })) - .await; - ctx.expect_result(51_103, json!({}), Some("SID-1")); - - evaluate_until_value_async( - &mut ctx, - "SID-1", - 51_104, - "globalThis.__lm_ws_fetch_result", - &json!("error,close:1006"), - "WebSocket to fail after Fetch.failRequest", - ) - .await; - - server.abort(); -} - -#[tokio::test(flavor = "multi_thread")] -async fn websocket_handshake_fulfill_request_opens_synthetic_socket() { - let (page_url, socket_url, server) = spawn_websocket_page_server().await; - let socket_literal = serde_json::to_string(&socket_url).expect("socket URL literal"); - let mut ctx = TestContext::new(); - with_loaded_http_document(&mut ctx, &page_url, "SID-1", "TID-1").await; - ctx.sent.clear(); - - ctx.process_async(json!({ - "id": 51_150, - "method": "Fetch.enable", - "sessionId": "SID-1", - "params": { - "patterns": [{ "urlPattern": "*", "requestStage": "Request", "resourceType": "WebSocket" }] - } - })) - .await; - ctx.expect_result(51_150, json!({}), Some("SID-1")); - enable_runtime_async(&mut ctx, "SID-1", 51_151).await; - - ctx.process_async(json!({ - "id": 51_152, - "method": "Runtime.evaluate", - "sessionId": "SID-1", - "params": { - "expression": format!(r#"(() => {{ - globalThis.__lm_ws_fetch_result = "pending"; - const events = []; - const socket = new WebSocket({socket_literal}, "chat"); - socket.addEventListener('open', () => {{ - events.push(`open:${{socket.protocol}}`); - socket.send('hello'); - socket.close(1000, 'done'); - }}); - socket.addEventListener('error', () => events.push('error')); - socket.addEventListener('close', (event) => {{ - events.push(`close:${{event.code}}:${{event.wasClean}}`); - events.push(`cookie:${{document.cookie.includes('ws_synthetic=1')}}`); - globalThis.__lm_ws_fetch_result = events.join(','); - }}); - return "scheduled"; - }})()"#) - } - })) - .await; - let _ = take_response_by_id(&mut ctx, 51_152); - - let paused = ctx - .sent - .iter() - .find(|message| { - message["method"] == json!("Fetch.requestPaused") - && message["params"]["resourceType"] == json!("WebSocket") - }) - .cloned() - .expect("WebSocket Fetch.requestPaused event"); - let request_id = paused["params"]["requestId"] - .as_str() - .expect("WebSocket fetch request id") - .to_owned(); - ctx.sent.clear(); - - ctx.process_async(json!({ - "id": 51_153, - "method": "Fetch.fulfillRequest", - "sessionId": "SID-1", - "params": { - "requestId": request_id, - "responseCode": 101, - "responseHeaders": [ - { "name": "Upgrade", "value": "websocket" }, - { "name": "Connection", "value": "Upgrade" }, - { "name": "Sec-WebSocket-Protocol", "value": "chat" }, - { "name": "Set-Cookie", "value": "ws_synthetic=1; Path=/" } - ] - } - })) - .await; - ctx.expect_result(51_153, json!({}), Some("SID-1")); - - evaluate_until_value_async( - &mut ctx, - "SID-1", - 51_154, - "globalThis.__lm_ws_fetch_result", - &json!("open:chat,close:1000:true,cookie:true"), - "WebSocket to open from Fetch.fulfillRequest synthetic handshake", - ) - .await; - - server.abort(); -} - -#[tokio::test(flavor = "multi_thread")] -async fn websocket_synthetic_socket_accepts_fetch_injected_server_frames() { - let (page_url, socket_url, server) = spawn_websocket_page_server().await; - let socket_literal = serde_json::to_string(&socket_url).expect("socket URL literal"); - let mut ctx = TestContext::new(); - with_loaded_http_document(&mut ctx, &page_url, "SID-1", "TID-1").await; - ctx.sent.clear(); - - ctx.process_async(json!({ - "id": 51_170, - "method": "Fetch.enable", - "sessionId": "SID-1", - "params": { - "patterns": [{ "urlPattern": "*", "requestStage": "Request", "resourceType": "WebSocket" }] - } - })) - .await; - ctx.expect_result(51_170, json!({}), Some("SID-1")); - enable_runtime_async(&mut ctx, "SID-1", 51_171).await; - - ctx.process_async(json!({ - "id": 51_172, - "method": "Runtime.evaluate", - "sessionId": "SID-1", - "params": { - "expression": format!(r#"(() => {{ - globalThis.__lm_ws_fetch_result = "pending"; - globalThis.__lm_ws_events = []; - const socket = new WebSocket({socket_literal}, "chat"); - socket.binaryType = "arraybuffer"; - socket.addEventListener('open', () => {{ - globalThis.__lm_ws_events.push(`open:${{socket.protocol}}`); - globalThis.__lm_ws_fetch_result = globalThis.__lm_ws_events.join(','); - }}); - socket.addEventListener('message', (event) => {{ - if (typeof event.data === 'string') {{ - globalThis.__lm_ws_events.push(`text:${{event.data}}`); - }} else {{ - const bytes = Array.from(new Uint8Array(event.data)).join('-'); - globalThis.__lm_ws_events.push(`binary:${{bytes}}`); - }} - globalThis.__lm_ws_fetch_result = globalThis.__lm_ws_events.join(','); - }}); - socket.addEventListener('close', (event) => {{ - globalThis.__lm_ws_events.push(`close:${{event.code}}:${{event.reason}}:${{event.wasClean}}`); - globalThis.__lm_ws_fetch_result = globalThis.__lm_ws_events.join(','); - }}); - return "scheduled"; - }})()"#) - } - })) - .await; - let _ = take_response_by_id(&mut ctx, 51_172); - - let paused = ctx - .sent - .iter() - .find(|message| { - message["method"] == json!("Fetch.requestPaused") - && message["params"]["resourceType"] == json!("WebSocket") - }) - .cloned() - .expect("WebSocket Fetch.requestPaused event"); - let request_id = paused["params"]["requestId"] - .as_str() - .expect("WebSocket fetch request id") - .to_owned(); - ctx.sent.clear(); - - ctx.process_async(json!({ - "id": 51_173, - "method": "Fetch.fulfillRequest", - "sessionId": "SID-1", - "params": { - "requestId": request_id, - "responseCode": 101, - "responseHeaders": [ - { "name": "Upgrade", "value": "websocket" }, - { "name": "Connection", "value": "Upgrade" }, - { "name": "Sec-WebSocket-Protocol", "value": "chat" } - ] - } - })) - .await; - ctx.expect_result(51_173, json!({}), Some("SID-1")); - - evaluate_until_value_async( - &mut ctx, - "SID-1", - 51_174, - "globalThis.__lm_ws_fetch_result", - &json!("open:chat"), - "synthetic WebSocket to open before injected frames", - ) - .await; - - ctx.process_async(json!({ - "id": 51_175, - "method": "Fetch.dispatchWebSocketMessage", - "sessionId": "SID-1", - "params": { - "requestId": request_id, - "opcode": "Text", - "data": "server-text" - } - })) - .await; - ctx.expect_result(51_175, json!({}), Some("SID-1")); - evaluate_until_value_async( - &mut ctx, - "SID-1", - 51_176, - "globalThis.__lm_ws_fetch_result", - &json!("open:chat,text:server-text"), - "synthetic WebSocket text frame should dispatch to JS", - ) - .await; - - ctx.process_async(json!({ - "id": 51_177, - "method": "Fetch.dispatchWebSocketMessage", - "sessionId": "SID-1", - "params": { - "requestId": request_id, - "opcode": "Binary", - "data": "AQIDBA==" - } - })) - .await; - ctx.expect_result(51_177, json!({}), Some("SID-1")); - evaluate_until_value_async( - &mut ctx, - "SID-1", - 51_178, - "globalThis.__lm_ws_fetch_result", - &json!("open:chat,text:server-text,binary:1-2-3-4"), - "synthetic WebSocket binary frame should dispatch to JS", - ) - .await; - - ctx.process_async(json!({ - "id": 51_179, - "method": "Fetch.closeWebSocket", - "sessionId": "SID-1", - "params": { - "requestId": request_id, - "code": 1000, - "reason": "server-done" - } - })) - .await; - ctx.expect_result(51_179, json!({}), Some("SID-1")); - evaluate_until_value_async( - &mut ctx, - "SID-1", - 51_180, - "globalThis.__lm_ws_fetch_result", - &json!("open:chat,text:server-text,binary:1-2-3-4,close:1000:server-done:true"), - "synthetic WebSocket server close should dispatch to JS", - ) - .await; - - server.abort(); -} - -#[tokio::test(flavor = "multi_thread")] -async fn background_websocket_synthetic_socket_injection_routes_to_session_owner_without_active_page() - { - let (page_url, socket_url, server) = spawn_websocket_page_server().await; - let socket_literal = serde_json::to_string(&socket_url).expect("socket URL literal"); - let mut ctx = TestContext::new(); - with_loaded_http_background_document( - &mut ctx, - &page_url, - "SID-active", - "TID-active", - "SID-background", - "TID-background", - ) - .await; - ctx.sent.clear(); - - ctx.process_async(json!({ - "id": 51_181, - "method": "Fetch.enable", - "sessionId": "SID-background", - "params": { - "patterns": [{ "urlPattern": "*", "requestStage": "Request", "resourceType": "WebSocket" }] - } - })) - .await; - ctx.expect_result(51_181, json!({}), Some("SID-background")); - enable_runtime_async(&mut ctx, "SID-background", 51_182).await; - - ctx.process_async(json!({ - "id": 51_183, - "method": "Runtime.evaluate", - "sessionId": "SID-background", - "params": { - "expression": format!(r#"(() => {{ - globalThis.__lm_ws_fetch_result = "pending"; - globalThis.__lm_ws_events = []; - const socket = new WebSocket({socket_literal}, "chat"); - socket.addEventListener('open', () => {{ - globalThis.__lm_ws_events.push(`open:${{socket.protocol}}`); - globalThis.__lm_ws_fetch_result = globalThis.__lm_ws_events.join(','); - }}); - socket.addEventListener('message', (event) => {{ - globalThis.__lm_ws_events.push(`text:${{event.data}}`); - globalThis.__lm_ws_fetch_result = globalThis.__lm_ws_events.join(','); - }}); - return "scheduled"; - }})()"#) - } - })) - .await; - let _ = take_response_by_id(&mut ctx, 51_183); - - wait_until_scheduler_message( - &mut ctx, - "background WebSocket Fetch.requestPaused event", - |message| { - message["method"] == json!("Fetch.requestPaused") - && message["params"]["resourceType"] == json!("WebSocket") - && message["sessionId"] == json!("SID-background") - }, - ) - .await; - let paused = ctx.take_first_matching( - "background WebSocket Fetch.requestPaused event", - |message| { - message["method"] == json!("Fetch.requestPaused") - && message["params"]["resourceType"] == json!("WebSocket") - && message["sessionId"] == json!("SID-background") - }, - ); - let request_id = paused["params"]["requestId"] - .as_str() - .expect("WebSocket fetch request id") - .to_owned(); - ctx.sent.clear(); - - ctx.process_async(json!({ - "id": 51_184, - "method": "Fetch.fulfillRequest", - "sessionId": "SID-background", - "params": { - "requestId": request_id, - "responseCode": 101, - "responseHeaders": [ - { "name": "Upgrade", "value": "websocket" }, - { "name": "Connection", "value": "Upgrade" }, - { "name": "Sec-WebSocket-Protocol", "value": "chat" } - ] - } - })) - .await; - ctx.expect_result(51_184, json!({}), Some("SID-background")); - - evaluate_until_value_async( - &mut ctx, - "SID-background", - 51_185, - "globalThis.__lm_ws_fetch_result", - &json!("open:chat"), - "background synthetic WebSocket to open without active page", - ) - .await; - - ctx.process_async(json!({ - "id": 51_186, - "method": "Fetch.dispatchWebSocketMessage", - "sessionId": "SID-background", - "params": { - "requestId": request_id, - "opcode": "Text", - "data": "background-server-text" - } - })) - .await; - ctx.expect_result(51_186, json!({}), Some("SID-background")); - - evaluate_until_value_async( - &mut ctx, - "SID-background", - 51_187, - "globalThis.__lm_ws_fetch_result", - &json!("open:chat,text:background-server-text"), - "background synthetic WebSocket text frame should dispatch to owner page", - ) - .await; - ctx.with_fixture(|conn| { - assert_eq!( - conn.browser_context - .as_ref() - .and_then(|browser_context| browser_context.active_target_id()), - Some("TID-active"), - "background Fetch.dispatchWebSocketMessage should not activate the target" + let page_url = format!("http://{addr}/page"); + let socket_url = format!("ws://{addr}/socket"); + let socket_literal = serde_json::to_string(&socket_url).unwrap(); + // Auth admission and type-less filters must not turn the socket into + // a Fetch pause or an ordinary Network request. + for params in [ + json!({}), + json!({"patterns": [{"urlPattern": "*/never-requested"}]}), + json!({"patterns": [{"urlPattern": "*"}]}), + json!({"patterns": [{"urlPattern": "*", "requestStage": "Response"}]}), + json!({"handleAuthRequests": true}), + ] { + let mut ctx = TestContext::new(); + with_loaded_http_document(&mut ctx, &page_url, "SID-1", "TID-1").await; + ctx.process_async(json!({ + "id": 51_000, + "method": "Fetch.enable", + "sessionId": "SID-1", + "params": params + })) + .await; + ctx.expect_result(51_000, json!({}), Some("SID-1")); + ctx.sent.clear(); + ctx.process_async(json!({ + "id": 51_001, + "method": "Runtime.evaluate", + "sessionId": "SID-1", + "params": { + "expression": format!(r#"(() => {{ + globalThis.socketResult = 'pending'; + const socket = new WebSocket({socket_literal}); + socket.onopen = () => socket.send('hello'); + socket.onmessage = event => {{ + globalThis.socketResult = event.data; + socket.close(1000, 'done'); + }}; + socket.onerror = () => {{ globalThis.socketResult = 'error'; }}; + return 'scheduled'; + }})()"#) + } + })) + .await; + let _ = take_response_by_id(&mut ctx, 51_001); + evaluate_until_value_async( + &mut ctx, + "SID-1", + 51_002, + "globalThis.socketResult", + &json!("hello"), + "WebSocket echo without a Fetch continuation", ) - }); - - server.abort(); -} - -#[tokio::test(flavor = "multi_thread")] -async fn websocket_handshake_response_stage_pauses_open_until_continue_response() { - let (page_url, socket_url, server) = spawn_websocket_page_server().await; - let socket_literal = serde_json::to_string(&socket_url).expect("socket URL literal"); - let mut ctx = TestContext::new(); - with_loaded_http_document(&mut ctx, &page_url, "SID-1", "TID-1").await; - ctx.sent.clear(); - - ctx.process_async(json!({ - "id": 51_200, - "method": "Fetch.enable", - "sessionId": "SID-1", - "params": { - "patterns": [{ "urlPattern": "*", "requestStage": "Response", "resourceType": "WebSocket" }] - } - })) - .await; - ctx.expect_result(51_200, json!({}), Some("SID-1")); - enable_runtime_async(&mut ctx, "SID-1", 51_201).await; - - ctx.process_async(json!({ - "id": 51_202, - "method": "Runtime.evaluate", - "sessionId": "SID-1", - "params": { - "expression": format!(r#"(() => {{ - globalThis.__lm_ws_fetch_result = "pending"; - const socket = new WebSocket({socket_literal}); - socket.addEventListener('open', () => {{ - globalThis.__lm_ws_fetch_result = "opened"; - socket.send('hello'); - }}); - socket.addEventListener('message', (event) => {{ - globalThis.__lm_ws_fetch_result = event.data; - socket.close(1000, 'done'); - }}); - socket.addEventListener('error', () => {{ - globalThis.__lm_ws_fetch_result = "error"; - }}); - return "scheduled"; - }})()"#) - } - })) - .await; - let _ = take_response_by_id(&mut ctx, 51_202); - - wait_until_message( - &mut ctx, - "SID-1", - "WebSocket response-stage requestPaused event", - |message| { - message["method"] == json!("Fetch.requestPaused") - && message["params"]["resourceType"] == json!("WebSocket") - && message["params"]["responseStatusCode"] == json!(101) - }, - ) - .await; - let paused = ctx - .sent - .iter() - .find(|message| { - message["method"] == json!("Fetch.requestPaused") - && message["params"]["resourceType"] == json!("WebSocket") - && message["params"]["responseStatusCode"] == json!(101) + .await; + wait_until_messages(&mut ctx, "SID-1", "WebSocket close", |messages| { + messages + .iter() + .any(|message| message["method"] == json!("Network.webSocketClosed")) }) - .cloned() - .expect("WebSocket response-stage Fetch.requestPaused event"); - let request_id = paused["params"]["requestId"] - .as_str() - .expect("WebSocket response-stage fetch request id") - .to_owned(); - assert_eq!(paused["params"]["request"]["url"], socket_url); - - for _ in 0..5 { - ctx.complete_one_ready_scheduler_input_for_test().await; - tokio::time::sleep(std::time::Duration::from_millis(10)).await; + .await; + let created = ctx + .sent + .iter() + .filter(|message| message["method"] == json!("Network.webSocketCreated")) + .collect::>(); + assert_eq!(created.len(), 1, "configuration: {params}"); + assert_eq!(created[0]["params"]["url"], socket_url); + let request_id = &created[0]["params"]["requestId"]; + for method in [ + "Network.webSocketWillSendHandshakeRequest", + "Network.webSocketHandshakeResponseReceived", + "Network.webSocketFrameSent", + "Network.webSocketFrameReceived", + "Network.webSocketClosed", + ] { + assert!( + ctx.sent.iter().any(|message| { + message["method"] == method && &message["params"]["requestId"] == request_id + }), + "missing {method} for {params}: {:?}", + ctx.sent + ); + } + assert!( + ctx.sent.iter().all(|message| { + message["method"] != "Fetch.requestPaused" + && message["method"] != "Network.requestWillBeSent" + && message["method"] != "Network.responseReceived" + && message["method"] != "Network.loadingFinished" + && message["method"] != "Network.loadingFailed" + }), + "WebSocket must use only dedicated Network events for {params}: {:?}", + ctx.sent + ); } - ctx.process_async(json!({ - "id": 51_203, - "method": "Runtime.evaluate", - "sessionId": "SID-1", - "params": { "expression": "globalThis.__lm_ws_fetch_result" } - })) - .await; - let value = take_response_by_id(&mut ctx, 51_203); - assert_eq!(value["result"]["result"]["value"], json!("pending")); - ctx.sent.clear(); - - ctx.process_async(json!({ - "id": 51_300, - "method": "Fetch.continueResponse", - "sessionId": "SID-1", - "params": { "requestId": request_id } - })) - .await; - ctx.expect_result(51_300, json!({}), Some("SID-1")); - - evaluate_until_value_async( - &mut ctx, - "SID-1", - 51_301, - "globalThis.__lm_ws_fetch_result", - &json!("hello"), - "WebSocket to open after Fetch.continueResponse", - ) - .await; - server.abort(); } #[tokio::test(flavor = "multi_thread")] -async fn websocket_handshake_response_stage_continue_response_can_override_101_metadata() { - let (page_url, socket_url, server) = spawn_websocket_page_server().await; - let socket_literal = serde_json::to_string(&socket_url).expect("socket URL literal"); +async fn fetch_rejects_explicit_websocket_filters() { let mut ctx = TestContext::new(); - with_loaded_http_document(&mut ctx, &page_url, "SID-1", "TID-1").await; - ctx.sent.clear(); - - ctx.process_async(json!({ - "id": 51_320, - "method": "Fetch.enable", - "sessionId": "SID-1", - "params": { - "patterns": [{ "urlPattern": "*", "requestStage": "Response", "resourceType": "WebSocket" }] - } - })) - .await; - ctx.expect_result(51_320, json!({}), Some("SID-1")); - enable_runtime_async(&mut ctx, "SID-1", 51_321).await; - - ctx.process_async(json!({ - "id": 51_322, - "method": "Runtime.evaluate", - "sessionId": "SID-1", - "params": { - "expression": format!(r#"(() => {{ - globalThis.__lm_ws_fetch_result = "pending"; - const socket = new WebSocket({socket_literal}, "chat"); - socket.addEventListener('open', () => {{ - socket.send(`meta:${{socket.protocol}}:${{socket.extensions}}:${{document.cookie.includes('ws_continue_response=1')}}`); - }}); - socket.addEventListener('message', (event) => {{ - globalThis.__lm_ws_fetch_result = event.data; - socket.close(1000, 'done'); - }}); - socket.addEventListener('error', () => {{ - globalThis.__lm_ws_fetch_result = "error"; - }}); - return "scheduled"; - }})()"#) - } - })) - .await; - let _ = take_response_by_id(&mut ctx, 51_322); - - wait_until_message( - &mut ctx, - "SID-1", - "WebSocket response-stage requestPaused event before continueResponse override", - |message| { - message["method"] == json!("Fetch.requestPaused") - && message["params"]["resourceType"] == json!("WebSocket") - && message["params"]["responseStatusCode"] == json!(101) - }, - ) - .await; - let paused = ctx - .sent - .iter() - .find(|message| { - message["method"] == json!("Fetch.requestPaused") - && message["params"]["resourceType"] == json!("WebSocket") - && message["params"]["responseStatusCode"] == json!(101) - }) - .cloned() - .expect("WebSocket response-stage Fetch.requestPaused event"); - let request_id = paused["params"]["requestId"] - .as_str() - .expect("WebSocket response-stage fetch request id") - .to_owned(); - ctx.sent.clear(); - - ctx.process_async(json!({ - "id": 51_323, - "method": "Fetch.continueResponse", - "sessionId": "SID-1", - "params": { - "requestId": request_id, - "responseCode": 101, - "responseHeaders": [ - { "name": "Upgrade", "value": "websocket" }, - { "name": "Connection", "value": "Upgrade" }, - { "name": "Sec-WebSocket-Protocol", "value": "chat" }, - { "name": "Sec-WebSocket-Extensions", "value": "x-moli-test" }, - { "name": "Set-Cookie", "value": "ws_continue_response=1; Path=/" } - ] - } - })) - .await; - ctx.expect_result(51_323, json!({}), Some("SID-1")); - - evaluate_until_value_async( - &mut ctx, - "SID-1", - 51_324, - "globalThis.__lm_ws_fetch_result", - &json!("meta:chat:x-moli-test:true"), - "WebSocket response-stage continueResponse override to open with rewritten metadata", - ) - .await; - - server.abort(); -} - -#[tokio::test(flavor = "multi_thread")] -async fn websocket_handshake_response_stage_fulfill_request_can_supply_101_metadata() { - let (page_url, socket_url, server) = spawn_websocket_page_server().await; - let socket_literal = serde_json::to_string(&socket_url).expect("socket URL literal"); - let mut ctx = TestContext::new(); - with_loaded_http_document(&mut ctx, &page_url, "SID-1", "TID-1").await; - ctx.sent.clear(); - - ctx.process_async(json!({ - "id": 51_350, - "method": "Fetch.enable", - "sessionId": "SID-1", - "params": { - "patterns": [{ "urlPattern": "*", "requestStage": "Response", "resourceType": "WebSocket" }] - } - })) - .await; - ctx.expect_result(51_350, json!({}), Some("SID-1")); - enable_runtime_async(&mut ctx, "SID-1", 51_351).await; - - ctx.process_async(json!({ - "id": 51_352, - "method": "Runtime.evaluate", - "sessionId": "SID-1", - "params": { - "expression": format!(r#"(() => {{ - globalThis.__lm_ws_fetch_result = "pending"; - const socket = new WebSocket({socket_literal}, "chat"); - socket.addEventListener('open', () => {{ - socket.send(`fulfilled:${{socket.protocol}}:${{document.cookie.includes('ws_fulfill_response=1')}}`); - }}); - socket.addEventListener('message', (event) => {{ - globalThis.__lm_ws_fetch_result = event.data; - socket.close(1000, 'done'); - }}); - socket.addEventListener('error', () => {{ - globalThis.__lm_ws_fetch_result = "error"; - }}); - return "scheduled"; - }})()"#) - } - })) - .await; - let _ = take_response_by_id(&mut ctx, 51_352); - - wait_until_message( - &mut ctx, - "SID-1", - "WebSocket response-stage requestPaused event before fulfillRequest 101", - |message| { - message["method"] == json!("Fetch.requestPaused") - && message["params"]["resourceType"] == json!("WebSocket") - && message["params"]["responseStatusCode"] == json!(101) - }, - ) - .await; - let paused = ctx - .sent - .iter() - .find(|message| { - message["method"] == json!("Fetch.requestPaused") - && message["params"]["resourceType"] == json!("WebSocket") - && message["params"]["responseStatusCode"] == json!(101) - }) - .cloned() - .expect("WebSocket response-stage Fetch.requestPaused event"); - let request_id = paused["params"]["requestId"] - .as_str() - .expect("WebSocket response-stage fetch request id") - .to_owned(); - ctx.sent.clear(); - - ctx.process_async(json!({ - "id": 51_353, - "method": "Fetch.fulfillRequest", - "sessionId": "SID-1", - "params": { - "requestId": request_id, - "responseCode": 101, - "responseHeaders": [ - { "name": "Upgrade", "value": "websocket" }, - { "name": "Connection", "value": "Upgrade" }, - { "name": "Sec-WebSocket-Protocol", "value": "chat" }, - { "name": "Set-Cookie", "value": "ws_fulfill_response=1; Path=/" } - ] - } - })) - .await; - ctx.expect_result(51_353, json!({}), Some("SID-1")); - - evaluate_until_value_async( - &mut ctx, - "SID-1", - 51_354, - "globalThis.__lm_ws_fetch_result", - &json!("fulfilled:chat:true"), - "WebSocket response-stage fulfillRequest 101 to open with supplied metadata", - ) - .await; - - server.abort(); -} - -#[tokio::test(flavor = "multi_thread")] -async fn websocket_handshake_response_stage_fail_request_dispatches_error_and_close() { - let (page_url, socket_url, server) = spawn_websocket_page_server().await; - let socket_literal = serde_json::to_string(&socket_url).expect("socket URL literal"); - let mut ctx = TestContext::new(); - with_loaded_http_document(&mut ctx, &page_url, "SID-1", "TID-1").await; - ctx.sent.clear(); - - ctx.process_async(json!({ - "id": 51_400, - "method": "Fetch.enable", - "sessionId": "SID-1", - "params": { - "patterns": [{ "urlPattern": "*", "requestStage": "Response", "resourceType": "WebSocket" }] - } - })) - .await; - ctx.expect_result(51_400, json!({}), Some("SID-1")); - enable_runtime_async(&mut ctx, "SID-1", 51_401).await; - - ctx.process_async(json!({ - "id": 51_402, - "method": "Runtime.evaluate", - "sessionId": "SID-1", - "params": { - "expression": format!(r#"(() => {{ - globalThis.__lm_ws_fetch_result = "pending"; - const events = []; - const socket = new WebSocket({socket_literal}); - socket.addEventListener('open', () => events.push('open')); - socket.addEventListener('error', () => events.push('error')); - socket.addEventListener('close', (event) => {{ - events.push(`close:${{event.code}}`); - globalThis.__lm_ws_fetch_result = events.join(','); - }}); - return "scheduled"; - }})()"#) - } - })) - .await; - let _ = take_response_by_id(&mut ctx, 51_402); - - wait_until_message( - &mut ctx, - "SID-1", - "WebSocket response-stage requestPaused event before failRequest", - |message| { - message["method"] == json!("Fetch.requestPaused") - && message["params"]["resourceType"] == json!("WebSocket") - && message["params"]["responseStatusCode"] == json!(101) - }, - ) - .await; - let paused = ctx - .sent - .iter() - .find(|message| { - message["method"] == json!("Fetch.requestPaused") - && message["params"]["resourceType"] == json!("WebSocket") - && message["params"]["responseStatusCode"] == json!(101) - }) - .cloned() - .expect("WebSocket response-stage Fetch.requestPaused event"); - let request_id = paused["params"]["requestId"] - .as_str() - .expect("WebSocket response-stage fetch request id") - .to_owned(); - ctx.sent.clear(); - - ctx.process_async(json!({ - "id": 51_403, - "method": "Fetch.failRequest", - "sessionId": "SID-1", - "params": { - "requestId": request_id, - "errorReason": "Aborted" - } - })) - .await; - ctx.expect_result(51_403, json!({}), Some("SID-1")); - - evaluate_until_value_async( - &mut ctx, - "SID-1", - 51_404, - "globalThis.__lm_ws_fetch_result", - &json!("error,close:1006"), - "WebSocket response-stage failRequest to dispatch error and close", - ) - .await; - - server.abort(); + let mut bc = BrowserContext::new("BID-1".into()); + bc.set_active_target_id("TID-1"); + bc.attach_active_session("SID-1"); + ctx.with_fixture(|conn| conn.install_browser_context_fixture_for_test(bc)); + for request_stage in ["Request", "Response"] { + ctx.process_async(json!({ + "id": 51_003, + "method": "Fetch.enable", + "sessionId": "SID-1", + "params": {"patterns": [{"resourceType": "WebSocket", "requestStage": request_stage}]} + })) + .await; + let response = take_response_by_id(&mut ctx, 51_003); + assert_eq!(response["error"]["code"], -32602, "{response:?}"); + } } diff --git a/moli-protocol/src/domains/network/backlog.rs b/moli-protocol/src/domains/network/backlog.rs index 6639227212f..b16dd69f23f 100644 --- a/moli-protocol/src/domains/network/backlog.rs +++ b/moli-protocol/src/domains/network/backlog.rs @@ -271,6 +271,12 @@ fn emit_complete_subresource_network_delivery_record( let initial_output_len = out.len(); let request_id = delivery_output.request_id(); let output = delivery_output.metadata(); + // The same native handshake record also feeds the dedicated WebSocket + // delivery below. Publishing it as an ordinary HTTP request would give + // clients an extra inflight request for a long-lived socket. + if output.resource_type() == moli_core::page::SubresourceResourceType::WebSocket { + return false; + } let Some(runtime_slot) = conn.runtime_session_owner_slot_mut_for_owner(owner) else { return false; }; @@ -289,16 +295,14 @@ fn emit_complete_subresource_network_delivery_record( if !runtime_slot.claim_completed_subresource_request_id(request_id) { return false; } - if output.resource_type() != moli_core::page::SubresourceResourceType::WebSocket { - record_subresource_pending_response_body(conn, owner, request_id, event_session_ids); - record_subresource_request_body( - conn, - owner, - request_id, - output.request_body_bytes(), - event_session_ids, - ); - } + record_subresource_pending_response_body(conn, owner, request_id, event_session_ids); + record_subresource_request_body( + conn, + owner, + request_id, + output.request_body_bytes(), + event_session_ids, + ); if !request_was_announced_by_fetch_pause { for event_session_id in event_session_ids { emit_request_will_be_sent( @@ -407,15 +411,13 @@ fn emit_complete_subresource_network_delivery_record( } } TargetSubresourceMetadataOutcome::Failure { error_text } => { - if output.resource_type() != moli_core::page::SubresourceResourceType::WebSocket { - record_subresource_failed_response_body( - conn, - owner, - error_text.clone(), - request_id, - event_session_ids, - ); - } + record_subresource_failed_response_body( + conn, + owner, + error_text.clone(), + request_id, + event_session_ids, + ); for event_session_id in event_session_ids { emit_loading_failed( out, diff --git a/moli-protocol/src/domains/network/tests/blocked_urls.rs b/moli-protocol/src/domains/network/tests/blocked_urls.rs index cd0afd062de..01a9fb7f796 100644 --- a/moli-protocol/src/domains/network/tests/blocked_urls.rs +++ b/moli-protocol/src/domains/network/tests/blocked_urls.rs @@ -9,6 +9,65 @@ async fn enable_network_domain(ctx: &mut TestContext, id: u64, session_id: Optio ctx.expect_result(id, json!({}), session_id); } +async fn assert_blocked_websocket_events(ctx: &mut TestContext, url: &str) -> serde_json::Value { + wait_until_messages( + ctx, + Some("SID-1"), + "blocked WebSocket terminal", + |messages| { + let Some(created) = messages.iter().find(|message| { + message["method"] == "Network.webSocketCreated" && message["params"]["url"] == url + }) else { + return false; + }; + messages.iter().any(|message| { + message["method"] == "Network.webSocketClosed" + && message["params"]["requestId"] == created["params"]["requestId"] + }) + }, + ) + .await; + let created = ctx + .sent + .iter() + .find(|message| { + message["method"] == "Network.webSocketCreated" && message["params"]["url"] == url + }) + .unwrap(); + let request_id = &created["params"]["requestId"]; + let events = ctx + .sent + .iter() + .filter(|message| &message["params"]["requestId"] == request_id) + .collect::>(); + let methods = events + .iter() + .map(|message| message["method"].as_str().unwrap()) + .collect::>(); + assert_eq!( + methods, + [ + "Network.webSocketCreated", + "Network.webSocketWillSendHandshakeRequest", + "Network.webSocketFrameError", + "Network.webSocketClosed" + ] + ); + assert!(events.iter().all(|message| message["sessionId"] == "SID-1")); + assert_eq!( + events[2]["params"]["errorMessage"], + "net::ERR_BLOCKED_BY_CLIENT" + ); + assert!( + ctx.sent + .iter() + .all(|message| message["method"] != "Network.requestWillBeSent" + || (message["params"]["request"]["url"] != url + && message["params"]["type"] != "WebSocket")) + ); + events[1]["params"]["request"].clone() +} + #[tokio::test(flavor = "multi_thread")] async fn set_blocked_urls_requires_browser_context() { let mut ctx = TestContext::new(); @@ -713,7 +772,7 @@ async fn set_blocked_urls_worker_xhr_emits_loading_failed() { assert_eq!(result["result"]["result"]["value"], "failed:0"); } #[tokio::test(flavor = "multi_thread")] -async fn set_blocked_urls_worker_websocket_emits_loading_failed() { +async fn set_blocked_urls_worker_websocket_emits_dedicated_failure_events() { let mut ctx = TestContext::new(); let mut bc = BrowserContext::new("BID-1".into()); bc.set_active_target_id("TID-1"); @@ -800,50 +859,9 @@ async fn set_blocked_urls_worker_websocket_emits_loading_failed() { .find(|message| message["id"] == json!(2826)) .cloned() .expect("runtime evaluate result"); - flush_until_subresource_failed(&mut ctx, "WebSocket", "blocked worker websocket failure").await; - let failed = ctx - .sent - .iter() - .find(|message| message["method"] == json!("Network.loadingFailed")) - .cloned() - .expect("network loadingFailed event"); - assert_eq!(failed["sessionId"], "SID-1"); - assert_eq!(failed["params"]["type"], "WebSocket"); - assert_eq!(failed["params"]["errorText"], "net::ERR_BLOCKED_BY_CLIENT"); - let request_id = failed["params"]["requestId"] - .as_str() - .expect("failed request id"); - let request = ctx - .sent - .iter() - .find(|message| { - message["method"] == json!("Network.requestWillBeSent") - && message["params"]["requestId"] == json!(request_id) - }) - .expect("matching requestWillBeSent"); - assert_eq!( - request["params"]["request"]["url"], - "ws://example.test/blocked/worker-ws" - ); - assert_eq!( - request["params"]["request"]["headers"]["x-cdp-test"], - "works-worker-ws" - ); - ctx.complete_one_ready_scheduler_input_for_test().await; - let worker_ws_failures = ctx - .sent - .iter() - .filter(|message| { - message["method"] == json!("Network.loadingFailed") - && message["params"]["type"] == json!("WebSocket") - && message["params"]["errorText"] == json!("net::ERR_BLOCKED_BY_CLIENT") - }) - .count(); - assert_eq!(worker_ws_failures, 1); - assert!(ctx.sent.iter().any(|message| { - message["method"] == json!("Network.webSocketCreated") - && message["params"]["url"] == json!("ws://example.test/blocked/worker-ws") - })); + let request = + assert_blocked_websocket_events(&mut ctx, "ws://example.test/blocked/worker-ws").await; + assert_eq!(request["headers"]["x-cdp-test"], "works-worker-ws"); ctx.process_and_wait_for_response_async(json!({ "id": 2827, @@ -1191,7 +1209,7 @@ async fn set_blocked_urls_runtime_xhr_emits_loading_failed() { assert_eq!(result["result"]["result"]["value"], "failed:0"); } #[tokio::test(flavor = "multi_thread")] -async fn set_blocked_urls_runtime_websocket_emits_loading_failed() { +async fn set_blocked_urls_runtime_websocket_emits_dedicated_failure_events() { let mut ctx = TestContext::new(); let mut bc = BrowserContext::new("BID-1".into()); bc.set_active_target_id("TID-1"); @@ -1257,28 +1275,7 @@ async fn set_blocked_urls_runtime_websocket_emits_loading_failed() { .find(|message| message["id"] == json!(2819)) .cloned() .expect("runtime evaluate result"); - flush_until_subresource_failed(&mut ctx, "WebSocket", "blocked websocket failure").await; - let failed = ctx - .sent - .iter() - .find(|message| { - message["method"] == json!("Network.loadingFailed") - && message["params"]["type"] == json!("WebSocket") - }) - .cloned() - .expect("network loadingFailed event"); - assert_eq!(failed["sessionId"], "SID-1"); - assert_eq!(failed["params"]["errorText"], "net::ERR_BLOCKED_BY_CLIENT"); - let websocket_created = ctx - .sent - .iter() - .find(|message| message["method"] == json!("Network.webSocketCreated")) - .cloned() - .expect("webSocketCreated event"); - assert_eq!( - websocket_created["params"]["url"], - "ws://example.test/blocked/socket" - ); + assert_blocked_websocket_events(&mut ctx, "ws://example.test/blocked/socket").await; ctx.process_async(json!({ "id": 2820,