Best headless browser for AI agents. Lite, Fast, High-Compatibility. Built in Rust
Rust ai-agentsai-toolsbrowserbrowser-automationcloud-browserheadlessheadless-browserkitesurfplaywrightpuppeteerrustservoweb-crawlerweb-crawlingweb-scraperweb-scraping
use crate::{
WptManifestOrigin, WptManifestTest,
meta::{extract_wpt_meta_script_references, resolve_wpt_static_resource_reference},
};
use anyhow::{Context, Result};
use axum::{
Router,
body::{Body, Bytes},
extract::{
Path, Query, State,
ws::{Message as WebSocketMessage, WebSocket, WebSocketUpgrade},
},
http::{
HeaderMap, HeaderName, HeaderValue, Method, StatusCode, Uri,
header::{
ACCESS_CONTROL_ALLOW_CREDENTIALS, ACCESS_CONTROL_ALLOW_HEADERS,
ACCESS_CONTROL_ALLOW_METHODS, ACCESS_CONTROL_ALLOW_ORIGIN,
ACCESS_CONTROL_EXPOSE_HEADERS, ACCESS_CONTROL_REQUEST_HEADERS,
ACCESS_CONTROL_REQUEST_METHOD, CONTENT_TYPE, COOKIE, HOST, LOCATION, ORIGIN,
SET_COOKIE, VARY,
},
},
response::{IntoResponse, Redirect, Response},
routing::{any, get, post},
serve::Listener,
};
use parking_lot::Mutex;
use std::{
collections::{HashMap, HashSet},
io,
path::{Component, Path as StdPath, PathBuf},
sync::{Arc, OnceLock},
};
use tokio::{
net::{TcpListener, TcpStream},
sync::{mpsc, oneshot},
task::JoinHandle,
time::{Duration, sleep},
};
use tokio_rustls::{TlsAcceptor, server::TlsStream};
use tokio_stream::wrappers::ReceiverStream;
const COMPILED_WPT_FIXTURE_ROOT: &str = concat!(env!("CARGO_MANIFEST_DIR"), "/fixtures/wpt");
const WPT_STATIC_FIXTURE_TOP_LEVEL_DIRS: &[&str] = &["assets", "ported", "resources", "upstream"];
const WPT_BROWSER_HOST: &str = "localhost";
const WPT_INSECURE_HOST: &str = "0.0.0.0";
const WPT_REMOTE_HOST: &str = "127.0.0.1";
const WPT_WINDOW_WRAPPER_QUERY: &str = "moli-wpt-window-wrapper";
const WPT_WORKER_ENTRY_QUERY: &str = "moli-wpt-worker-entry";
const WPT_SHARED_WORKER_WRAPPER_QUERY: &str = "moli-wpt-shared-worker-wrapper";
const WPT_WORKER_WRAPPER_QUERY: &str = "moli-wpt-worker-wrapper";
const WPT_XHR_TEXT_BODY: &str = "1234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890";
const WPT_XHR_JSON_BODY: &str = r#"{"over":"9000!!!","updated_at":1765867200000}"#;
const WPT_WORKER_SLOW_BODY: &str = r#"postMessage("loaded");
onmessage = (event) => {
postMessage(`pong:${event.data}`);
};
"#;
const WPT_WORKER_IMPORTSCRIPTS_ARGS_WORKER_BODY: &str = r#"onmessage = function (event) {
switch (event.data) {
case "symbol":
try {
importScripts(Symbol("worker.js"));
postMessage({ name: "unexpected-success" });
} catch (error) {
postMessage({ name: error && error.name });
}
close();
return;
case "invalid-url":
try {
importScripts(
"data:text/javascript,globalThis.__lmImportScriptsRan=true",
"http://foo bar"
);
postMessage({ name: "unexpected-success", ran: globalThis.__lmImportScriptsRan === true });
} catch (error) {
postMessage({
name: error && error.name,
ran: globalThis.__lmImportScriptsRan === true,
});
}
close();
return;
case "stringify":
importScripts(undefined, null, 1);
postMessage({
undefinedLoaded: globalThis.__undefinedLoaded === true,
nullLoaded: globalThis.__nullLoaded === true,
oneLoaded: globalThis.__oneLoaded === true,
});
close();
return;
default:
postMessage({
name: "unexpected-scenario",
scenario: event.data,
});
close();
}
};
"#;
const WPT_WORKER_IMPORTSCRIPTS_UNDEFINED_BODY: &str = "globalThis.__undefinedLoaded = true;\n";
const WPT_WORKER_IMPORTSCRIPTS_NULL_BODY: &str = "globalThis.__nullLoaded = true;\n";
const WPT_WORKER_IMPORTSCRIPTS_ONE_BODY: &str = "globalThis.__oneLoaded = true;\n";
#[derive(Default)]
struct AbortObservationRegistry {
states: Mutex<HashMap<String, Option<bool>>>,
}
impl AbortObservationRegistry {
fn mark_pending(&self, token: &str) {
self.states.lock().insert(token.to_owned(), None);
}
fn mark_complete(&self, token: &str, disconnected: bool) {
self.states
.lock()
.insert(token.to_owned(), Some(disconnected));
}
fn lookup(&self, token: &str) -> Option<Option<bool>> {
self.states.lock().get(token).copied()
}
}
#[derive(Default)]
struct CorsPreflightObservationRegistry {
states: Mutex<HashSet<String>>,
}
impl CorsPreflightObservationRegistry {
fn mark_preflight(&self, token: &str) {
self.states.lock().insert(token.to_owned());
}
fn take_preflighted(&self, token: &str) -> bool {
self.states.lock().remove(token)
}
}
#[derive(Default)]
struct CspReportObservationRegistry {
reports: Mutex<HashMap<String, Vec<CspReportObservation>>>,
}
struct CspReportObservation {
content_type: Option<String>,
body: String,
}
impl CspReportObservationRegistry {
fn push(&self, token: &str, report: CspReportObservation) {
self.reports
.lock()
.entry(token.to_owned())
.or_default()
.push(report);
}
fn take(&self, token: &str) -> Vec<CspReportObservation> {
self.reports.lock().remove(token).unwrap_or_default()
}
}
#[derive(Clone)]
struct WptFixtureRuntimeState {
primary_addr: std::net::SocketAddr,
secondary_addr: std::net::SocketAddr,
primary_https_addr: std::net::SocketAddr,
secondary_https_addr: std::net::SocketAddr,
abort_observations: Arc<AbortObservationRegistry>,
cors_preflight_observations: Arc<CorsPreflightObservationRegistry>,
csp_report_observations: Arc<CspReportObservationRegistry>,
}
struct WptTlsListener {
listener: TcpListener,
acceptor: TlsAcceptor,
}
impl WptTlsListener {
fn new(listener: TcpListener, acceptor: TlsAcceptor) -> Self {
Self { listener, acceptor }
}
}
impl Listener for WptTlsListener {
type Io = TlsStream<TcpStream>;
type Addr = std::net::SocketAddr;
async fn accept(&mut self) -> (Self::Io, Self::Addr) {
loop {
let (stream, addr) = match self.listener.accept().await {
Ok(accepted) => accepted,
Err(_) => {
sleep(Duration::from_millis(1)).await;
continue;
}
};
match self.acceptor.accept(stream).await {
Ok(stream) => return (stream, addr),
Err(_) => continue,
}
}
}
fn local_addr(&self) -> io::Result<Self::Addr> {
self.listener.local_addr()
}
}
fn wpt_tls_acceptor() -> Result<TlsAcceptor> {
use tokio_rustls::rustls::{
ServerConfig,
pki_types::{CertificateDer, PrivateKeyDer, PrivatePkcs8KeyDer},
};
let cert = rcgen::generate_simple_self_signed(vec![
WPT_BROWSER_HOST.to_owned(),
WPT_REMOTE_HOST.to_owned(),
])
.context("failed to generate WPT fixture TLS certificate")?;
let cert_der = CertificateDer::from(cert.cert.der().to_vec());
let key_der = PrivateKeyDer::from(PrivatePkcs8KeyDer::from(cert.key_pair.serialize_der()));
let config = ServerConfig::builder()
.with_no_client_auth()
.with_single_cert(vec![cert_der], key_der)
.context("failed to build WPT fixture TLS config")?;
Ok(TlsAcceptor::from(Arc::new(config)))
}
pub struct WptFixtureServer {
addr: std::net::SocketAddr,
https_addr: std::net::SocketAddr,
shutdown_txs: Vec<oneshot::Sender<()>>,
tasks: Vec<JoinHandle<()>>,
}
impl WptFixtureServer {
pub async fn spawn() -> Result<Self> {
let primary_listener = TcpListener::bind("127.0.0.1:0")
.await
.context("failed to bind primary WPT fixture server")?;
let addr = primary_listener
.local_addr()
.context("failed to read primary WPT fixture server address")?;
let secondary_listener = TcpListener::bind("127.0.0.1:0")
.await
.context("failed to bind secondary WPT fixture server")?;
let secondary_addr = secondary_listener
.local_addr()
.context("failed to read secondary WPT fixture server address")?;
let primary_https_listener = TcpListener::bind("127.0.0.1:0")
.await
.context("failed to bind primary HTTPS WPT fixture server")?;
let primary_https_addr = primary_https_listener
.local_addr()
.context("failed to read primary HTTPS WPT fixture server address")?;
let secondary_https_listener = TcpListener::bind("127.0.0.1:0")
.await
.context("failed to bind secondary HTTPS WPT fixture server")?;
let secondary_https_addr = secondary_https_listener
.local_addr()
.context("failed to read secondary HTTPS WPT fixture server address")?;
let tls_acceptor = wpt_tls_acceptor()?;
let primary_tls_acceptor = tls_acceptor.clone();
let secondary_tls_acceptor = tls_acceptor;
let runtime_state = WptFixtureRuntimeState {
primary_addr: addr,
secondary_addr,
primary_https_addr,
secondary_https_addr,
abort_observations: Arc::new(AbortObservationRegistry::default()),
cors_preflight_observations: Arc::new(CorsPreflightObservationRegistry::default()),
csp_report_observations: Arc::new(CspReportObservationRegistry::default()),
};
let app = wpt_fixture_app(runtime_state);
let primary_app = app.clone();
let primary_https_app = app.clone();
let secondary_https_app = app.clone();
let (primary_shutdown_tx, primary_shutdown_rx) = oneshot::channel();
let (secondary_shutdown_tx, secondary_shutdown_rx) = oneshot::channel();
let (primary_https_shutdown_tx, primary_https_shutdown_rx) = oneshot::channel();
let (secondary_https_shutdown_tx, secondary_https_shutdown_rx) = oneshot::channel();
let primary_task = tokio::spawn(async move {
if let Err(error) = axum::serve(primary_listener, primary_app)
.with_graceful_shutdown(async {
let _ = primary_shutdown_rx.await;
})
.await
{
panic!("WPT fixture server failed: {error}");
}
});
let secondary_task = tokio::spawn(async move {
if let Err(error) = axum::serve(secondary_listener, app)
.with_graceful_shutdown(async {
let _ = secondary_shutdown_rx.await;
})
.await
{
panic!("WPT fixture server failed: {error}");
}
});
let primary_https_task = tokio::spawn(async move {
let listener = WptTlsListener::new(primary_https_listener, primary_tls_acceptor);
if let Err(error) = axum::serve(listener, primary_https_app)
.with_graceful_shutdown(async {
let _ = primary_https_shutdown_rx.await;
})
.await
{
panic!("WPT HTTPS fixture server failed: {error}");
}
});
let secondary_https_task = tokio::spawn(async move {
let listener = WptTlsListener::new(secondary_https_listener, secondary_tls_acceptor);
if let Err(error) = axum::serve(listener, secondary_https_app)
.with_graceful_shutdown(async {
let _ = secondary_https_shutdown_rx.await;
})
.await
{
panic!("WPT HTTPS fixture server failed: {error}");
}
});
Ok(Self {
addr,
https_addr: primary_https_addr,
shutdown_txs: vec![
primary_shutdown_tx,
secondary_shutdown_tx,
primary_https_shutdown_tx,
secondary_https_shutdown_tx,
],
tasks: vec![
primary_task,
secondary_task,
primary_https_task,
secondary_https_task,
],
})
}
pub fn url(&self, path: &str) -> String {
format!("http://{}:{}{}", WPT_BROWSER_HOST, self.addr.port(), path)
}
pub fn case_url(&self, test: &WptManifestTest) -> String {
let secure =
test.origin == WptManifestOrigin::Trusted && test.local_path.contains(".https.");
let mut url = wpt_case_url(
if secure { self.https_addr } else { self.addr },
&test.local_path,
&test.global,
&test.query,
test.origin,
);
if test.test_type == "crashtest" {
append_raw_query(&mut url, "moli-wpt-crashtest=1");
}
if secure {
url.replacen("http:", "https:", 1)
} else {
url
}
}
pub fn fixture_url(&self, local_path: &str) -> String {
wpt_fixture_url(self.addr, local_path)
}
#[cfg(test)]
pub(crate) fn for_test_addr(addr: std::net::SocketAddr) -> Self {
Self {
addr,
https_addr: addr,
shutdown_txs: Vec::new(),
tasks: Vec::new(),
}
}
pub async fn shutdown(mut self) {
while let Some(shutdown_tx) = self.shutdown_txs.pop() {
let _ = shutdown_tx.send(());
}
while let Some(task) = self.tasks.pop() {
let _ = task.await;
}
}
}
fn wpt_fixture_app(runtime_state: WptFixtureRuntimeState) -> Router {
Router::new()
.route("/wpt/runtime/cookies/http-set", get(wpt_cookie_http_set))
.route(
"/wpt/runtime/cookies/http-check",
get(wpt_cookie_http_check),
)
.route(
"/wpt/runtime/cookies/path-scope/set",
get(wpt_cookie_path_scope_set),
)
.route(
"/wpt/runtime/cookies/path-scope/check",
get(wpt_cookie_path_scope_check),
)
.route(
"/wpt/runtime/cookies/path-scope-extra/check",
get(wpt_cookie_path_scope_extra_check),
)
.route(
"/wpt/runtime/cookies/invalid-domain/set",
get(wpt_cookie_invalid_domain_set),
)
.route(
"/wpt/runtime/cookies/invalid-domain/check",
get(wpt_cookie_invalid_domain_check),
)
.route(
"/wpt/runtime/cookies/replace/red",
get(wpt_cookie_replace_red),
)
.route(
"/wpt/runtime/cookies/replace/blue",
get(wpt_cookie_replace_blue),
)
.route(
"/wpt/runtime/cookies/replace/check",
get(wpt_cookie_replace_check),
)
.route(
"/wpt/runtime/cookies/samesite/set",
get(wpt_cookie_samesite_set),
)
.route(
"/wpt/runtime/cookies/samesite/check",
get(wpt_cookie_samesite_check),
)
.route(
"/wpt/runtime/cookies/redirect-chain/start",
get(wpt_cookie_redirect_chain_start),
)
.route(
"/wpt/runtime/cookies/redirect-chain/middle",
get(wpt_cookie_redirect_chain_middle),
)
.route(
"/wpt/runtime/cookies/redirect-chain/final",
get(wpt_cookie_redirect_chain_final),
)
.route("/wpt/runtime/xhr/text", get(wpt_xhr_text))
.route("/wpt/runtime/xhr/html-text", get(wpt_xhr_html_text))
.route("/wpt/runtime/xhr/json", get(wpt_xhr_json))
.route("/wpt/runtime/xhr/binary", get(wpt_xhr_binary))
.route("/wpt/runtime/xhr/redirect", get(wpt_xhr_redirect))
.route("/wpt/runtime/xhr/404", get(wpt_xhr_404))
.route("/wpt/runtime/xhr/500", get(wpt_xhr_500))
.route("/wpt/runtime/xhr/slow", get(wpt_xhr_slow))
.route("/wpt/runtime/xhr/very-slow", get(wpt_xhr_very_slow))
.route("/wpt/runtime/xhr/empty", get(wpt_xhr_empty))
.route(
"/wpt/runtime/xhr/abort-observing/{token}",
get(wpt_xhr_abort_observing),
)
.route(
"/wpt/runtime/xhr/abort-observing-status/{token}",
get(wpt_xhr_abort_observing_status),
)
.route(
"/wpt/runtime/fetch/abort-observing/{token}",
get(wpt_fetch_abort_observing),
)
.route(
"/wpt/runtime/fetch/abort-observing-status/{token}",
get(wpt_fetch_abort_observing_status),
)
.route(
"/wpt/runtime/xhr/request-headers",
get(wpt_xhr_request_headers),
)
.route(
"/wpt/runtime/fetch/request-headers",
get(wpt_xhr_request_headers),
)
.route("/wpt/runtime/xhr/echo-body", post(wpt_xhr_echo_body))
.route("/wpt/runtime/xhr/echo-body-hex", post(wpt_echo_body_hex))
.route("/wpt/runtime/cors/allow", get(wpt_cors_allow))
.route("/wpt/runtime/cors/deny", get(wpt_cors_deny))
.route("/wpt/runtime/cors/exposed", get(wpt_cors_exposed_headers))
.route(
"/wpt/runtime/cors/exposed/wildcard",
get(wpt_cors_exposed_headers_wildcard),
)
.route(
"/wpt/runtime/cors/exposed/wildcard-credentials",
get(wpt_cors_exposed_headers_wildcard_credentials),
)
.route(
"/wpt/runtime/cors/preflight/allow",
any(wpt_cors_preflight_allow),
)
.route(
"/wpt/runtime/cors/preflight/deny-method",
any(wpt_cors_preflight_deny_method),
)
.route(
"/wpt/runtime/cors/preflight/deny-header",
any(wpt_cors_preflight_deny_header),
)
.route(
"/wpt/runtime/cors/preflight/redirect-to-allow",
any(wpt_cors_preflight_redirect_to_allow),
)
.route(
"/wpt/runtime/cors/preflight/redirect-to-preflight-required",
any(wpt_cors_preflight_redirect_to_preflight_required),
)
.route(
"/wpt/runtime/cors/preflight/preflight-required-final",
any(wpt_cors_preflight_required_final),
)
.route(
"/wpt/runtime/cors/redirect/to-credentials-allow",
get(wpt_cors_redirect_to_credentials_allow),
)
.route(
"/wpt/runtime/cors/redirect/to-same-origin-echo",
get(wpt_cors_redirect_to_same_origin_echo),
)
.route(
"/wpt/runtime/cors/redirect/to-alt-to-same-origin-echo",
get(wpt_cors_redirect_to_alt_to_same_origin_echo),
)
.route(
"/wpt/runtime/cors/redirect/to-cross-site-to-same-origin-echo",
get(wpt_cors_redirect_to_cross_site_to_same_origin_echo),
)
.route(
"/wpt/runtime/cors/redirect/303-to-method-echo",
any(wpt_cors_redirect_303_to_method_echo),
)
.route(
"/wpt/runtime/cors/redirect/307-to-method-echo",
any(wpt_cors_redirect_307_to_method_echo),
)
.route(
"/wpt/runtime/cors/redirect/method-echo",
any(wpt_cors_redirect_method_echo),
)
.route(
"/wpt/runtime/cors/redirect/same-origin-echo",
get(wpt_cors_redirect_same_origin_echo),
)
.route(
"/wpt/runtime/cors/credentials/allow",
get(wpt_cors_credentials_allow),
)
.route(
"/wpt/runtime/cors/credentials/wildcard",
get(wpt_cors_credentials_wildcard),
)
.route("/wpt/runtime/forms/submit-echo", any(wpt_form_submit_echo))
.route("/wpt/runtime/websocket/echo", get(wpt_websocket_echo))
.route(
"/wpt/runtime/websocket/cookie-set",
get(wpt_websocket_cookie_set),
)
.route(
"/wpt/runtime/websocket/cookie-echo",
get(wpt_websocket_cookie_echo),
)
.route(
"/wpt/runtime/websocket/subprotocol",
get(wpt_websocket_subprotocol),
)
.route(
"/wpt/runtime/websocket/server-close",
get(wpt_websocket_server_close),
)
.route(
"/wpt/runtime/websocket/slow-handshake",
get(wpt_websocket_slow_handshake),
)
.route(
"/wpt/runtime/websocket/plain-200",
get(wpt_websocket_plain_200),
)
.route(
"/wpt/runtime/websocket/response-cookie",
get(wpt_websocket_response_cookie),
)
.route(
"/wpt/runtime/worker/module-redirect/start.js",
get(wpt_worker_module_redirect_start),
)
.route(
"/wpt/runtime/worker/module-redirect/fragment-start.js",
get(wpt_worker_module_redirect_fragment_start),
)
.route(
"/wpt/runtime/worker/module-credentials/set-cookie",
get(wpt_worker_module_credentials_cookie_set),
)
.route(
"/wpt/runtime/worker/module-credentials/check-cookie",
get(wpt_worker_module_credentials_cookie_check),
)
.route(
"/wpt/runtime/worker/module-credentials/main.js",
get(wpt_worker_module_credentials_main),
)
.route(
"/wpt/runtime/worker/module-credentials/dependency.js",
get(wpt_worker_module_credentials_dependency),
)
.route(
"/wpt/runtime/sharedworker/script-fetch-policy/set-cookie",
get(wpt_shared_worker_script_fetch_policy_cookie_set),
)
.route(
"/wpt/runtime/sharedworker/script-fetch-policy/set-remote-cookie",
get(wpt_shared_worker_script_fetch_policy_remote_cookie_set),
)
.route(
"/wpt/runtime/sharedworker/script-fetch-policy/report-cookie.js",
get(wpt_shared_worker_script_fetch_policy_report_cookie),
)
.route(
"/wpt/runtime/sharedworker/script-fetch-policy/report-import-cookie-main.js",
get(wpt_shared_worker_script_fetch_policy_report_import_cookie_main),
)
.route(
"/wpt/runtime/sharedworker/script-fetch-policy/report-import-cookie-dependency.js",
get(wpt_shared_worker_script_fetch_policy_report_import_cookie_dependency),
)
.route(
"/wpt/runtime/sharedworker/script-fetch-policy/report-import-cookie-remote-dependency.js",
get(wpt_shared_worker_script_fetch_policy_report_import_cookie_remote_dependency),
)
.route(
"/wpt/runtime/sharedworker/script-fetch-policy/referrer-policy-main.js",
get(wpt_shared_worker_script_fetch_policy_referrer_policy_main),
)
.route(
"/wpt/runtime/sharedworker/script-fetch-policy/report-referrer-dependency.js",
get(wpt_shared_worker_script_fetch_policy_report_referrer_dependency),
)
.route(
"/wpt/runtime/sharedworker/script-fetch-policy/cross-origin-redirect-start.js",
get(wpt_shared_worker_script_fetch_policy_cross_origin_redirect_start),
)
.route(
"/wpt/runtime/sharedworker/script-fetch-policy/cross-origin-target.js",
get(wpt_shared_worker_script_fetch_policy_cross_origin_target),
)
.route(
"/wpt/runtime/csp/reporting/target.txt",
get(wpt_csp_reporting_target),
)
.route(
"/wpt/runtime/csp/reporting/collect",
post(wpt_csp_reporting_collect),
)
.route(
"/wpt/runtime/csp/reporting/take",
get(wpt_csp_reporting_take),
)
.route(
"/wpt/runtime/worker/module-json-mime/config.data",
get(wpt_worker_module_json_mime_config),
)
.route(
"/wpt/runtime/worker/module-json-mime/json-with-charset.data",
get(wpt_worker_module_json_mime_with_charset),
)
.route(
"/wpt/runtime/worker/module-json-mime/javascript.json",
get(wpt_worker_module_json_mime_javascript),
)
.route(
"/wpt/runtime/worker/module-json-mime/plain-json.json",
get(wpt_worker_module_json_mime_plain_json),
)
.route(
"/wpt/runtime/worker/importscripts/cross-origin-target.js",
get(wpt_worker_importscripts_cross_origin_target),
)
.route(
"/wpt/runtime/worker/importscripts/redirect-to-cross-origin.js",
get(wpt_worker_importscripts_redirect_to_cross_origin),
)
.route(
"/wpt/runtime/worker/importscripts/args-worker.js",
get(wpt_worker_importscripts_args_worker),
)
.route(
"/wpt/runtime/worker/importscripts/undefined",
get(wpt_worker_importscripts_undefined),
)
.route(
"/wpt/runtime/worker/importscripts/null",
get(wpt_worker_importscripts_null),
)
.route(
"/wpt/runtime/worker/importscripts/1",
get(wpt_worker_importscripts_one),
)
.route("/wpt/runtime/worker/slow.js", get(wpt_worker_slow_script))
.route(
"/wpt/runtime/location/port-config.js",
get(wpt_location_port_config),
)
.route(
"/wpt/runtime/fixture-server-config.js",
get(wpt_fixture_server_config),
)
.route(
"/wpt/runtime/fetch/credentials/request-cookie/set",
get(wpt_fetch_credentials_request_cookie_set),
)
.route("/wpt/runtime/fetch/echo-body-hex", post(wpt_echo_body_hex))
.route(
"/wpt/runtime/fetch/binary-response",
get(wpt_fetch_binary_response),
)
.route(
"/wpt/runtime/fetch/credentials/request-cookie/check",
get(wpt_fetch_credentials_request_cookie_check),
)
.route(
"/wpt/runtime/fetch/credentials/default-response-cookie/set",
get(wpt_fetch_credentials_default_response_cookie_set),
)
.route(
"/wpt/runtime/fetch/credentials/default-response-cookie/check",
get(wpt_fetch_credentials_default_response_cookie_check),
)
.route(
"/wpt/runtime/fetch/credentials/include-response-cookie/set",
get(wpt_fetch_credentials_include_response_cookie_set),
)
.route(
"/wpt/runtime/fetch/credentials/include-response-cookie/check",
get(wpt_fetch_credentials_include_response_cookie_check),
)
.route(
"/wpt/runtime/fetch/credentials/omit-response-cookie/set",
get(wpt_fetch_credentials_omit_response_cookie_set),
)
.route(
"/wpt/runtime/fetch/credentials/omit-response-cookie/check",
get(wpt_fetch_credentials_omit_response_cookie_check),
)
.route(
"/wpt/runtime/fetch/credentials/streaming/{mode}/set",
get(wpt_fetch_credentials_streaming_response_cookie_set),
)
.route(
"/wpt/runtime/fetch/credentials/streaming/{mode}/check",
get(wpt_fetch_credentials_streaming_response_cookie_check),
)
.route(
"/wpt/runtime/xhr/credentials/request-cookie/set",
get(wpt_xhr_credentials_request_cookie_set),
)
.route(
"/wpt/runtime/xhr/credentials/request-cookie/check",
get(wpt_xhr_credentials_request_cookie_check),
)
.route(
"/wpt/runtime/xhr/credentials/default-response-cookie/set",
get(wpt_xhr_credentials_default_response_cookie_set),
)
.route(
"/wpt/runtime/xhr/credentials/default-response-cookie/check",
get(wpt_xhr_credentials_default_response_cookie_check),
)
.route(
"/wpt/runtime/xhr/credentials/include-response-cookie/set",
get(wpt_xhr_credentials_include_response_cookie_set),
)
.route(
"/wpt/runtime/xhr/credentials/include-response-cookie/check",
get(wpt_xhr_credentials_include_response_cookie_check),
)
.route("/common/redirect.py", get(wpt_common_redirect))
.route(
"/service-workers/service-worker/resources/redirect.py",
get(wpt_service_worker_redirect),
)
.route("/common/blank.html", get(wpt_common_blank_html))
.route("/common/{*path}", get(wpt_root_common_asset))
.route("/resources/{*path}", get(wpt_root_resources_asset))
.route("/webmcp/{*path}", get(wpt_root_webmcp_asset))
.route("/workers/{*path}", get(wpt_root_workers_asset))
.route("/wpt/{*path}", get(wpt_fixture_asset))
.with_state(runtime_state)
}
fn wpt_fixture_url(addr: std::net::SocketAddr, local_path: &str) -> String {
wpt_fixture_url_for_origin(addr, local_path, WptManifestOrigin::Trusted)
}
fn wpt_fixture_url_for_origin(
addr: std::net::SocketAddr,
local_path: &str,
origin: WptManifestOrigin,
) -> String {
let host = match origin {
WptManifestOrigin::Trusted => WPT_BROWSER_HOST,
WptManifestOrigin::Insecure => WPT_INSECURE_HOST,
};
format!(
"http://{}:{}/wpt/{}",
host,
addr.port(),
local_path.trim_start_matches('/')
)
}
fn wpt_case_url(
addr: std::net::SocketAddr,
local_path: &str,
global: &str,
query: &str,
origin: WptManifestOrigin,
) -> String {
let mut url = wpt_fixture_url_for_origin(addr, local_path, origin);
append_raw_query(&mut url, query);
if global == "worker" {
append_raw_query(&mut url, &format!("{WPT_WORKER_WRAPPER_QUERY}=1"));
url
} else if global == "sharedworker" {
append_raw_query(&mut url, &format!("{WPT_SHARED_WORKER_WRAPPER_QUERY}=1"));
url
} else if wpt_fixture_uses_window_wrapper(local_path) {
append_raw_query(&mut url, &format!("{WPT_WINDOW_WRAPPER_QUERY}=1"));
url
} else {
url
}
}
fn append_raw_query(url: &mut String, raw_query: &str) {
let raw_query = raw_query.trim().trim_start_matches('?');
if raw_query.is_empty() {
return;
}
if url.contains('?') {
url.push('&');
} else {
url.push('?');
}
url.push_str(raw_query);
}
impl Drop for WptFixtureServer {
fn drop(&mut self) {
while let Some(shutdown_tx) = self.shutdown_txs.pop() {
let _ = shutdown_tx.send(());
}
while let Some(task) = self.tasks.pop() {
task.abort();
}
}
}
async fn wpt_fixture_asset(
Path(path): Path<String>,
Query(query): Query<HashMap<String, String>>,
State(runtime_state): State<WptFixtureRuntimeState>,
) -> Response {
wpt_fixture_asset_response(&path, query, &runtime_state).await
}
async fn wpt_root_resources_asset(
Path(path): Path<String>,
Query(query): Query<HashMap<String, String>>,
State(runtime_state): State<WptFixtureRuntimeState>,
) -> Response {
wpt_fixture_asset_response(&format!("resources/{path}"), query, &runtime_state).await
}
async fn wpt_root_common_asset(
Path(path): Path<String>,
Query(query): Query<HashMap<String, String>>,
State(runtime_state): State<WptFixtureRuntimeState>,
) -> Response {
wpt_fixture_asset_response(&format!("upstream/common/{path}"), query, &runtime_state).await
}
async fn wpt_root_webmcp_asset(
Path(path): Path<String>,
Query(query): Query<HashMap<String, String>>,
State(runtime_state): State<WptFixtureRuntimeState>,
) -> Response {
wpt_fixture_asset_response(&format!("upstream/webmcp/{path}"), query, &runtime_state).await
}
async fn wpt_root_workers_asset(
Path(path): Path<String>,
Query(query): Query<HashMap<String, String>>,
State(runtime_state): State<WptFixtureRuntimeState>,
) -> Response {
wpt_fixture_asset_response(&format!("upstream/workers/{path}"), query, &runtime_state).await
}
async fn wpt_common_redirect(Query(query): Query<HashMap<String, String>>) -> Response {
match query.get("location") {
Some(location) => Redirect::temporary(location).into_response(),
None => (StatusCode::BAD_REQUEST, "missing redirect location").into_response(),
}
}
async fn wpt_service_worker_redirect(Query(query): Query<HashMap<String, String>>) -> Response {
wpt_service_worker_redirect_response(&query)
}
fn wpt_service_worker_redirect_response(query: &HashMap<String, String>) -> Response {
let Some(location) = query.get("Redirect") else {
return (StatusCode::BAD_REQUEST, "missing redirect target").into_response();
};
let status = match query.get("Status") {
Some(raw_status) => match raw_status
.parse::<u16>()
.ok()
.and_then(|status| StatusCode::from_u16(status).ok())
{
Some(status) => status,
None => return (StatusCode::BAD_REQUEST, "invalid redirect status").into_response(),
},
None => StatusCode::FOUND,
};
let Ok(location) = HeaderValue::from_str(location) else {
return (StatusCode::BAD_REQUEST, "invalid redirect target").into_response();
};
let mut response = Body::empty().into_response();
*response.status_mut() = status;
response.headers_mut().insert(LOCATION, location);
if let Some(value) = query.get("ACAOrigin") {
for item in value.split(',') {
if let Ok(header_value) = HeaderValue::from_str(item) {
response
.headers_mut()
.append(ACCESS_CONTROL_ALLOW_ORIGIN, header_value);
}
}
}
if let Some(value) = query.get("ACAHeaders")
&& let Ok(header_value) = HeaderValue::from_str(value)
{
response
.headers_mut()
.insert(ACCESS_CONTROL_ALLOW_HEADERS, header_value);
}
if let Some(value) = query.get("ACAMethods")
&& let Ok(header_value) = HeaderValue::from_str(value)
{
response
.headers_mut()
.insert(ACCESS_CONTROL_ALLOW_METHODS, header_value);
}
if let Some(value) = query.get("ACACredentials")
&& let Ok(header_value) = HeaderValue::from_str(value)
{
response
.headers_mut()
.insert(ACCESS_CONTROL_ALLOW_CREDENTIALS, header_value);
}
if let Some(value) = query.get("ACEHeaders")
&& let Ok(header_value) = HeaderValue::from_str(value)
{
response
.headers_mut()
.insert(ACCESS_CONTROL_EXPOSE_HEADERS, header_value);
}
response
}
async fn wpt_common_blank_html() -> Response {
html_response("<!doctype html><title></title>".to_owned())
}
fn wpt_worker_location_helper_redirect() -> Response {
Redirect::temporary("post-location-members.js?a").into_response()
}
fn wpt_worker_module_resource_redirect(query: &HashMap<String, String>) -> Response {
let Some(location) = query.get("location") else {
return (StatusCode::BAD_REQUEST, "missing redirect location").into_response();
};
Redirect::temporary(location).into_response()
}
fn wpt_worker_module_export_on_load_script() -> Response {
let mut response = static_text_response(
"export const importedModules = ['export-on-load-script.js'];".to_owned(),
"text/javascript",
);
response
.headers_mut()
.insert(ACCESS_CONTROL_ALLOW_ORIGIN, HeaderValue::from_static("*"));
response.headers_mut().insert(
ACCESS_CONTROL_ALLOW_HEADERS,
HeaderValue::from_static("Service-Worker"),
);
response
}
fn wpt_worker_baseurl_redirect(fixture_path: &str) -> Option<Response> {
let location = match fixture_path {
"upstream/workers/baseurl/beta/import.py" => "../gamma/import.js",
"upstream/workers/baseurl/beta/importScripts.py" => "../gamma/importScripts.js",
"upstream/workers/baseurl/beta/sharedworker.py" => "../gamma/sharedworker.js",
"upstream/workers/baseurl/beta/worker.py" => "../gamma/worker.js",
"upstream/workers/baseurl/beta/xhr.py" => "../gamma/xhr.js",
"upstream/workers/baseurl/beta/xhr-worker.py" => "../gamma/xhr-worker.js",
"ported/sharedworker/resources/runtime-url/beta/importscripts.py" => {
"../gamma/importscripts.js"
}
"ported/sharedworker/resources/runtime-url/beta/xhr-worker.py" => "../gamma/xhr-worker.js",
_ => return None,
};
Some(Redirect::temporary(location).into_response())
}
async fn wpt_fixture_asset_response(
path: &str,
query: HashMap<String, String>,
runtime_state: &WptFixtureRuntimeState,
) -> Response {
let normalized_path = path
.split('/')
.filter(|segment| !segment.is_empty())
.collect::<Vec<_>>()
.join("/");
let source_path = wpt_worker_entry_source_path(&normalized_path);
let is_worker_entry_request =
source_path.is_some() || query.contains_key(WPT_WORKER_ENTRY_QUERY);
let fixture_path = source_path.as_deref().unwrap_or(&normalized_path);
let Some(fs_path) = sanitize_wpt_fixture_path(fixture_path) else {
return (StatusCode::BAD_REQUEST, "invalid wpt fixture path").into_response();
};
if fixture_path == "upstream/workers/support/nosiniff-error-worker.py" {
return wpt_worker_nosniff_error_response();
}
if fixture_path == "upstream/workers/support/imported_script.py" {
return wpt_worker_imported_script_response(&query);
}
if fixture_path == "upstream/workers/interfaces/WorkerGlobalScope/location/helper-redirect.py" {
return wpt_worker_location_helper_redirect();
}
if fixture_path == "upstream/workers/modules/resources/redirect.py" {
return wpt_worker_module_resource_redirect(&query);
}
if fixture_path == "upstream/workers/modules/resources/export-on-load-script.py" {
return wpt_worker_module_export_on_load_script();
}
if let Some(response) = wpt_worker_baseurl_redirect(fixture_path) {
return response;
}
if is_worker_entry_request {
if !wpt_fixture_uses_worker_wrapper(fixture_path) {
return (
StatusCode::BAD_REQUEST,
"wpt worker entry wrapper only supports .any.js, .worker.js, and .sharedworker.js fixtures",
)
.into_response();
}
return match tokio::fs::read_to_string(&fs_path).await {
Ok(source) => {
let source = apply_wpt_substitutions(fixture_path, source, runtime_state, &query);
javascript_response(wpt_worker_entry_script(fixture_path, &source, &query))
}
Err(error) if error.kind() == std::io::ErrorKind::NotFound => {
(StatusCode::NOT_FOUND, "wpt fixture not found").into_response()
}
Err(_) => (
StatusCode::INTERNAL_SERVER_ERROR,
"failed to read wpt fixture",
)
.into_response(),
};
}
if query.contains_key(WPT_WINDOW_WRAPPER_QUERY) {
if !wpt_fixture_uses_window_wrapper(&normalized_path) {
return (
StatusCode::BAD_REQUEST,
"wpt window wrapper only supports .any.js and .window.js fixtures",
)
.into_response();
}
return match tokio::fs::read_to_string(&fs_path).await {
Ok(source) => {
let source = apply_wpt_substitutions(fixture_path, source, runtime_state, &query);
html_response(wpt_window_wrapper_html(&normalized_path, &source, &query))
}
Err(error) if error.kind() == std::io::ErrorKind::NotFound => {
(StatusCode::NOT_FOUND, "wpt fixture not found").into_response()
}
Err(_) => (
StatusCode::INTERNAL_SERVER_ERROR,
"failed to read wpt fixture",
)
.into_response(),
};
}
if query.contains_key(WPT_WORKER_WRAPPER_QUERY) {
if !wpt_fixture_uses_worker_wrapper(&normalized_path) {
return (
StatusCode::BAD_REQUEST,
"wpt worker wrapper only supports .any.js, .worker.js, and .sharedworker.js fixtures",
)
.into_response();
}
return match tokio::fs::read_to_string(&fs_path).await {
Ok(source) => {
let source = apply_wpt_substitutions(fixture_path, source, runtime_state, &query);
html_response(wpt_worker_wrapper_html(&normalized_path, &source, &query))
}
Err(error) if error.kind() == std::io::ErrorKind::NotFound => {
(StatusCode::NOT_FOUND, "wpt fixture not found").into_response()
}
Err(_) => (
StatusCode::INTERNAL_SERVER_ERROR,
"failed to read wpt fixture",
)
.into_response(),
};
}
if query.contains_key(WPT_SHARED_WORKER_WRAPPER_QUERY) {
if !wpt_fixture_uses_worker_wrapper(&normalized_path) {
return (
StatusCode::BAD_REQUEST,
"wpt shared worker wrapper only supports .any.js, .worker.js, and .sharedworker.js fixtures",
)
.into_response();
}
return match tokio::fs::read_to_string(&fs_path).await {
Ok(source) => {
let source = apply_wpt_substitutions(fixture_path, source, runtime_state, &query);
html_response(wpt_shared_worker_wrapper_html(
&normalized_path,
&source,
&query,
))
}
Err(error) if error.kind() == std::io::ErrorKind::NotFound => {
(StatusCode::NOT_FOUND, "wpt fixture not found").into_response()
}
Err(_) => (
StatusCode::INTERNAL_SERVER_ERROR,
"failed to read wpt fixture",
)
.into_response(),
};
}
let Some(content_type) = wpt_fixture_content_type(&fs_path, fixture_path) else {
return (
StatusCode::UNSUPPORTED_MEDIA_TYPE,
"unsupported wpt fixture type",
)
.into_response();
};
match read_static_wpt_fixture_body(&fs_path, fixture_path, content_type, runtime_state, &query)
.await
{
Ok(response) => response,
Err(error) if error.kind() == std::io::ErrorKind::NotFound => {
(StatusCode::NOT_FOUND, "wpt fixture not found").into_response()
}
Err(_) => (
StatusCode::INTERNAL_SERVER_ERROR,
"failed to read wpt fixture",
)
.into_response(),
}
}
async fn read_static_wpt_fixture_body(
fs_path: &StdPath,
fixture_path: &str,
content_type: &'static str,
runtime_state: &WptFixtureRuntimeState,
query: &HashMap<String, String>,
) -> std::io::Result<Response> {
if wpt_fixture_needs_text_processing(fixture_path, content_type) {
let source = tokio::fs::read_to_string(fs_path).await?;
let source = apply_wpt_substitutions(fixture_path, source, runtime_state, query);
let source = if query.contains_key("moli-wpt-crashtest") {
wpt_crashtest_wrapper_html(source)
} else {
source
};
let mut response = static_text_response(
adapt_upstream_html_fixture(fixture_path, source),
content_type,
);
apply_wpt_headers_sidecar(&mut response, fs_path).await?;
apply_wpt_pipe_headers(&mut response, query);
return Ok(response);
}
let bytes = tokio::fs::read(fs_path).await?;
let mut response = static_bytes_response(bytes, content_type);
apply_wpt_headers_sidecar(&mut response, fs_path).await?;
apply_wpt_pipe_headers(&mut response, query);
Ok(response)
}
async fn apply_wpt_headers_sidecar(response: &mut Response, fs_path: &StdPath) -> io::Result<()> {
let sidecar_path = PathBuf::from(format!("{}.headers", fs_path.display()));
let source = match tokio::fs::read_to_string(&sidecar_path).await {
Ok(source) => source,
Err(error) if error.kind() == io::ErrorKind::NotFound => return Ok(()),
Err(error) => return Err(error),
};
for (index, line) in source.lines().enumerate() {
let line = line.trim();
if line.is_empty() || line.starts_with('#') {
continue;
}
let Some((name, value)) = line.split_once(':') else {
return Err(io::Error::new(
io::ErrorKind::InvalidData,
format!(
"invalid WPT .headers line {} in {}",
index + 1,
sidecar_path.display()
),
));
};
let name = HeaderName::from_bytes(name.trim().as_bytes()).map_err(|error| {
io::Error::new(
io::ErrorKind::InvalidData,
format!(
"invalid WPT .headers name on line {} in {}: {error}",
index + 1,
sidecar_path.display()
),
)
})?;
let value = HeaderValue::from_str(value.trim()).map_err(|error| {
io::Error::new(
io::ErrorKind::InvalidData,
format!(
"invalid WPT .headers value on line {} in {}: {error}",
index + 1,
sidecar_path.display()
),
)
})?;
response.headers_mut().append(name, value);
}
Ok(())
}
fn apply_wpt_pipe_headers(response: &mut Response, query: &HashMap<String, String>) {
let Some(pipe) = query.get("pipe") else {
return;
};
for command in pipe.split('|') {
let command = command.trim();
let Some(inner) = command
.strip_prefix("header(")
.and_then(|value| value.strip_suffix(')'))
else {
continue;
};
let Some((name, value)) = inner.split_once(',') else {
continue;
};
let Ok(name) = HeaderName::from_bytes(name.trim().as_bytes()) else {
continue;
};
let Ok(value) = HeaderValue::from_str(value.trim()) else {
continue;
};
response.headers_mut().append(name, value);
}
}
fn wpt_fixture_needs_text_processing(fixture_path: &str, content_type: &str) -> bool {
content_type.starts_with("text/html") || wpt_fixture_uses_substitution(fixture_path)
}
fn wpt_worker_entry_source_path(path: &str) -> Option<String> {
let path = path.trim_start_matches('/');
if let Some(source) = path.strip_suffix(".any.worker.js") {
return Some(format!("{source}.any.js"));
}
if let Some(source) = path.strip_suffix(".any.sharedworker.js") {
return Some(format!("{source}.any.js"));
}
None
}
fn sanitize_wpt_fixture_path(path: &str) -> Option<PathBuf> {
let mut fs_path = PathBuf::from(wpt_fixture_root());
let candidate = StdPath::new(path);
let mut saw_top_level_dir = false;
for component in candidate.components() {
match component {
Component::Normal(segment) => {
if !saw_top_level_dir {
let segment = segment.to_str()?;
if !WPT_STATIC_FIXTURE_TOP_LEVEL_DIRS.contains(&segment) {
return None;
}
saw_top_level_dir = true;
}
fs_path.push(segment);
}
Component::CurDir => {}
Component::ParentDir | Component::RootDir | Component::Prefix(_) => return None,
}
}
if !saw_top_level_dir {
return None;
}
Some(fs_path)
}
fn wpt_fixture_root() -> &'static StdPath {
static ROOT: OnceLock<PathBuf> = OnceLock::new();
ROOT.get_or_init(|| {
std::env::current_dir()
.ok()
.as_deref()
.and_then(wpt_fixture_root_in_checkout)
.unwrap_or_else(|| PathBuf::from(COMPILED_WPT_FIXTURE_ROOT))
})
.as_path()
}
fn wpt_fixture_root_in_checkout(start: &StdPath) -> Option<PathBuf> {
for ancestor in start.ancestors() {
for relative in [
StdPath::new("moli-wpt-compat/fixtures/wpt"),
StdPath::new("fixtures/wpt"),
] {
let candidate = ancestor.join(relative);
if candidate.join("manifest.toml").is_file()
&& candidate.join("expected.toml").is_file()
{
return Some(candidate);
}
}
}
None
}
fn wpt_fixture_uses_window_wrapper(path: &str) -> bool {
let path = path.trim_start_matches('/');
path.ends_with(".any.js") || path.ends_with(".window.js")
}
fn wpt_fixture_uses_worker_wrapper(path: &str) -> bool {
let path = path.trim_start_matches('/');
path.ends_with(".any.js") || path.ends_with(".worker.js") || path.ends_with(".sharedworker.js")
}
fn wpt_fixture_uses_substitution(path: &str) -> bool {
StdPath::new(path)
.file_name()
.and_then(|name| name.to_str())
.is_some_and(|file_name| file_name.contains(".sub."))
}
fn wpt_fixture_content_type(path: &StdPath, fixture_path: &str) -> Option<&'static str> {
if fixture_path == "upstream/workers/worker-url-encoding.html" {
return Some("text/html");
}
match path.extension().and_then(|ext| ext.to_str()) {
Some("css") => Some("text/css; charset=utf-8"),
Some("htm") => Some("text/html; charset=utf-8"),
Some("html") => Some("text/html; charset=utf-8"),
Some("js") => Some("application/javascript"),
Some("json") => Some("application/json"),
Some("txt") => Some("text/plain; charset=utf-8"),
Some("xml") => Some("application/xml"),
None if wpt_extensionless_worker_script(path) => Some("application/javascript"),
_ => None,
}
}
fn wpt_extensionless_worker_script(path: &StdPath) -> bool {
let Some(file_name) = path.file_name().and_then(|name| name.to_str()) else {
return false;
};
if !matches!(file_name, "1" | "Infinity" | "NaN" | "null" | "undefined") {
return false;
}
let components = path
.components()
.map(|component| component.as_os_str().to_string_lossy().into_owned())
.collect::<Vec<_>>();
components.windows(4).any(|window| {
window[0] == "workers"
&& window[1] == "constructors"
&& window[2] == "Worker"
&& window[3] == file_name
}) || components.windows(4).any(|window| {
window[0] == "workers"
&& window[1] == "constructors"
&& window[2] == "SharedWorker"
&& window[3] == file_name
}) || components.windows(5).any(|window| {
window[0] == "workers"
&& window[1] == "interfaces"
&& window[2] == "WorkerUtils"
&& window[3] == "importScripts"
&& window[4] == file_name
})
}
fn apply_wpt_substitutions(
path: &str,
source: String,
runtime_state: &WptFixtureRuntimeState,
query: &HashMap<String, String>,
) -> String {
if !wpt_fixture_uses_substitution(path) {
return source;
}
let mut output = String::with_capacity(source.len());
let mut rest = source.as_str();
while let Some(start) = rest.find("{{") {
output.push_str(&rest[..start]);
let after_start = &rest[start + 2..];
let Some(end) = after_start.find("}}") else {
output.push_str(&rest[start..]);
return output;
};
let raw_token = &after_start[..end];
if let Some(value) = wpt_substitution_value(raw_token.trim(), path, runtime_state, query) {
output.push_str(&value);
} else {
output.push_str("{{");
output.push_str(raw_token);
output.push_str("}}");
}
rest = &after_start[end + 2..];
}
output.push_str(rest);
output
}
fn wpt_substitution_value(
token: &str,
path: &str,
runtime_state: &WptFixtureRuntimeState,
query: &HashMap<String, String>,
) -> Option<String> {
let primary_port = runtime_state.primary_addr.port().to_string();
let secondary_port = runtime_state.secondary_addr.port().to_string();
let primary_https_port = runtime_state.primary_https_addr.port().to_string();
let secondary_https_port = runtime_state.secondary_https_addr.port().to_string();
match token {
"host" | "browser_host" => Some(WPT_BROWSER_HOST.to_owned()),
"location[scheme]" => Some("http".to_owned()),
"location[host]" => Some(wpt_fixture_host_port(runtime_state)),
"location[hostname]" => Some(WPT_BROWSER_HOST.to_owned()),
"location[origin]" | "location[server]" => {
Some(format!("http://{}", wpt_fixture_host_port(runtime_state)))
}
"location[path]" => Some(format!("/wpt/{}", path.trim_start_matches('/'))),
"location[port]" => Some(primary_port),
"location[query]" => Some(String::new()),
"ports[http][0]" => Some(primary_port),
"ports[http][1]" => Some(secondary_port),
"ports[https][0]" => Some(primary_https_port),
"ports[https][1]" => Some(secondary_https_port),
_ if token.starts_with("GET[") && token.ends_with(']') => token
.strip_prefix("GET[")
.and_then(|name| name.strip_suffix(']'))
.map(|name| query.get(name).cloned().unwrap_or_default()),
_ if token.starts_with("domains[") || token.starts_with("hosts[") => {
if token.contains("nonexistent") {
Some(format!("nonexistent.{WPT_BROWSER_HOST}"))
} else if token.contains("alt") && token.contains("www2") {
Some("localhost.".to_owned())
} else if token.contains("www1") || token.contains("alt") {
Some(WPT_REMOTE_HOST.to_owned())
} else {
Some(WPT_BROWSER_HOST.to_owned())
}
}
_ => None,
}
}
fn wpt_fixture_host_port(runtime_state: &WptFixtureRuntimeState) -> String {
format!("{}:{}", WPT_BROWSER_HOST, runtime_state.primary_addr.port())
}
// Chromium's load-driven crashtests have no testharness report. Keep their
// source intact and observe completion of the load handler and a subsequent
// browser task, so queued cancellation/navigation work runs before teardown.
fn wpt_crashtest_wrapper_html(mut source: String) -> String {
let scripts = r#"<script src="/resources/testharness.js"></script><script src="/resources/testharnessreport.js"></script><script src="/wpt/resources/moli-wpt-adapter.js"></script>"#;
let insertion = source.find("<script").unwrap_or(source.len());
source.insert_str(insertion, scripts);
source.push_str(
r#"<script>
const crashTest = async_test('Load handler and renderer remain live');
const crashLoad = window.onload;
window.onload = event => {
Promise.resolve().then(() => typeof crashLoad === 'function' ? crashLoad.call(window, event) : undefined).then(() => {
const checkpoint = new MessageChannel();
checkpoint.port1.onmessage = crashTest.step_func_done(() => {
checkpoint.port1.close(); checkpoint.port2.close();
});
checkpoint.port2.postMessage(null);
}, crashTest.step_func(error => { throw error; }));
};
</script>"#,
);
source
}
fn adapt_upstream_html_fixture(path: &str, source: String) -> String {
if !path.starts_with("upstream/") || !(path.ends_with(".html") || path.ends_with(".htm")) {
return source;
}
if source.contains("moli-wpt-adapter.js") {
return source;
}
for marker in [
r#"<script src="/resources/testharnessreport.js"></script>"#,
r#"<script src='/resources/testharnessreport.js'></script>"#,
r#"<script src=/resources/testharnessreport.js></script>"#,
] {
if source.contains(marker) {
return source.replace(
marker,
&format!(r#"{marker}<script src="/wpt/resources/moli-wpt-adapter.js"></script>"#),
);
}
}
source
}
fn wpt_window_wrapper_html(
script_path: &str,
script_source: &str,
query: &HashMap<String, String>,
) -> String {
let script_src =
html_escape_double_quoted_attribute(&wpt_public_script_url_with_query(script_path, query));
let meta_scripts = wpt_window_wrapper_meta_script_tags(script_path, script_source);
format!(
"<!doctype html><meta charset=\"utf-8\"><script src=\"/wpt/resources/testharness.js\"></script><script src=\"/wpt/resources/testharnessreport.js\"></script><script src=\"/wpt/resources/moli-wpt-adapter.js\"></script><body><div id=\"log\"></div>{meta_scripts}<script src=\"{script_src}\"></script>"
)
}
fn wpt_worker_wrapper_html(
script_path: &str,
_script_source: &str,
query: &HashMap<String, String>,
) -> String {
let script_src =
html_escape_double_quoted_attribute(&wpt_worker_entry_public_url(script_path, query));
format!(
"<!doctype html><meta charset=\"utf-8\"><script src=\"/wpt/resources/testharness.js\"></script><script src=\"/wpt/resources/testharnessreport.js\"></script><script src=\"/wpt/resources/moli-wpt-adapter.js\"></script><body><div id=\"log\"></div><script>fetch_tests_from_worker(new Worker(\"{script_src}\"));</script>"
)
}
fn wpt_shared_worker_wrapper_html(
script_path: &str,
_script_source: &str,
query: &HashMap<String, String>,
) -> String {
let script_src = html_escape_double_quoted_attribute(&wpt_shared_worker_entry_public_url(
script_path,
query,
));
format!(
"<!doctype html><meta charset=\"utf-8\"><script src=\"/wpt/resources/testharness.js\"></script><script src=\"/wpt/resources/testharnessreport.js\"></script><script src=\"/wpt/resources/moli-wpt-adapter.js\"></script><body><div id=\"log\"></div><script>fetch_tests_from_worker(new SharedWorker(\"{script_src}\"));</script>"
)
}
fn wpt_worker_entry_public_url(script_path: &str, query: &HashMap<String, String>) -> String {
let path = script_path.trim_start_matches('/');
let mut url = if let Some(worker_path) = path.strip_prefix("upstream/workers/")
&& let Some(stem) = worker_path.strip_suffix(".any.js")
{
format!("/workers/{stem}.any.worker.js")
} else if let Some(worker_path) = path.strip_prefix("upstream/workers/")
&& path.ends_with(".worker.js")
{
format!("/workers/{worker_path}")
} else {
format!("/wpt/{path}?{WPT_WORKER_ENTRY_QUERY}=1")
};
append_forwarded_wpt_query(&mut url, query);
url
}
fn wpt_shared_worker_entry_public_url(
script_path: &str,
query: &HashMap<String, String>,
) -> String {
let path = script_path.trim_start_matches('/');
let mut url = if let Some(worker_path) = path.strip_prefix("upstream/workers/")
&& let Some(stem) = worker_path.strip_suffix(".any.js")
{
format!("/workers/{stem}.any.worker.js")
} else {
format!("/wpt/{path}?{WPT_WORKER_ENTRY_QUERY}=1")
};
append_forwarded_wpt_query(&mut url, query);
url
}
fn wpt_worker_entry_script(
script_path: &str,
script_source: &str,
query: &HashMap<String, String>,
) -> String {
let mut body = String::new();
if !script_path.ends_with(".worker.js") {
body.push_str("importScripts(\"/resources/testharness.js\");\n");
}
for reference in extract_wpt_meta_script_references(script_source) {
if is_local_wpt_harness_meta_script(&reference) {
let script_src = js_string_literal(&reference);
body.push_str(&format!("importScripts({script_src});\n"));
continue;
}
let Ok(Some(resolved)) =
resolve_wpt_static_resource_reference(script_path, &reference, "upstream")
else {
continue;
};
let script_src = js_string_literal(&wpt_public_script_url(&resolved.path_with_suffix()));
body.push_str(&format!("importScripts({script_src});\n"));
}
let entry_src = js_string_literal(&wpt_public_script_url_with_query(script_path, query));
body.push_str(&format!("importScripts({entry_src});\n"));
body
}
fn wpt_public_script_url(path: &str) -> String {
let path = path.trim_start_matches('/');
if let Some(worker_path) = path.strip_prefix("upstream/workers/") {
format!("/workers/{worker_path}")
} else {
format!("/wpt/{path}")
}
}
fn wpt_public_script_url_with_query(path: &str, query: &HashMap<String, String>) -> String {
let mut url = wpt_public_script_url(path);
append_forwarded_wpt_query(&mut url, query);
url
}
fn append_forwarded_wpt_query(url: &mut String, query: &HashMap<String, String>) {
let mut keys = query
.keys()
.filter(|key| should_forward_wpt_query_param(key))
.collect::<Vec<_>>();
keys.sort();
for key in keys {
let Some(value) = query.get(key) else {
continue;
};
if is_wpt_subset_variant_query_param(key) {
append_raw_query(url, key);
continue;
}
append_raw_query(url, &format!("{key}={value}"));
}
}
fn should_forward_wpt_query_param(key: &str) -> bool {
!matches!(
key,
WPT_WINDOW_WRAPPER_QUERY
| WPT_WORKER_WRAPPER_QUERY
| WPT_SHARED_WORKER_WRAPPER_QUERY
| WPT_WORKER_ENTRY_QUERY
)
}
fn is_wpt_subset_variant_query_param(key: &str) -> bool {
let Some((start, end)) = key.split_once('-') else {
return false;
};
!start.is_empty()
&& start.bytes().all(|byte| byte.is_ascii_digit())
&& (end == "last" || (!end.is_empty() && end.bytes().all(|byte| byte.is_ascii_digit())))
}
fn wpt_window_wrapper_meta_script_tags(script_path: &str, script_source: &str) -> String {
let mut tags = String::new();
for reference in extract_wpt_meta_script_references(script_source) {
if is_local_wpt_harness_meta_script(&reference) {
let script_src = html_escape_double_quoted_attribute(&reference);
tags.push_str(&format!("<script src=\"{script_src}\"></script>"));
continue;
}
let Ok(Some(resolved)) =
resolve_wpt_static_resource_reference(script_path, &reference, "upstream")
else {
continue;
};
let script_src =
html_escape_double_quoted_attribute(&format!("/wpt/{}", resolved.path_with_suffix()));
tags.push_str(&format!("<script src=\"{script_src}\"></script>"));
}
tags
}
fn is_local_wpt_harness_meta_script(reference: &str) -> bool {
matches!(
reference,
"/resources/WebIDLParser.js" | "/resources/idlharness.js"
)
}
fn static_text_response(source: String, content_type: &'static str) -> Response {
let mut response = source.into_response();
response
.headers_mut()
.insert(CONTENT_TYPE, HeaderValue::from_static(content_type));
response
}
fn static_bytes_response(source: Vec<u8>, content_type: &'static str) -> Response {
let mut response = Body::from(source).into_response();
response
.headers_mut()
.insert(CONTENT_TYPE, HeaderValue::from_static(content_type));
response
}
fn html_response(source: String) -> Response {
static_text_response(source, "text/html; charset=utf-8")
}
fn javascript_response(source: String) -> Response {
static_text_response(source, "application/javascript")
}
fn wpt_worker_imported_script_response(query: &HashMap<String, String>) -> Response {
let Some(mime) = query.get("mime") else {
return (StatusCode::BAD_REQUEST, "missing mime query").into_response();
};
let Ok(content_type) = HeaderValue::from_str(mime) else {
return (StatusCode::BAD_REQUEST, "invalid mime query").into_response();
};
let mut response = String::new().into_response();
response.headers_mut().insert(CONTENT_TYPE, content_type);
response
}
fn wpt_worker_nosniff_error_response() -> Response {
let mut response = static_text_response(String::new(), "text/html");
response.headers_mut().insert(
"x-content-type-options",
HeaderValue::from_static("nosniff"),
);
response
}
async fn wpt_cookie_http_set() -> Response {
response_with_set_cookie(
"http-cookie=set",
"wpt_http_cookie=fixture; Path=/wpt/runtime/cookies; HttpOnly; SameSite=Lax",
)
}
async fn wpt_location_port_config(
State(runtime_state): State<WptFixtureRuntimeState>,
headers: HeaderMap,
) -> Response {
port_config_response(runtime_state, headers, "__lmLocationPortConfig")
}
async fn wpt_fixture_server_config(
State(runtime_state): State<WptFixtureRuntimeState>,
headers: HeaderMap,
) -> Response {
port_config_response(runtime_state, headers, "__lmFixtureServerConfig")
}
fn port_config_response(
runtime_state: WptFixtureRuntimeState,
headers: HeaderMap,
global_name: &'static str,
) -> Response {
let current_port = host_header_port(&headers).unwrap_or(runtime_state.primary_addr.port());
let alternate_port = alternate_wpt_fixture_port(&runtime_state, Some(current_port));
let current_port = serde_json::to_string(¤t_port.to_string())
.expect("current WPT fixture port should serialize");
let alternate_port = serde_json::to_string(&alternate_port.to_string())
.expect("alternate WPT fixture port should serialize");
javascript_response(format!(
"globalThis.{global_name} = Object.assign(globalThis.{global_name} || {{}}, {{ currentPort: {current_port}, alternatePort: {alternate_port} }});"
))
}
async fn wpt_websocket_echo(ws: WebSocketUpgrade) -> Response {
ws.on_upgrade(|socket| async move {
handle_wpt_echo_websocket(socket).await;
})
}
async fn wpt_websocket_cookie_set() -> Response {
response_with_set_cookie(
"websocket-cookie=set",
"wpt_ws_cookie=handshake; Path=/wpt/runtime/websocket; HttpOnly; SameSite=Lax",
)
}
async fn wpt_websocket_cookie_echo(headers: HeaderMap, ws: WebSocketUpgrade) -> Response {
let cookie = headers
.get(COOKIE)
.and_then(|value| value.to_str().ok())
.unwrap_or_default()
.to_owned();
ws.on_upgrade(|mut socket| async move {
let _ = socket.send(WebSocketMessage::Text(cookie.into())).await;
let _ = socket
.send(WebSocketMessage::Close(Some(
axum::extract::ws::CloseFrame {
code: 1000,
reason: "cookie echoed".into(),
},
)))
.await;
})
}
async fn wpt_websocket_subprotocol(ws: WebSocketUpgrade) -> Response {
ws.protocols(["superchat"])
.on_upgrade(|mut socket| async move {
let _ = socket
.send(WebSocketMessage::Text("subprotocol-open".into()))
.await;
handle_wpt_echo_websocket(socket).await;
})
}
async fn handle_wpt_echo_websocket(mut socket: WebSocket) {
while let Some(Ok(message)) = socket.recv().await {
match message {
WebSocketMessage::Text(text) => {
let _ = socket.send(WebSocketMessage::Text(text)).await;
}
WebSocketMessage::Binary(bytes) => {
let _ = socket.send(WebSocketMessage::Binary(bytes)).await;
}
WebSocketMessage::Close(_frame) => {
// recv already queued the Close reply; flush before releasing TCP.
let _ = futures_util::SinkExt::flush(&mut socket).await;
break;
}
WebSocketMessage::Ping(payload) => {
let _ = socket.send(WebSocketMessage::Pong(payload)).await;
}
WebSocketMessage::Pong(_) => {}
}
}
}
async fn wpt_websocket_server_close(ws: WebSocketUpgrade) -> Response {
ws.on_upgrade(|mut socket| async move {
let _ = socket
.send(WebSocketMessage::Close(Some(
axum::extract::ws::CloseFrame {
code: 3001,
reason: "server done".into(),
},
)))
.await;
})
}
async fn wpt_websocket_slow_handshake(ws: WebSocketUpgrade) -> Response {
sleep(Duration::from_millis(250)).await;
ws.on_upgrade(|socket| async move {
handle_wpt_echo_websocket(socket).await;
})
}
async fn wpt_websocket_plain_200() -> Response {
text_response("not a websocket upgrade")
}
async fn wpt_websocket_response_cookie(ws: WebSocketUpgrade) -> Response {
let mut response = ws.on_upgrade(|mut socket| async move {
let _ = socket
.send(WebSocketMessage::Close(Some(
axum::extract::ws::CloseFrame {
code: 1000,
reason: "cookie stored".into(),
},
)))
.await;
});
response.headers_mut().append(
SET_COOKIE,
HeaderValue::from_static("ws_response_cookie=ok; Path=/; SameSite=Lax"),
);
response
}
fn host_header_port(headers: &HeaderMap) -> Option<u16> {
headers
.get(HOST)
.and_then(|value| value.to_str().ok())
.and_then(|host| host.rsplit_once(':').map(|(_, port)| port))
.and_then(|port| port.parse().ok())
}
fn alternate_wpt_fixture_port(
runtime_state: &WptFixtureRuntimeState,
current_port: Option<u16>,
) -> u16 {
match current_port {
Some(port) if port == runtime_state.primary_addr.port() => {
runtime_state.secondary_addr.port()
}
Some(port) if port == runtime_state.secondary_addr.port() => {
runtime_state.primary_addr.port()
}
_ => runtime_state.secondary_addr.port(),
}
}
async fn wpt_cookie_http_check(headers: HeaderMap) -> Response {
let body = if has_cookie(&headers, "wpt_http_cookie=fixture") {
"http-cookie=seen"
} else {
"http-cookie=missing"
};
text_response(body)
}
async fn wpt_cookie_path_scope_set() -> Response {
response_with_set_cookie(
"path-cookie=set",
"wpt_path_cookie=match; Path=/wpt/runtime/cookies/path-scope; HttpOnly; SameSite=Lax",
)
}
async fn wpt_cookie_path_scope_check(headers: HeaderMap) -> Response {
let body = if has_cookie(&headers, "wpt_path_cookie=match") {
"path-cookie=seen"
} else {
"path-cookie=missing"
};
text_response(body)
}
async fn wpt_cookie_path_scope_extra_check(headers: HeaderMap) -> Response {
let body = if has_cookie(&headers, "wpt_path_cookie=match") {
"path-cookie=seen"
} else {
"path-cookie=missing"
};
text_response(body)
}
async fn wpt_cookie_invalid_domain_set() -> Response {
response_with_set_cookie(
"invalid-domain=set",
"wpt_bad_domain=1; Domain=example.com; Path=/wpt/runtime/cookies; HttpOnly; SameSite=Lax",
)
}
async fn wpt_cookie_invalid_domain_check(headers: HeaderMap) -> Response {
let body = if has_cookie(&headers, "wpt_bad_domain=1") {
"invalid-domain=seen"
} else {
"invalid-domain=missing"
};
text_response(body)
}
async fn wpt_cookie_replace_red() -> Response {
response_with_set_cookie(
"replace-cookie=red",
"wpt_replace_cookie=red; Path=/wpt/runtime/cookies/replace; HttpOnly; SameSite=Lax",
)
}
async fn wpt_cookie_replace_blue() -> Response {
response_with_set_cookie(
"replace-cookie=blue",
"wpt_replace_cookie=blue; Path=/wpt/runtime/cookies/replace; HttpOnly; SameSite=Lax",
)
}
async fn wpt_cookie_replace_check(headers: HeaderMap) -> Response {
let body = if has_cookie(&headers, "wpt_replace_cookie=blue") {
"replace-cookie=blue"
} else if has_cookie(&headers, "wpt_replace_cookie=red") {
"replace-cookie=red"
} else {
"replace-cookie=missing"
};
text_response(body)
}
async fn wpt_cookie_samesite_set() -> Response {
let mut response = response_with_set_cookie(
"samesite-cookie=set",
"wpt_samesite_strict=ok; Path=/wpt/runtime/cookies/samesite; HttpOnly; SameSite=Strict",
);
response.headers_mut().append(
SET_COOKIE,
HeaderValue::from_static(
"wpt_samesite_lax=ok; Path=/wpt/runtime/cookies/samesite; HttpOnly; SameSite=Lax",
),
);
response
}
async fn wpt_cookie_samesite_check(headers: HeaderMap) -> Response {
let body = if has_cookie(&headers, "wpt_samesite_strict=ok")
&& has_cookie(&headers, "wpt_samesite_lax=ok")
{
"samesite-cookie=strict-lax"
} else {
"samesite-cookie=missing"
};
text_response(body)
}
async fn wpt_cookie_redirect_chain_start() -> Response {
redirect_with_cookies(
"/wpt/runtime/cookies/redirect-chain/middle",
&[
"wpt_chain=start; Path=/wpt/runtime/cookies/redirect-chain; HttpOnly; SameSite=Lax",
"wpt_common=one; Path=/wpt/runtime/cookies; HttpOnly; SameSite=Lax",
],
)
}
async fn wpt_cookie_redirect_chain_middle(headers: HeaderMap) -> Response {
if !has_cookie(&headers, "wpt_chain=start") || !has_cookie(&headers, "wpt_common=one") {
return text_response("cookie-chain=broken");
}
redirect_with_cookies(
"/wpt/runtime/cookies/redirect-chain/final",
&[
"wpt_common=two; Path=/wpt/runtime/cookies; HttpOnly; SameSite=Lax",
"wpt_middle=seen; Path=/wpt/runtime/cookies/redirect-chain; HttpOnly; SameSite=Lax",
],
)
}
async fn wpt_cookie_redirect_chain_final(headers: HeaderMap) -> Response {
let body = if has_cookie(&headers, "wpt_chain=start")
&& has_cookie(&headers, "wpt_common=two")
&& has_cookie(&headers, "wpt_middle=seen")
{
"cookie-chain=ok"
} else {
"cookie-chain=broken"
};
text_response(body)
}
async fn wpt_xhr_text() -> Response {
text_response(WPT_XHR_TEXT_BODY)
}
async fn wpt_xhr_html_text() -> Response {
html_response(format!(
"<!doctype html><html><body>{WPT_XHR_TEXT_BODY}</body></html>"
))
}
async fn wpt_xhr_json() -> Response {
json_response(WPT_XHR_JSON_BODY)
}
async fn wpt_xhr_binary() -> Response {
binary_response(&[0u8, 0, 1, 2, 0, 0, 9])
}
async fn wpt_xhr_redirect() -> Response {
Redirect::to("/wpt/runtime/xhr/text").into_response()
}
async fn wpt_xhr_404() -> Response {
(StatusCode::NOT_FOUND, "Not Found").into_response()
}
async fn wpt_xhr_500() -> Response {
(StatusCode::INTERNAL_SERVER_ERROR, "Internal Server Error").into_response()
}
async fn wpt_xhr_slow() -> Response {
sleep(Duration::from_millis(75)).await;
text_response(WPT_XHR_TEXT_BODY)
}
async fn wpt_xhr_very_slow() -> Response {
sleep(Duration::from_millis(250)).await;
text_response(WPT_XHR_TEXT_BODY)
}
async fn wpt_xhr_empty() -> Response {
text_response("")
}
async fn wpt_xhr_abort_observing(
State(runtime_state): State<WptFixtureRuntimeState>,
Path(token): Path<String>,
) -> Response {
abort_observing_response(Arc::clone(&runtime_state.abort_observations), token)
}
async fn wpt_xhr_abort_observing_status(
State(runtime_state): State<WptFixtureRuntimeState>,
Path(token): Path<String>,
) -> Response {
abort_observing_status_response(&runtime_state.abort_observations, &token)
}
async fn wpt_fetch_abort_observing(
State(runtime_state): State<WptFixtureRuntimeState>,
Path(token): Path<String>,
) -> Response {
abort_observing_response(Arc::clone(&runtime_state.abort_observations), token)
}
async fn wpt_fetch_abort_observing_status(
State(runtime_state): State<WptFixtureRuntimeState>,
Path(token): Path<String>,
) -> Response {
abort_observing_status_response(&runtime_state.abort_observations, &token)
}
fn abort_observing_response(
observations: Arc<AbortObservationRegistry>,
token: String,
) -> Response {
observations.mark_pending(&token);
let observed_token = token;
let (tx, rx) = mpsc::channel(2);
tokio::spawn(async move {
if tx
.send(Ok::<Bytes, std::convert::Infallible>(Bytes::from_static(
b"partial-",
)))
.await
.is_err()
{
observations.mark_complete(&observed_token, true);
return;
}
let disconnected = tokio::select! {
_ = tx.closed() => true,
result = async {
sleep(Duration::from_millis(1000)).await;
tx.send(Ok::<Bytes, std::convert::Infallible>(Bytes::from_static(
b"tail",
)))
.await
} => result.is_err(),
};
observations.mark_complete(&observed_token, disconnected);
});
Response::builder()
.header(CONTENT_TYPE, "text/plain; charset=utf-8")
.body(Body::from_stream(ReceiverStream::new(rx)))
.expect("xhr abort observer response should build")
}
fn abort_observing_status_response(
observations: &AbortObservationRegistry,
token: &str,
) -> Response {
let payload = match observations.lookup(token) {
Some(Some(disconnected)) => serde_json::json!({
"complete": true,
"disconnected": disconnected,
}),
Some(None) => serde_json::json!({
"complete": false,
"disconnected": serde_json::Value::Null,
}),
None => serde_json::json!({
"complete": false,
"missing": true,
}),
};
json_string_response(payload.to_string())
}
async fn wpt_xhr_request_headers(headers: HeaderMap) -> Response {
let payload = serde_json::json!({
"x_test": header_value(&headers, "x-test"),
"accept": header_value(&headers, "accept"),
"referer": header_value(&headers, "referer"),
"sec_fetch_site": header_value(&headers, "sec-fetch-site"),
"sec_fetch_mode": header_value(&headers, "sec-fetch-mode"),
"sec_fetch_dest": header_value(&headers, "sec-fetch-dest"),
"sec_ch_ua_present": header_value(&headers, "sec-ch-ua").is_some(),
"sec_ch_ua_mobile": header_value(&headers, "sec-ch-ua-mobile"),
"sec_ch_ua_platform": header_value(&headers, "sec-ch-ua-platform"),
});
json_string_response(payload.to_string())
}
async fn wpt_xhr_echo_body(headers: HeaderMap, body: Bytes) -> Response {
let payload = serde_json::json!({
"body": String::from_utf8_lossy(&body).to_string(),
"content_type": header_value(&headers, "content-type"),
"x_body_test": header_value(&headers, "x-body-test"),
});
json_string_response(payload.to_string())
}
async fn wpt_echo_body_hex(headers: HeaderMap, body: Bytes) -> Response {
let payload = serde_json::json!({
"body_hex": bytes_hex(&body),
"content_type": header_value(&headers, "content-type"),
});
json_string_response(payload.to_string())
}
fn bytes_hex(bytes: &[u8]) -> String {
let mut output = String::with_capacity(bytes.len() * 2);
for byte in bytes {
use std::fmt::Write;
let _ = write!(output, "{byte:02x}");
}
output
}
async fn wpt_cors_allow(headers: HeaderMap) -> Response {
cors_text_response(&headers, "cors-ok")
}
async fn wpt_cors_deny() -> Response {
text_response("cors-deny")
}
async fn wpt_cors_exposed_headers(headers: HeaderMap) -> Response {
let mut response = cors_text_response(&headers, "cors-exposed");
let response_headers = response.headers_mut();
response_headers.insert("content-language", HeaderValue::from_static("en-US"));
response_headers.insert("x-visible", HeaderValue::from_static("visible"));
response_headers.insert("x-case-visible", HeaderValue::from_static("case-visible"));
response_headers.insert("x-hidden", HeaderValue::from_static("hidden"));
response_headers.insert(
ACCESS_CONTROL_EXPOSE_HEADERS,
HeaderValue::from_static("X-Visible, X-Case-Visible"),
);
response
}
async fn wpt_cors_exposed_headers_wildcard(headers: HeaderMap) -> Response {
let mut response = cors_text_response(&headers, "cors-exposed-wildcard");
let response_headers = response.headers_mut();
response_headers.insert("x-wildcard-visible", HeaderValue::from_static("wildcard"));
response_headers.insert(ACCESS_CONTROL_EXPOSE_HEADERS, HeaderValue::from_static("*"));
response
}
async fn wpt_cors_exposed_headers_wildcard_credentials(headers: HeaderMap) -> Response {
let mut response = credentials_text_response(&headers, "cors-exposed-wildcard-credentials");
let response_headers = response.headers_mut();
response_headers.insert(
"x-wildcard-credentialed",
HeaderValue::from_static("credentialed"),
);
response_headers.insert(ACCESS_CONTROL_EXPOSE_HEADERS, HeaderValue::from_static("*"));
response
}
async fn wpt_cors_preflight_allow(method: Method, headers: HeaderMap, body: Bytes) -> Response {
cors_preflight_response(
method,
headers,
body,
"cors-preflight-allow",
"POST, PUT",
"content-type, x-preflight-test",
)
}
async fn wpt_cors_preflight_deny_method(
method: Method,
headers: HeaderMap,
body: Bytes,
) -> Response {
cors_preflight_response(
method,
headers,
body,
"cors-preflight-deny-method",
"GET",
"content-type, x-preflight-test",
)
}
async fn wpt_cors_preflight_deny_header(
method: Method,
headers: HeaderMap,
body: Bytes,
) -> Response {
cors_preflight_response(
method,
headers,
body,
"cors-preflight-deny-header",
"POST",
"content-type",
)
}
async fn wpt_cors_preflight_redirect_to_allow(
method: Method,
headers: HeaderMap,
body: Bytes,
) -> Response {
if method == Method::OPTIONS {
return cors_redirect_response("/wpt/runtime/cors/preflight/allow", &headers);
}
cors_preflight_response(
method,
headers,
body,
"cors-preflight-redirect-to-allow",
"POST",
"content-type, x-preflight-test",
)
}
async fn wpt_cors_preflight_redirect_to_preflight_required(
State(runtime_state): State<WptFixtureRuntimeState>,
Query(query): Query<HashMap<String, String>>,
method: Method,
headers: HeaderMap,
body: Bytes,
) -> Response {
if method == Method::OPTIONS {
return cors_preflight_response(
method,
headers,
body,
"cors-preflight-redirect-source",
"POST",
"content-type, x-preflight-test",
);
}
let token = query.get("token").cloned().unwrap_or_default();
let location = format!(
"http://{}/wpt/runtime/cors/preflight/preflight-required-final?token={}",
runtime_state.secondary_addr, token
);
cors_redirect_response(&location, &headers)
}
async fn wpt_cors_preflight_required_final(
State(runtime_state): State<WptFixtureRuntimeState>,
Query(query): Query<HashMap<String, String>>,
method: Method,
headers: HeaderMap,
body: Bytes,
) -> Response {
let token = query.get("token").cloned().unwrap_or_default();
if method == Method::OPTIONS {
if !token.is_empty() {
runtime_state
.cors_preflight_observations
.mark_preflight(&token);
}
return cors_preflight_response(
method,
headers,
body,
"cors-preflight-required-final",
"POST",
"content-type, x-preflight-test",
);
}
let payload = serde_json::json!({
"method": method.as_str(),
"body": String::from_utf8_lossy(&body).to_string(),
"x_preflight_test": header_value(&headers, "x-preflight-test"),
"content_type": header_value(&headers, "content-type"),
"preflighted": !token.is_empty() && runtime_state.cors_preflight_observations.take_preflighted(&token),
"response": "cors-preflight-required-final",
});
let mut response = json_string_response(payload.to_string());
add_cors_allow_origin_header(&mut response, &headers);
response
}
async fn wpt_cors_redirect_to_credentials_allow(
State(runtime_state): State<WptFixtureRuntimeState>,
headers: HeaderMap,
) -> Response {
let location = format!(
"http://{}/wpt/runtime/cors/credentials/allow",
runtime_state.secondary_addr
);
cors_redirect_response(&location, &headers)
}
async fn wpt_cors_redirect_to_same_origin_echo(
State(runtime_state): State<WptFixtureRuntimeState>,
headers: HeaderMap,
) -> Response {
let location = format!(
"http://{}:{}/wpt/runtime/cors/redirect/same-origin-echo",
WPT_BROWSER_HOST,
runtime_state.primary_addr.port()
);
cors_redirect_response(&location, &headers)
}
async fn wpt_cors_redirect_to_alt_to_same_origin_echo(
State(runtime_state): State<WptFixtureRuntimeState>,
headers: HeaderMap,
) -> Response {
let location = format!(
"http://{}:{}/wpt/runtime/cors/redirect/to-same-origin-echo",
WPT_BROWSER_HOST,
runtime_state.secondary_addr.port()
);
cors_redirect_response(&location, &headers)
}
async fn wpt_cors_redirect_to_cross_site_to_same_origin_echo(
State(runtime_state): State<WptFixtureRuntimeState>,
headers: HeaderMap,
) -> Response {
let location = format!(
"http://{}:{}/wpt/runtime/cors/redirect/to-same-origin-echo",
WPT_REMOTE_HOST,
runtime_state.secondary_addr.port()
);
cors_redirect_response(&location, &headers)
}
async fn wpt_cors_redirect_303_to_method_echo(
State(runtime_state): State<WptFixtureRuntimeState>,
headers: HeaderMap,
) -> Response {
let location = format!(
"http://{}/wpt/runtime/cors/redirect/method-echo",
runtime_state.secondary_addr
);
let mut response = cors_redirect_response(&location, &headers);
*response.status_mut() = StatusCode::SEE_OTHER;
response
}
async fn wpt_cors_redirect_307_to_method_echo(
State(runtime_state): State<WptFixtureRuntimeState>,
headers: HeaderMap,
) -> Response {
let location = format!(
"http://{}/wpt/runtime/cors/redirect/method-echo",
runtime_state.secondary_addr
);
let mut response = cors_redirect_response(&location, &headers);
*response.status_mut() = StatusCode::TEMPORARY_REDIRECT;
response
}
async fn wpt_cors_redirect_method_echo(
method: Method,
headers: HeaderMap,
body: Bytes,
) -> Response {
let payload = serde_json::json!({
"method": method.as_str(),
"body": String::from_utf8_lossy(&body).to_string(),
"content_type": header_value(&headers, "content-type"),
"origin": header_value(&headers, ORIGIN.as_str()),
"response": "cors-redirect-method-echo",
});
let mut response = json_string_response(payload.to_string());
add_cors_allow_origin_header(&mut response, &headers);
response
}
async fn wpt_cors_redirect_same_origin_echo(headers: HeaderMap) -> Response {
let payload = serde_json::json!({
"origin": header_value(&headers, ORIGIN.as_str()),
"response": "cors-redirect-same-origin-echo",
});
// A return to the initiating URL still needs CORS authorization after a
// cross-origin hop. Echo the actual Origin, including the literal null.
let mut response = json_string_response(payload.to_string());
add_cors_allow_origin_header(&mut response, &headers);
response
}
async fn wpt_cors_credentials_allow(headers: HeaderMap) -> Response {
credentials_text_response(&headers, "cors-credentials-ok")
}
async fn wpt_cors_credentials_wildcard() -> Response {
let mut response = text_response("cors-credentials-wildcard");
let headers = response.headers_mut();
headers.insert(ACCESS_CONTROL_ALLOW_ORIGIN, HeaderValue::from_static("*"));
headers.insert(
ACCESS_CONTROL_ALLOW_CREDENTIALS,
HeaderValue::from_static("true"),
);
headers.insert(VARY, HeaderValue::from_static("Origin"));
response
}
async fn wpt_fetch_credentials_request_cookie_set(headers: HeaderMap) -> Response {
credentials_response_with_set_cookie(
&headers,
"request-cookie=set",
"wpt_fetch_credentials_request=fixture; Path=/wpt/runtime/fetch/credentials; HttpOnly; SameSite=Lax",
)
}
async fn wpt_fetch_binary_response() -> Response {
binary_response(&[0x00, 0xff, 0x41, 0x80, 0x0a, 0x0d])
}
async fn wpt_fetch_credentials_request_cookie_check(headers: HeaderMap) -> Response {
let body = if has_cookie(&headers, "wpt_fetch_credentials_request=fixture") {
"request-cookie=seen"
} else {
"request-cookie=missing"
};
credentials_text_response(&headers, body)
}
async fn wpt_fetch_credentials_default_response_cookie_set(headers: HeaderMap) -> Response {
credentials_response_with_set_cookie(
&headers,
"default-response-cookie=set",
"wpt_fetch_credentials_default_response=stored; Path=/wpt/runtime/fetch/credentials; HttpOnly; SameSite=Lax",
)
}
async fn wpt_fetch_credentials_default_response_cookie_check(headers: HeaderMap) -> Response {
let body = if has_cookie(&headers, "wpt_fetch_credentials_default_response=stored") {
"default-response-cookie=seen"
} else {
"default-response-cookie=missing"
};
credentials_text_response(&headers, body)
}
async fn wpt_fetch_credentials_include_response_cookie_set(headers: HeaderMap) -> Response {
credentials_response_with_set_cookie(
&headers,
"include-response-cookie=set",
"wpt_fetch_credentials_include_response=stored; Path=/wpt/runtime/fetch/credentials; HttpOnly; SameSite=Lax",
)
}
async fn wpt_fetch_credentials_include_response_cookie_check(headers: HeaderMap) -> Response {
let body = if has_cookie(&headers, "wpt_fetch_credentials_include_response=stored") {
"include-response-cookie=seen"
} else {
"include-response-cookie=missing"
};
credentials_text_response(&headers, body)
}
async fn wpt_fetch_credentials_omit_response_cookie_set(headers: HeaderMap) -> Response {
credentials_response_with_set_cookie(
&headers,
"omit-response-cookie=set",
"wpt_fetch_credentials_omit_response=stored; Path=/wpt/runtime/fetch/credentials; HttpOnly; SameSite=Lax",
)
}
async fn wpt_fetch_credentials_omit_response_cookie_check(headers: HeaderMap) -> Response {
let body = if has_cookie(&headers, "wpt_fetch_credentials_omit_response=stored") {
"omit-response-cookie=seen"
} else {
"omit-response-cookie=missing"
};
credentials_text_response(&headers, body)
}
async fn wpt_fetch_credentials_streaming_response_cookie_set(
Path(mode): Path<String>,
headers: HeaderMap,
) -> Response {
let Some((body, cookie)) = streaming_fetch_credentials_cookie(&mode) else {
return StatusCode::NOT_FOUND.into_response();
};
streaming_credentials_response_with_set_cookie(&headers, body, cookie)
}
async fn wpt_fetch_credentials_streaming_response_cookie_check(
Path(mode): Path<String>,
headers: HeaderMap,
) -> Response {
let Some((body, cookie)) = streaming_fetch_credentials_cookie(&mode) else {
return StatusCode::NOT_FOUND.into_response();
};
let cookie_pair = cookie
.split(';')
.next()
.expect("streaming credentials cookie should include a name/value pair");
let response_body = if has_cookie(&headers, cookie_pair) {
body.seen
} else {
body.missing
};
credentials_text_response(&headers, response_body)
}
async fn wpt_xhr_credentials_request_cookie_set(headers: HeaderMap) -> Response {
credentials_response_with_set_cookie(
&headers,
"request-cookie=set",
"wpt_xhr_credentials_request=fixture; Path=/wpt/runtime/xhr/credentials; HttpOnly; SameSite=Lax",
)
}
async fn wpt_xhr_credentials_request_cookie_check(headers: HeaderMap) -> Response {
let body = if has_cookie(&headers, "wpt_xhr_credentials_request=fixture") {
"request-cookie=seen"
} else {
"request-cookie=missing"
};
credentials_text_response(&headers, body)
}
async fn wpt_xhr_credentials_default_response_cookie_set(headers: HeaderMap) -> Response {
credentials_response_with_set_cookie(
&headers,
"default-response-cookie=set",
"wpt_xhr_credentials_default_response=stored; Path=/wpt/runtime/xhr/credentials; HttpOnly; SameSite=Lax",
)
}
async fn wpt_xhr_credentials_default_response_cookie_check(headers: HeaderMap) -> Response {
let body = if has_cookie(&headers, "wpt_xhr_credentials_default_response=stored") {
"default-response-cookie=seen"
} else {
"default-response-cookie=missing"
};
credentials_text_response(&headers, body)
}
async fn wpt_xhr_credentials_include_response_cookie_set(headers: HeaderMap) -> Response {
credentials_response_with_set_cookie(
&headers,
"include-response-cookie=set",
"wpt_xhr_credentials_include_response=stored; Path=/wpt/runtime/xhr/credentials; HttpOnly; SameSite=Lax",
)
}
async fn wpt_xhr_credentials_include_response_cookie_check(headers: HeaderMap) -> Response {
let body = if has_cookie(&headers, "wpt_xhr_credentials_include_response=stored") {
"include-response-cookie=seen"
} else {
"include-response-cookie=missing"
};
credentials_text_response(&headers, body)
}
struct StreamingCredentialBody {
set_head: &'static str,
set_tail: &'static str,
seen: &'static str,
missing: &'static str,
}
fn streaming_fetch_credentials_cookie(
mode: &str,
) -> Option<(StreamingCredentialBody, &'static str)> {
match mode {
"default" => Some((
StreamingCredentialBody {
set_head: "streaming-default-response-cookie=head-",
set_tail: "tail",
seen: "streaming-default-response-cookie=seen",
missing: "streaming-default-response-cookie=missing",
},
"wpt_fetch_credentials_streaming_default=stored; Path=/wpt/runtime/fetch/credentials; HttpOnly; SameSite=Lax",
)),
"include" => Some((
StreamingCredentialBody {
set_head: "streaming-include-response-cookie=head-",
set_tail: "tail",
seen: "streaming-include-response-cookie=seen",
missing: "streaming-include-response-cookie=missing",
},
"wpt_fetch_credentials_streaming_include=stored; Path=/wpt/runtime/fetch/credentials; HttpOnly; SameSite=Lax",
)),
"omit" => Some((
StreamingCredentialBody {
set_head: "streaming-omit-response-cookie=head-",
set_tail: "tail",
seen: "streaming-omit-response-cookie=seen",
missing: "streaming-omit-response-cookie=missing",
},
"wpt_fetch_credentials_streaming_omit=stored; Path=/wpt/runtime/fetch/credentials; HttpOnly; SameSite=Lax",
)),
_ => None,
}
}
async fn wpt_form_submit_echo(
method: Method,
uri: Uri,
headers: HeaderMap,
body: Bytes,
) -> Response {
let payload = serde_json::json!({
"method": method.as_str(),
"search": uri.query().map(|query| format!("?{query}")).unwrap_or_default(),
"body": String::from_utf8_lossy(&body).to_string(),
"content_type": header_value(&headers, "content-type"),
});
html_response(format!(
"<!doctype html><body>{}</body>",
html_escape_text(&payload.to_string())
))
}
async fn wpt_worker_slow_script() -> Response {
sleep(Duration::from_millis(75)).await;
javascript_response(WPT_WORKER_SLOW_BODY.to_string())
}
async fn wpt_worker_module_redirect_start() -> Redirect {
Redirect::temporary("/wpt/ported/worker/resources/worker-module-http-redirect-entry.js")
}
async fn wpt_worker_module_redirect_fragment_start() -> Redirect {
Redirect::temporary(
"/wpt/ported/worker/resources/worker-module-http-redirect-entry.js#redirect-fragment",
)
}
async fn wpt_worker_module_credentials_cookie_set(headers: HeaderMap) -> Response {
credentials_response_with_set_cookie(
&headers,
"module-worker-cookie=set",
"wpt_worker_module_credentials=fixture; Path=/wpt/runtime/worker/module-credentials; HttpOnly; SameSite=Lax",
)
}
async fn wpt_worker_module_credentials_cookie_check(headers: HeaderMap) -> Response {
let body = if has_cookie(&headers, "wpt_worker_module_credentials=fixture") {
"module-worker-cookie=seen"
} else {
"module-worker-cookie=missing"
};
credentials_text_response(&headers, body)
}
async fn wpt_worker_module_credentials_main(
State(runtime_state): State<WptFixtureRuntimeState>,
) -> Response {
let dependency_url = format!(
"http://{}/wpt/runtime/worker/module-credentials/dependency.js",
runtime_state.secondary_addr
);
javascript_response(format!(
"import {{ credentialCookie }} from {};\npostMessage({{ credentialCookie, metaUrl: import.meta.url }});\n",
serde_json::to_string(&dependency_url).expect("dependency URL should serialize")
))
}
async fn wpt_worker_module_credentials_dependency(headers: HeaderMap) -> Response {
let credential_cookie = if has_cookie(&headers, "wpt_worker_module_credentials=fixture") {
"seen"
} else {
"missing"
};
let mut response = javascript_response(format!(
"export const credentialCookie = {};\n",
serde_json::to_string(credential_cookie).expect("cookie status should serialize")
));
add_cors_allow_origin_header(&mut response, &headers);
response.headers_mut().insert(
ACCESS_CONTROL_ALLOW_CREDENTIALS,
HeaderValue::from_static("true"),
);
response
}
async fn wpt_shared_worker_script_fetch_policy_cookie_set(headers: HeaderMap) -> Response {
credentials_response_with_set_cookie(
&headers,
"shared-worker-script-cookie=set",
"wpt_sharedworker_script_fetch_policy=fixture; Path=/wpt/runtime/sharedworker/script-fetch-policy; HttpOnly; SameSite=Lax",
)
}
async fn wpt_shared_worker_script_fetch_policy_remote_cookie_set(headers: HeaderMap) -> Response {
credentials_response_with_set_cookie(
&headers,
"shared-worker-script-remote-cookie=set",
"wpt_sharedworker_script_fetch_policy_remote=fixture; Path=/wpt/runtime/sharedworker/script-fetch-policy; HttpOnly; SameSite=Lax",
)
}
async fn wpt_shared_worker_script_fetch_policy_report_cookie(headers: HeaderMap) -> Response {
let credential_cookie = if has_cookie(&headers, "wpt_sharedworker_script_fetch_policy=fixture")
{
"seen"
} else {
"missing"
};
javascript_response(format!(
"onconnect = (event) => {{ event.ports[0].postMessage({{ cookie: {} }}); }};\n",
serde_json::to_string(credential_cookie).expect("cookie status should serialize")
))
}
async fn wpt_shared_worker_script_fetch_policy_report_import_cookie_main(
State(runtime_state): State<WptFixtureRuntimeState>,
Query(query): Query<HashMap<String, String>>,
) -> Response {
let import_kind = query.get("kind").map(String::as_str).unwrap_or("static");
let dependency_origin = query
.get("dependencyOrigin")
.map(String::as_str)
.unwrap_or("same");
let dependency_url = if let Some(dependency_url) = query.get("dependencyUrl") {
dependency_url.clone()
} else if dependency_origin == "remote" {
format!(
"http://{}/wpt/runtime/sharedworker/script-fetch-policy/report-import-cookie-remote-dependency.js",
runtime_state.secondary_addr
)
} else {
"/wpt/runtime/sharedworker/script-fetch-policy/report-import-cookie-dependency.js"
.to_owned()
};
let serialized_dependency_url =
serde_json::to_string(&dependency_url).expect("dependency URL should serialize");
match import_kind {
"dynamic" => javascript_response(format!(
"onconnect = async (event) => {{ const module = await import({serialized_dependency_url}); event.ports[0].postMessage({{ cookie: module.credentialCookie }}); }};\n"
)),
_ => javascript_response(format!(
"import {{ credentialCookie }} from {serialized_dependency_url};\nonconnect = (event) => {{ event.ports[0].postMessage({{ cookie: credentialCookie }}); }};\n"
)),
}
}
async fn wpt_shared_worker_script_fetch_policy_report_import_cookie_dependency(
headers: HeaderMap,
) -> Response {
shared_worker_script_fetch_policy_import_cookie_dependency_response(
headers,
"wpt_sharedworker_script_fetch_policy=fixture",
)
}
async fn wpt_shared_worker_script_fetch_policy_report_import_cookie_remote_dependency(
headers: HeaderMap,
) -> Response {
shared_worker_script_fetch_policy_import_cookie_dependency_response(
headers,
"wpt_sharedworker_script_fetch_policy_remote=fixture",
)
}
fn shared_worker_script_fetch_policy_import_cookie_dependency_response(
headers: HeaderMap,
expected_cookie: &str,
) -> Response {
let credential_cookie = if has_cookie(&headers, expected_cookie) {
"seen"
} else {
"missing"
};
let mut response = javascript_response(format!(
"export const credentialCookie = {};\n",
serde_json::to_string(credential_cookie).expect("cookie status should serialize")
));
add_cors_allow_origin_header(&mut response, &headers);
response.headers_mut().insert(
ACCESS_CONTROL_ALLOW_CREDENTIALS,
HeaderValue::from_static("true"),
);
response
}
async fn wpt_shared_worker_script_fetch_policy_referrer_policy_main() -> Response {
let mut response = javascript_response(
r#"import { dependencyReferer } from "./report-referrer-dependency.js";
onconnect = (event) => {
event.ports[0].postMessage({ dependencyReferer });
};
"#
.to_owned(),
);
response.headers_mut().insert(
HeaderName::from_static("referrer-policy"),
HeaderValue::from_static("no-referrer"),
);
response
}
async fn wpt_shared_worker_script_fetch_policy_report_referrer_dependency(
headers: HeaderMap,
) -> Response {
let referer = headers
.get("referer")
.and_then(|value| value.to_str().ok())
.unwrap_or_default();
javascript_response(format!(
"export const dependencyReferer = {};\n",
serde_json::to_string(referer).expect("referer should serialize")
))
}
async fn wpt_shared_worker_script_fetch_policy_cross_origin_redirect_start(
State(runtime_state): State<WptFixtureRuntimeState>,
) -> Redirect {
Redirect::temporary(&format!(
"http://{}/wpt/runtime/sharedworker/script-fetch-policy/cross-origin-target.js",
runtime_state.secondary_addr
))
}
async fn wpt_shared_worker_script_fetch_policy_cross_origin_target() -> Response {
javascript_response(
"onconnect = (event) => event.ports[0].postMessage('executed-cross-origin');\n".to_owned(),
)
}
async fn wpt_csp_reporting_target() -> Response {
text_response("csp-reporting-target")
}
async fn wpt_csp_reporting_collect(
State(runtime_state): State<WptFixtureRuntimeState>,
Query(query): Query<HashMap<String, String>>,
headers: HeaderMap,
body: Bytes,
) -> Response {
let Some(token) = query.get("token").filter(|token| !token.is_empty()) else {
return (StatusCode::BAD_REQUEST, "missing report token").into_response();
};
runtime_state.csp_report_observations.push(
token,
CspReportObservation {
content_type: header_value(&headers, CONTENT_TYPE.as_str()),
body: String::from_utf8_lossy(&body).to_string(),
},
);
StatusCode::NO_CONTENT.into_response()
}
async fn wpt_csp_reporting_take(
State(runtime_state): State<WptFixtureRuntimeState>,
Query(query): Query<HashMap<String, String>>,
) -> Response {
let Some(token) = query.get("token").filter(|token| !token.is_empty()) else {
return (StatusCode::BAD_REQUEST, "missing report token").into_response();
};
let reports = runtime_state
.csp_report_observations
.take(token)
.into_iter()
.map(|report| {
serde_json::json!({
"contentType": report.content_type,
"body": report.body,
})
})
.collect::<Vec<_>>();
json_string_response(serde_json::json!({ "reports": reports }).to_string())
}
async fn wpt_worker_module_json_mime_config() -> Response {
response_with_content_type(
r#"{"name":"runtime-json","nested":{"value":11}}"#,
"application/activity+json",
)
}
async fn wpt_worker_module_json_mime_with_charset() -> Response {
response_with_content_type(
r#"{"name":"charset-json"}"#,
"application/json; charset=utf-8",
)
}
async fn wpt_worker_module_json_mime_javascript() -> Response {
javascript_response("export default 'javascript-from-json-path';\n".to_owned())
}
async fn wpt_worker_module_json_mime_plain_json() -> Response {
text_response(r#"{"name":"plain-json"}"#)
}
async fn wpt_worker_importscripts_cross_origin_target() -> Response {
javascript_response(
"globalThis.__lmCrossOriginImportScriptsLoaded = true;\nthrow new Error('cross-origin importScripts target should not execute');\n".to_string(),
)
}
async fn wpt_worker_importscripts_redirect_to_cross_origin(
State(runtime_state): State<WptFixtureRuntimeState>,
) -> Redirect {
Redirect::temporary(&format!(
"http://{}/wpt/runtime/worker/importscripts/cross-origin-target.js",
runtime_state.secondary_addr
))
}
async fn wpt_worker_importscripts_args_worker() -> Response {
javascript_response(WPT_WORKER_IMPORTSCRIPTS_ARGS_WORKER_BODY.to_string())
}
async fn wpt_worker_importscripts_undefined() -> Response {
javascript_response(WPT_WORKER_IMPORTSCRIPTS_UNDEFINED_BODY.to_string())
}
async fn wpt_worker_importscripts_null() -> Response {
javascript_response(WPT_WORKER_IMPORTSCRIPTS_NULL_BODY.to_string())
}
async fn wpt_worker_importscripts_one() -> Response {
javascript_response(WPT_WORKER_IMPORTSCRIPTS_ONE_BODY.to_string())
}
fn header_value(headers: &HeaderMap, name: &str) -> Option<String> {
headers
.get(name)
.and_then(|value| value.to_str().ok())
.map(str::to_owned)
}
fn html_escape_text(value: &str) -> String {
value
.replace('&', "&")
.replace('<', "<")
.replace('>', ">")
}
fn html_escape_double_quoted_attribute(value: &str) -> String {
html_escape_text(value).replace('"', """)
}
fn has_cookie(headers: &HeaderMap, expected: &str) -> bool {
headers
.get(COOKIE)
.and_then(|value| value.to_str().ok())
.is_some_and(|cookies| {
cookies
.split(';')
.map(str::trim)
.any(|cookie| cookie == expected)
})
}
fn response_with_set_cookie(body: &'static str, cookie: &'static str) -> Response {
let mut response = text_response(body);
response
.headers_mut()
.append(SET_COOKIE, HeaderValue::from_static(cookie));
response
}
fn credentials_text_response(request_headers: &HeaderMap, body: &'static str) -> Response {
let mut response = cors_text_response(request_headers, body);
response.headers_mut().insert(
ACCESS_CONTROL_ALLOW_CREDENTIALS,
HeaderValue::from_static("true"),
);
response
}
fn credentials_response_with_set_cookie(
request_headers: &HeaderMap,
body: &'static str,
cookie: &'static str,
) -> Response {
let mut response = response_with_set_cookie(body, cookie);
add_cors_allow_origin_header(&mut response, request_headers);
response.headers_mut().insert(
ACCESS_CONTROL_ALLOW_CREDENTIALS,
HeaderValue::from_static("true"),
);
response
}
fn streaming_credentials_response_with_set_cookie(
request_headers: &HeaderMap,
body: StreamingCredentialBody,
cookie: &'static str,
) -> Response {
let (tx, rx) = mpsc::channel(2);
tokio::spawn(async move {
if tx
.send(Ok::<Bytes, std::convert::Infallible>(Bytes::from_static(
body.set_head.as_bytes(),
)))
.await
.is_err()
{
return;
}
sleep(Duration::from_millis(150)).await;
let _ = tx
.send(Ok::<Bytes, std::convert::Infallible>(Bytes::from_static(
body.set_tail.as_bytes(),
)))
.await;
});
let mut response = Response::builder()
.header(CONTENT_TYPE, "text/plain; charset=utf-8")
.body(Body::from_stream(ReceiverStream::new(rx)))
.expect("streaming credentials response should build");
add_cors_allow_origin_header(&mut response, request_headers);
let headers = response.headers_mut();
headers.insert(
ACCESS_CONTROL_ALLOW_CREDENTIALS,
HeaderValue::from_static("true"),
);
headers.append(SET_COOKIE, HeaderValue::from_static(cookie));
response
}
fn cors_text_response(request_headers: &HeaderMap, body: &'static str) -> Response {
let mut response = text_response(body);
add_cors_allow_origin_header(&mut response, request_headers);
response
}
fn cors_preflight_response(
method: Method,
request_headers: HeaderMap,
body: Bytes,
response_body: &'static str,
allowed_methods: &'static str,
allowed_headers: &'static str,
) -> Response {
if method == Method::OPTIONS {
let payload = serde_json::json!({
"access_control_request_method": header_value(&request_headers, ACCESS_CONTROL_REQUEST_METHOD.as_str()),
"access_control_request_headers": header_value(&request_headers, ACCESS_CONTROL_REQUEST_HEADERS.as_str()),
});
let mut response = json_string_response(payload.to_string());
add_cors_allow_origin_header(&mut response, &request_headers);
let headers = response.headers_mut();
headers.insert(
ACCESS_CONTROL_ALLOW_METHODS,
HeaderValue::from_static(allowed_methods),
);
headers.insert(
ACCESS_CONTROL_ALLOW_HEADERS,
HeaderValue::from_static(allowed_headers),
);
return response;
}
let payload = serde_json::json!({
"method": method.as_str(),
"body": String::from_utf8_lossy(&body).to_string(),
"x_preflight_test": header_value(&request_headers, "x-preflight-test"),
"content_type": header_value(&request_headers, "content-type"),
"response": response_body,
});
let mut response = json_string_response(payload.to_string());
add_cors_allow_origin_header(&mut response, &request_headers);
response
}
fn cors_redirect_response(location: &str, request_headers: &HeaderMap) -> Response {
let mut response = Redirect::temporary(location).into_response();
add_cors_allow_origin_header(&mut response, request_headers);
response
}
fn add_cors_allow_origin_header(response: &mut Response, request_headers: &HeaderMap) {
let allow_origin = request_headers
.get(ORIGIN)
.cloned()
.unwrap_or_else(|| HeaderValue::from_static("*"));
let headers = response.headers_mut();
headers.insert(ACCESS_CONTROL_ALLOW_ORIGIN, allow_origin);
headers.insert(VARY, HeaderValue::from_static("Origin"));
}
fn redirect_with_cookies(location: &'static str, cookies: &[&'static str]) -> Response {
let mut response = Redirect::temporary(location).into_response();
for cookie in cookies {
response
.headers_mut()
.append(SET_COOKIE, HeaderValue::from_static(cookie));
}
response
}
fn text_response(source: &'static str) -> Response {
let mut response = source.into_response();
response.headers_mut().insert(
CONTENT_TYPE,
HeaderValue::from_static("text/plain; charset=utf-8"),
);
response
}
fn response_with_content_type(source: &'static str, content_type: &'static str) -> Response {
let mut response = source.into_response();
response
.headers_mut()
.insert(CONTENT_TYPE, HeaderValue::from_static(content_type));
response
}
fn json_response(source: &'static str) -> Response {
let mut response = source.into_response();
response
.headers_mut()
.insert(CONTENT_TYPE, HeaderValue::from_static("application/json"));
response
}
fn json_string_response(source: String) -> Response {
let mut response = source.into_response();
response
.headers_mut()
.insert(CONTENT_TYPE, HeaderValue::from_static("application/json"));
response
}
fn js_string_literal(value: &str) -> String {
serde_json::to_string(value).expect("string serialization should not fail")
}
fn binary_response(bytes: &'static [u8]) -> Response {
let mut response = bytes.to_vec().into_response();
response.headers_mut().insert(
CONTENT_TYPE,
HeaderValue::from_static("application/octet-stream"),
);
response
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn fixture_case_urls_use_https_port_only_for_trusted_https_cases() {
let mut server = WptFixtureServer::for_test_addr("127.0.0.1:12345".parse().unwrap());
server.https_addr = "127.0.0.1:23456".parse().unwrap();
let mut case = crate::load_manifest_case("testharness-dom-exception-assertions")
.unwrap()
.unwrap();
case.local_path = "upstream/example/sample.https.any.js".into();
case.query = "1-10".into();
assert_eq!(
server.case_url(&case),
"https://localhost:23456/wpt/upstream/example/sample.https.any.js?1-10&moli-wpt-window-wrapper=1"
);
case.origin = WptManifestOrigin::Insecure;
assert_eq!(
server.case_url(&case),
"http://0.0.0.0:12345/wpt/upstream/example/sample.https.any.js?1-10&moli-wpt-window-wrapper=1"
);
case.origin = WptManifestOrigin::Trusted;
case.local_path = "ported/harness/sample.html".into();
case.query.clear();
assert_eq!(
server.case_url(&case),
"http://localhost:12345/wpt/ported/harness/sample.html"
);
case.local_path = "ported/harness/sample.https.html".into();
case.test_type = "crashtest".into();
assert_eq!(
server.case_url(&case),
"https://localhost:23456/wpt/ported/harness/sample.https.html?moli-wpt-crashtest=1"
);
}
#[test]
fn sanitize_wpt_fixture_path_rejects_escape_components() {
assert!(sanitize_wpt_fixture_path("../manifest.toml").is_none());
assert!(sanitize_wpt_fixture_path("/manifest.toml").is_none());
assert!(sanitize_wpt_fixture_path("manifest.toml").is_none());
assert!(sanitize_wpt_fixture_path("runtime/xhr/text").is_none());
assert!(sanitize_wpt_fixture_path("").is_none());
}
#[test]
fn sanitize_wpt_fixture_path_accepts_nested_fixture_path() {
let path = sanitize_wpt_fixture_path("ported/dom/eventtarget-basic.html")
.expect("nested WPT fixture path should be accepted");
assert!(path.ends_with("ported/dom/eventtarget-basic.html"));
let path = sanitize_wpt_fixture_path("upstream/url/url-origin.any.js")
.expect("upstream WPT fixture path should be accepted");
assert!(path.ends_with("upstream/url/url-origin.any.js"));
}
#[test]
fn fixture_root_resolves_from_the_active_checkout() {
let current_dir = std::env::current_dir().expect("test current directory");
let active_checkout_root = wpt_fixture_root_in_checkout(¤t_dir)
.expect("WPT fixtures should be discoverable from the test checkout");
let resolved_root = wpt_fixture_root();
assert_eq!(
std::fs::canonicalize(resolved_root).expect("resolved fixture root"),
std::fs::canonicalize(active_checkout_root).expect("active checkout fixture root"),
"a test artifact reused across worktrees must serve fixtures from the checkout that runs it"
);
}
#[test]
fn wpt_fixture_url_prefixes_fixture_route() {
let addr = "127.0.0.1:12345".parse().expect("valid socket addr");
assert_eq!(
wpt_fixture_url(addr, "ported/dom/eventtarget-basic.html"),
"http://localhost:12345/wpt/ported/dom/eventtarget-basic.html"
);
assert_eq!(
wpt_fixture_url(addr, "/resources/testharness.js"),
"http://localhost:12345/wpt/resources/testharness.js"
);
}
#[test]
fn wpt_case_url_wraps_window_js_fixtures() {
let addr = "127.0.0.1:12345".parse().expect("valid socket addr");
assert_eq!(
wpt_case_url(
addr,
"upstream/url/url-origin.any.js",
"window",
"",
WptManifestOrigin::Trusted
),
"http://localhost:12345/wpt/upstream/url/url-origin.any.js?moli-wpt-window-wrapper=1"
);
assert_eq!(
wpt_case_url(
addr,
"upstream/dom/events/EventTarget.window.js",
"window",
"",
WptManifestOrigin::Trusted
),
"http://localhost:12345/wpt/upstream/dom/events/EventTarget.window.js?moli-wpt-window-wrapper=1"
);
assert_eq!(
wpt_case_url(
addr,
"upstream/workers/importscripts_mime.any.js",
"worker",
"",
WptManifestOrigin::Trusted
),
"http://localhost:12345/wpt/upstream/workers/importscripts_mime.any.js?moli-wpt-worker-wrapper=1"
);
assert_eq!(
wpt_case_url(
addr,
"upstream/workers/examples/onconnect.any.js",
"sharedworker",
"",
WptManifestOrigin::Trusted
),
"http://localhost:12345/wpt/upstream/workers/examples/onconnect.any.js?moli-wpt-shared-worker-wrapper=1"
);
assert_eq!(
wpt_case_url(
addr,
"ported/dom/eventtarget-basic.html",
"window",
"",
WptManifestOrigin::Trusted
),
"http://localhost:12345/wpt/ported/dom/eventtarget-basic.html"
);
assert_eq!(
wpt_case_url(
addr,
"upstream/WebCryptoAPI/derive_bits_keys/pbkdf2.https.any.js",
"window",
"1-1000",
WptManifestOrigin::Trusted
),
"http://localhost:12345/wpt/upstream/WebCryptoAPI/derive_bits_keys/pbkdf2.https.any.js?1-1000&moli-wpt-window-wrapper=1"
);
assert_eq!(
wpt_case_url(
addr,
"upstream/WebCryptoAPI/historical.any.js",
"worker",
"",
WptManifestOrigin::Insecure
),
"http://0.0.0.0:12345/wpt/upstream/WebCryptoAPI/historical.any.js?moli-wpt-worker-wrapper=1"
);
}
#[test]
fn wpt_window_wrapper_loads_harness_then_script() {
let html = wpt_window_wrapper_html("upstream/url/url-origin.any.js", "", &HashMap::new());
assert!(html.contains(r#"<script src="/wpt/resources/testharness.js"></script>"#));
assert!(html.contains(r#"<script src="/wpt/resources/moli-wpt-adapter.js"></script>"#));
assert!(html.contains(r#"<body><div id="log"></div>"#));
assert!(html.contains(r#"<script src="/wpt/upstream/url/url-origin.any.js"></script>"#));
}
#[test]
fn wpt_worker_wrapper_loads_harness_and_fetches_worker_results() {
let html = wpt_worker_wrapper_html(
"upstream/workers/importscripts_mime.any.js",
"",
&HashMap::new(),
);
assert!(html.contains(r#"<script src="/wpt/resources/testharness.js"></script>"#));
assert!(html.contains(r#"<script src="/wpt/resources/moli-wpt-adapter.js"></script>"#));
assert!(html.contains("fetch_tests_from_worker(new Worker("));
assert!(html.contains("/workers/importscripts_mime.any.worker.js"));
}
#[test]
fn wpt_worker_wrapper_uses_public_workers_url_for_worker_js_entrypoint() {
let html = wpt_worker_wrapper_html(
"upstream/workers/examples/general.worker.js",
"",
&HashMap::new(),
);
assert!(html.contains("fetch_tests_from_worker(new Worker("));
assert!(html.contains("/workers/examples/general.worker.js"));
assert!(!html.contains("moli-wpt-worker-entry"));
}
#[test]
fn wpt_shared_worker_wrapper_uses_sharedworker_global_entry_url() {
let html = wpt_shared_worker_wrapper_html(
"upstream/workers/examples/onconnect.any.js",
"",
&HashMap::new(),
);
assert!(html.contains("fetch_tests_from_worker(new SharedWorker("));
assert!(html.contains("/workers/examples/onconnect.any.worker.js"));
}
#[test]
fn wpt_worker_entry_source_path_maps_synthetic_any_worker_url() {
assert_eq!(
wpt_worker_entry_source_path("upstream/workers/Worker-location.sub.any.worker.js")
.as_deref(),
Some("upstream/workers/Worker-location.sub.any.js")
);
assert_eq!(
wpt_worker_entry_source_path("upstream/workers/examples/onconnect.any.sharedworker.js")
.as_deref(),
Some("upstream/workers/examples/onconnect.any.js")
);
assert_eq!(
wpt_worker_entry_source_path("upstream/workers/Worker-location.sub.any.js"),
None
);
}
#[test]
fn wpt_worker_entry_imports_harness_meta_scripts_and_entrypoint() {
let source = "// META: script=../support/helper.js\n// META: script=/common/gc.js?run=1\n// META: script=report-error-helper.js\n";
let script = wpt_worker_entry_script(
"upstream/workers/interfaces/WorkerUtils/importScripts/report-error-cross-origin.sub.any.js",
source,
&HashMap::new(),
);
assert!(script.contains(r#"importScripts("/resources/testharness.js");"#));
assert!(
script
.contains(r#"importScripts("/workers/interfaces/WorkerUtils/support/helper.js");"#)
);
assert!(script.contains(r#"importScripts("/wpt/upstream/common/gc.js?run=1");"#));
assert!(
script.contains(r#"importScripts("/workers/interfaces/WorkerUtils/importScripts/report-error-helper.js");"#)
);
assert!(script.contains(
r#"importScripts("/workers/interfaces/WorkerUtils/importScripts/report-error-cross-origin.sub.any.js");"#
));
}
#[test]
fn wpt_public_script_url_uses_root_worker_alias_for_upstream_workers() {
assert_eq!(
wpt_public_script_url(
"upstream/workers/interfaces/WorkerUtils/importScripts/report-error-helper.js"
),
"/workers/interfaces/WorkerUtils/importScripts/report-error-helper.js"
);
assert_eq!(
wpt_public_script_url("upstream/common/gc.js?run=1"),
"/wpt/upstream/common/gc.js?run=1"
);
}
#[test]
fn wpt_window_wrapper_escapes_script_path_attribute() {
let html = wpt_window_wrapper_html("upstream/url/quote\"<&.any.js", "", &HashMap::new());
assert!(html.contains("quote"<&.any.js"));
}
#[test]
fn wpt_worker_wrapper_forwards_variant_query_to_worker_entry() {
let query = HashMap::from([
("1-1000".to_owned(), "1".to_owned()),
(WPT_WORKER_WRAPPER_QUERY.to_owned(), "1".to_owned()),
]);
let html = wpt_worker_wrapper_html(
"upstream/WebCryptoAPI/derive_bits_keys/pbkdf2.https.any.js",
"",
&query,
);
assert!(html.contains("/wpt/upstream/WebCryptoAPI/derive_bits_keys/pbkdf2.https.any.js?moli-wpt-worker-entry=1&1-1000"));
}
#[test]
fn wpt_worker_entry_forwards_variant_query_to_test_script() {
let query = HashMap::from([
("1-1000".to_owned(), "1".to_owned()),
(WPT_WORKER_ENTRY_QUERY.to_owned(), "1".to_owned()),
]);
let script = wpt_worker_entry_script(
"upstream/WebCryptoAPI/derive_bits_keys/pbkdf2.https.any.js",
"",
&query,
);
assert!(script.contains(
r#"importScripts("/wpt/upstream/WebCryptoAPI/derive_bits_keys/pbkdf2.https.any.js?1-1000");"#
));
}
#[test]
fn upstream_html_fixture_injects_moli_adapter_after_harness_report() {
let html = adapt_upstream_html_fixture(
"upstream/FileAPI/file/File-constructor-endings.html",
r#"<script src="/resources/testharness.js"></script><script src="/resources/testharnessreport.js"></script>"#.to_owned(),
);
assert!(
html.contains(
r#"<script src="/resources/testharnessreport.js"></script><script src="/wpt/resources/moli-wpt-adapter.js"></script>"#
)
);
}
#[test]
fn upstream_html_fixture_injects_adapter_after_unquoted_harness_report() {
let html = adapt_upstream_html_fixture(
"upstream/workers/interfaces/DedicatedWorkerGlobalScope/postMessage/message-event.html",
r#"<script src=/resources/testharness.js></script><script src=/resources/testharnessreport.js></script>"#.to_owned(),
);
assert!(
html.contains(
r#"<script src=/resources/testharnessreport.js></script><script src="/wpt/resources/moli-wpt-adapter.js"></script>"#
)
);
}
#[test]
fn ported_html_fixture_does_not_inject_moli_adapter() {
let source = r#"<script src="/resources/testharnessreport.js"></script>"#.to_owned();
assert_eq!(
adapt_upstream_html_fixture("ported/dom/eventtarget-basic.html", source.clone()),
source
);
}
#[test]
fn wpt_window_wrapper_loads_meta_scripts_before_entrypoint() {
let html = wpt_window_wrapper_html(
"upstream/FileAPI/blob/Blob-constructor.any.js",
"// META: script=../support/Blob.js\n// META: script=/common/gc.js?run=1\n",
&HashMap::new(),
);
let helper = html
.find(r#"<script src="/wpt/upstream/FileAPI/support/Blob.js"></script>"#)
.expect("relative META script should be included");
let root_helper = html
.find(r#"<script src="/wpt/upstream/common/gc.js?run=1"></script>"#)
.expect("root-relative META script should stay under upstream fixture root");
let entrypoint = html
.find(r#"<script src="/wpt/upstream/FileAPI/blob/Blob-constructor.any.js"></script>"#)
.expect("entrypoint should be included");
assert!(helper < entrypoint);
assert!(root_helper < entrypoint);
}
#[test]
fn wpt_fixture_content_type_accepts_text_fixture_types() {
assert_eq!(
wpt_fixture_content_type(
StdPath::new("upstream/url/basic.window.js"),
"upstream/url/basic.window.js",
),
Some("application/javascript")
);
assert_eq!(
wpt_fixture_content_type(
StdPath::new("upstream/xhr/basic.sub.htm"),
"upstream/xhr/basic.sub.htm",
),
Some("text/html; charset=utf-8")
);
assert_eq!(
wpt_fixture_content_type(
StdPath::new("upstream/resources/helper.txt"),
"upstream/resources/helper.txt",
),
Some("text/plain; charset=utf-8")
);
assert_eq!(
wpt_fixture_content_type(
StdPath::new("resources/testharness.css"),
"resources/testharness.css",
),
Some("text/css; charset=utf-8")
);
assert_eq!(
wpt_fixture_content_type(
StdPath::new("upstream/xhr/resources/well-formed.xml"),
"upstream/xhr/resources/well-formed.xml",
),
Some("application/xml")
);
assert_eq!(
wpt_fixture_content_type(
StdPath::new("upstream/workers/constructors/Worker/undefined"),
"upstream/workers/constructors/Worker/undefined",
),
Some("application/javascript")
);
assert_eq!(
wpt_fixture_content_type(
StdPath::new("upstream/workers/interfaces/WorkerUtils/importScripts/null"),
"upstream/workers/interfaces/WorkerUtils/importScripts/null",
),
Some("application/javascript")
);
assert_eq!(
wpt_fixture_content_type(
StdPath::new("upstream/resources/undefined"),
"upstream/resources/undefined",
),
None
);
assert_eq!(
wpt_fixture_content_type(
StdPath::new("upstream/resources/handler.py"),
"upstream/resources/handler.py",
),
None
);
}
#[tokio::test]
async fn static_worker_script_fixtures_preserve_non_utf8_bytes() {
let fixture_path = "upstream/workers/constructors/Worker/script-utf16be.js";
let fs_path = sanitize_wpt_fixture_path(fixture_path).expect("fixture path");
let runtime_state = WptFixtureRuntimeState {
primary_addr: "127.0.0.1:8000".parse().expect("primary addr"),
secondary_addr: "127.0.0.1:8001".parse().expect("secondary addr"),
primary_https_addr: "127.0.0.1:8443".parse().expect("primary HTTPS addr"),
secondary_https_addr: "127.0.0.1:9443".parse().expect("secondary HTTPS addr"),
abort_observations: Arc::new(AbortObservationRegistry::default()),
cors_preflight_observations: Arc::new(CorsPreflightObservationRegistry::default()),
csp_report_observations: Arc::new(CspReportObservationRegistry::default()),
};
let response = read_static_wpt_fixture_body(
&fs_path,
fixture_path,
"application/javascript",
&runtime_state,
&HashMap::new(),
)
.await
.expect("fixture should be read as bytes");
let body = axum::body::to_bytes(response.into_body(), usize::MAX)
.await
.expect("response body");
assert_eq!(&body[..4], &[0xfe, 0xff, 0x00, 0x2f]);
}
#[tokio::test]
async fn static_fixture_applies_headers_sidecar() {
let fixture_path = "upstream/workers/modules/resources/export-on-load-script.js";
let fs_path = sanitize_wpt_fixture_path(fixture_path).expect("fixture path");
let runtime_state = WptFixtureRuntimeState {
primary_addr: "127.0.0.1:8000".parse().expect("primary addr"),
secondary_addr: "127.0.0.1:8001".parse().expect("secondary addr"),
primary_https_addr: "127.0.0.1:8443".parse().expect("primary HTTPS addr"),
secondary_https_addr: "127.0.0.1:9443".parse().expect("secondary HTTPS addr"),
abort_observations: Arc::new(AbortObservationRegistry::default()),
cors_preflight_observations: Arc::new(CorsPreflightObservationRegistry::default()),
csp_report_observations: Arc::new(CspReportObservationRegistry::default()),
};
let response = read_static_wpt_fixture_body(
&fs_path,
fixture_path,
"application/javascript",
&runtime_state,
&HashMap::new(),
)
.await
.expect("fixture should be read with sidecar headers");
assert_eq!(
response.headers().get(ACCESS_CONTROL_ALLOW_ORIGIN),
Some(&HeaderValue::from_static("*"))
);
}
#[tokio::test]
async fn static_fixture_applies_header_pipe() {
let fixture_path = "upstream/fetch/api/resources/top.txt";
let fs_path = sanitize_wpt_fixture_path(fixture_path).expect("fixture path");
let runtime_state = WptFixtureRuntimeState {
primary_addr: "127.0.0.1:8000".parse().expect("primary addr"),
secondary_addr: "127.0.0.1:8001".parse().expect("secondary addr"),
primary_https_addr: "127.0.0.1:8443".parse().expect("primary HTTPS addr"),
secondary_https_addr: "127.0.0.1:9443".parse().expect("secondary HTTPS addr"),
abort_observations: Arc::new(AbortObservationRegistry::default()),
cors_preflight_observations: Arc::new(CorsPreflightObservationRegistry::default()),
csp_report_observations: Arc::new(CspReportObservationRegistry::default()),
};
let mut query = HashMap::new();
query.insert(
"pipe".to_owned(),
"header(Access-Control-Allow-Origin, null)|header(Bad Header,ok)|header(X-Bad,bad\r\nInjected: x)".to_owned(),
);
let response = read_static_wpt_fixture_body(
&fs_path,
fixture_path,
"text/plain; charset=utf-8",
&runtime_state,
&query,
)
.await
.expect("fixture should be read with pipe headers");
assert_eq!(
response.headers().get(ACCESS_CONTROL_ALLOW_ORIGIN),
Some(&HeaderValue::from_static("null"))
);
assert!(response.headers().get("x-bad").is_none());
}
#[test]
fn worker_nosniff_error_fixture_response_matches_upstream_handler() {
let response = wpt_worker_nosniff_error_response();
assert_eq!(
response.headers().get(CONTENT_TYPE),
Some(&HeaderValue::from_static("text/html"))
);
assert_eq!(
response.headers().get("x-content-type-options"),
Some(&HeaderValue::from_static("nosniff"))
);
}
#[test]
fn worker_imported_script_fixture_response_uses_requested_mime() {
let mut query = HashMap::new();
query.insert(
"mime".to_owned(),
"text/javascript; charset=utf-8".to_owned(),
);
let response = wpt_worker_imported_script_response(&query);
assert_eq!(
response.headers().get(CONTENT_TYPE),
Some(&HeaderValue::from_static("text/javascript; charset=utf-8"))
);
}
#[test]
fn worker_location_helper_redirect_matches_upstream_handler() {
let response = wpt_worker_location_helper_redirect();
assert_eq!(response.status(), StatusCode::TEMPORARY_REDIRECT);
assert_eq!(
response.headers().get("location"),
Some(&HeaderValue::from_static("post-location-members.js?a"))
);
}
#[test]
fn worker_module_resource_redirect_matches_upstream_handler() {
let mut query = HashMap::new();
query.insert(
"location".to_owned(),
"/workers/modules/resources/export-on-load-script.js".to_owned(),
);
let response = wpt_worker_module_resource_redirect(&query);
assert_eq!(response.status(), StatusCode::TEMPORARY_REDIRECT);
assert_eq!(
response.headers().get(LOCATION),
Some(&HeaderValue::from_static(
"/workers/modules/resources/export-on-load-script.js"
))
);
}
#[tokio::test]
async fn worker_module_export_on_load_script_matches_upstream_handler() {
let response = wpt_worker_module_export_on_load_script();
assert_eq!(
response.headers().get(CONTENT_TYPE),
Some(&HeaderValue::from_static("text/javascript"))
);
assert_eq!(
response.headers().get(ACCESS_CONTROL_ALLOW_ORIGIN),
Some(&HeaderValue::from_static("*"))
);
assert_eq!(
response.headers().get(ACCESS_CONTROL_ALLOW_HEADERS),
Some(&HeaderValue::from_static("Service-Worker"))
);
let body = axum::body::to_bytes(response.into_body(), usize::MAX)
.await
.expect("response body");
assert_eq!(
body,
Bytes::from_static(b"export const importedModules = ['export-on-load-script.js'];")
);
}
#[test]
fn service_worker_redirect_response_matches_upstream_query_shape() {
let mut query = HashMap::new();
query.insert(
"Redirect".to_owned(),
"http://example.test/target.js".to_owned(),
);
query.insert("ACAOrigin".to_owned(), "*".to_owned());
query.insert("Status".to_owned(), "302".to_owned());
let response = wpt_service_worker_redirect_response(&query);
assert_eq!(response.status(), StatusCode::FOUND);
assert_eq!(
response.headers().get(LOCATION),
Some(&HeaderValue::from_static("http://example.test/target.js"))
);
assert_eq!(
response.headers().get(ACCESS_CONTROL_ALLOW_ORIGIN),
Some(&HeaderValue::from_static("*"))
);
}
#[test]
fn wpt_substitution_replaces_basic_fixture_tokens() {
let runtime_state = WptFixtureRuntimeState {
primary_addr: "127.0.0.1:12345"
.parse()
.expect("valid primary socket addr"),
secondary_addr: "127.0.0.1:23456"
.parse()
.expect("valid secondary socket addr"),
primary_https_addr: "127.0.0.1:34567"
.parse()
.expect("valid primary HTTPS socket addr"),
secondary_https_addr: "127.0.0.1:45678"
.parse()
.expect("valid secondary HTTPS socket addr"),
abort_observations: Arc::new(AbortObservationRegistry::default()),
cors_preflight_observations: Arc::new(CorsPreflightObservationRegistry::default()),
csp_report_observations: Arc::new(CspReportObservationRegistry::default()),
};
let substituted = apply_wpt_substitutions(
"upstream/dom/events/EventListener-incumbent-global-1.sub.html",
"http://{{host}}:{{ports[http][0]}} \
http://{{domains[www1]}}:{{ports[http][1]}} \
https://{{domains[www1]}}:{{ports[https][0]}} \
{{location[scheme]}} {{location[host]}} {{location[path]}} \
{{hosts[alt][]}} {{unknown}}"
.to_owned(),
&runtime_state,
&HashMap::new(),
);
assert!(substituted.contains("http://localhost:12345"));
assert!(substituted.contains("http://127.0.0.1:23456"));
assert!(substituted.contains("https://127.0.0.1:34567"));
assert!(substituted.contains("http localhost:12345"));
assert!(
substituted
.contains("/wpt/upstream/dom/events/EventListener-incumbent-global-1.sub.html")
);
assert!(substituted.contains("{{unknown}}"));
}
#[test]
fn wpt_substitution_replaces_get_query_tokens() {
let runtime_state = WptFixtureRuntimeState {
primary_addr: "127.0.0.1:12345"
.parse()
.expect("valid primary socket addr"),
secondary_addr: "127.0.0.1:23456"
.parse()
.expect("valid secondary socket addr"),
primary_https_addr: "127.0.0.1:34567"
.parse()
.expect("valid primary HTTPS socket addr"),
secondary_https_addr: "127.0.0.1:45678"
.parse()
.expect("valid secondary HTTPS socket addr"),
abort_observations: Arc::new(AbortObservationRegistry::default()),
cors_preflight_observations: Arc::new(CorsPreflightObservationRegistry::default()),
csp_report_observations: Arc::new(CspReportObservationRegistry::default()),
};
let query = HashMap::from([
(
"action".to_owned(),
"target/form-action-url-target.html".to_owned(),
),
("empty".to_owned(), String::new()),
]);
let substituted = apply_wpt_substitutions(
"upstream/html/semantics/forms/the-form-element/resources/form-with-action.sub.html",
r#"<form action="{{GET[action]}}" data-empty="{{GET[empty]}}" data-missing="{{GET[missing]}}">"#
.to_owned(),
&runtime_state,
&query,
);
assert_eq!(
substituted,
r#"<form action="target/form-action-url-target.html" data-empty="" data-missing="">"#
);
}
#[test]
fn wpt_substitution_ignores_non_sub_fixtures() {
let runtime_state = WptFixtureRuntimeState {
primary_addr: "127.0.0.1:12345"
.parse()
.expect("valid primary socket addr"),
secondary_addr: "127.0.0.1:23456"
.parse()
.expect("valid secondary socket addr"),
primary_https_addr: "127.0.0.1:34567"
.parse()
.expect("valid primary HTTPS socket addr"),
secondary_https_addr: "127.0.0.1:45678"
.parse()
.expect("valid secondary HTTPS socket addr"),
abort_observations: Arc::new(AbortObservationRegistry::default()),
cors_preflight_observations: Arc::new(CorsPreflightObservationRegistry::default()),
csp_report_observations: Arc::new(CspReportObservationRegistry::default()),
};
let source = "http://{{host}}:{{ports[http][0]}}".to_owned();
assert_eq!(
apply_wpt_substitutions(
"upstream/url/url-origin.any.js",
source.clone(),
&runtime_state,
&HashMap::new()
),
source
);
}
#[test]
fn has_cookie_requires_full_cookie_pair_match() {
let mut headers = HeaderMap::new();
headers.insert(
COOKIE,
HeaderValue::from_static("not_wpt=one_extra; theme=dark"),
);
assert!(!has_cookie(&headers, "wpt=one"));
}
#[test]
fn has_cookie_matches_trimmed_cookie_pair() {
let mut headers = HeaderMap::new();
headers.insert(
COOKIE,
HeaderValue::from_static("theme=dark; wpt=one; session=ok"),
);
assert!(has_cookie(&headers, "wpt=one"));
}
#[test]
fn host_header_port_extracts_numeric_port() {
let mut headers = HeaderMap::new();
headers.insert(HOST, HeaderValue::from_static("127.0.0.1:34567"));
assert_eq!(host_header_port(&headers), Some(34567));
}
#[test]
fn alternate_wpt_fixture_port_toggles_between_primary_and_secondary() {
let runtime_state = WptFixtureRuntimeState {
primary_addr: "127.0.0.1:12345"
.parse()
.expect("valid primary socket addr"),
secondary_addr: "127.0.0.1:23456"
.parse()
.expect("valid secondary socket addr"),
primary_https_addr: "127.0.0.1:34567"
.parse()
.expect("valid primary HTTPS socket addr"),
secondary_https_addr: "127.0.0.1:45678"
.parse()
.expect("valid secondary HTTPS socket addr"),
abort_observations: Arc::new(AbortObservationRegistry::default()),
cors_preflight_observations: Arc::new(CorsPreflightObservationRegistry::default()),
csp_report_observations: Arc::new(CspReportObservationRegistry::default()),
};
assert_eq!(
alternate_wpt_fixture_port(&runtime_state, Some(12345)),
23456
);
assert_eq!(
alternate_wpt_fixture_port(&runtime_state, Some(23456)),
12345
);
assert_eq!(alternate_wpt_fixture_port(&runtime_state, None), 23456);
}
}