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,