fix(csp): dispatch worker module violations as independent tasks

This commit is contained in:
ldm0
2026-11-21 20:03:37 +08:00
parent 4ea81c260c
commit fe571f70cd
4 changed files with 337 additions and 77 deletions
@@ -25,6 +25,7 @@ struct Inner {
original_url: Url,
owner_scope: Option<crate::native_bridge::OwnerDispatchScope>,
state: Mutex<State>,
violation_reporter: Option<Arc<dyn Fn(ContentSecurityPolicyUrlViolation) + Send + Sync>>,
}
#[derive(Default)]
@@ -72,9 +73,21 @@ impl ModuleFetchCspContext {
original_url,
owner_scope,
state: Mutex::new(State::default()),
violation_reporter: None,
}))
}
/// Install the networking report route before sharing this fetch context.
pub(crate) fn with_violation_reporter(
mut self,
reporter: impl Fn(ContentSecurityPolicyUrlViolation) + Send + Sync + 'static,
) -> Self {
Arc::get_mut(&mut self.0)
.expect("module reporting route is bound before fetch context sharing")
.violation_reporter = Some(Arc::new(reporter));
self
}
pub(crate) fn owner_scope(&self) -> Option<crate::native_bridge::OwnerDispatchScope> {
self.0.owner_scope
}
@@ -119,8 +132,15 @@ impl ModuleFetchCspContext {
.any(|(n, checked)| *n == ordinal && checked == url)
{
state.checked_hops.push((ordinal, url.clone()));
state.violations.extend(report);
state.violations.extend(enforce);
if let Some(reporter) = &self.0.violation_reporter {
drop(state);
for violation in report.into_iter().chain(enforce) {
reporter(violation);
}
} else {
state.violations.extend(report);
state.violations.extend(enforce);
}
}
match message {
Some(message) => anyhow::bail!(message),
+18 -16
View File
@@ -94,7 +94,24 @@ pub(super) struct WorkerModuleGraphFetchCompletion {
key: WorkerModuleKey,
fetch_id: WorkerModuleGraphFetchId,
result: Result<WorkerModuleFetchedSource, module_tree::ModuleLoadError>,
csp_violations: Vec<ContentSecurityPolicyUrlViolation>,
}
/// Module CSP reports are independent networking tasks and can arrive before a response.
pub(super) enum WorkerModuleGraphFetchEvent {
CspViolation(Box<ContentSecurityPolicyUrlViolation>),
Complete(Box<WorkerModuleGraphFetchCompletion>),
}
impl WorkerModuleGraphFetchEvent {
pub(super) fn completed(
fetch_id: WorkerModuleGraphFetchId,
key: WorkerModuleKey,
result: Result<WorkerModuleFetchedSource, String>,
) -> Self {
Self::Complete(Box::new(WorkerModuleGraphFetchCompletion::new(
fetch_id, key, result,
)))
}
}
pub(super) struct WorkerModuleFetchedSource {
@@ -235,7 +252,6 @@ impl WorkerModuleGraphFetchCompletion {
key,
fetch_id,
result,
csp_violations: Vec::new(),
}
}
@@ -243,20 +259,6 @@ impl WorkerModuleGraphFetchCompletion {
self.fetch_id
}
pub(super) fn with_csp_violations(
mut self,
violations: Vec<ContentSecurityPolicyUrlViolation>,
) -> Self {
self.csp_violations = violations;
self
}
pub(super) fn csp_violations(
&self,
) -> impl Iterator<Item = &ContentSecurityPolicyUrlViolation> {
self.csp_violations.iter()
}
pub(super) fn result(
&self,
) -> Result<&WorkerModuleFetchedSource, &module_tree::ModuleLoadError> {
+77 -57
View File
@@ -107,8 +107,8 @@ use super::inspector_task_runner::WorkerInspectorTaskRunner;
use super::inspector_task_runner::{WorkerInspectorTask, WorkerInspectorTaskMode};
use super::module_runtime::{
WorkerBootstrapError, WorkerModuleBootstrapResume, WorkerModuleBootstrapStart,
WorkerModuleEvaluationCompletion, WorkerModuleFetchedSource, WorkerModuleGraphFetchCompletion,
WorkerModuleGraphFetchCspSource, WorkerModuleGraphFetchRequest, WorkerModulePendingBootstrap,
WorkerModuleEvaluationCompletion, WorkerModuleFetchedSource, WorkerModuleGraphFetchCspSource,
WorkerModuleGraphFetchEvent, WorkerModuleGraphFetchRequest, WorkerModulePendingBootstrap,
WorkerModuleSource, complete_worker_module_graph_fetch,
evaluate_module_worker_bootstrap_source, install_classic_worker_dynamic_module_runtime,
resume_worker_dynamic_module_evaluation, resume_worker_module_trees,
@@ -692,7 +692,7 @@ fn start_worker_module_graph_fetch(
network_partition_key: Option<String>,
module_static_import_content_security_policies: Vec<ContentSecurityPolicy>,
worker_global_policy: crate::content_security_policy::InheritedContentSecurityPolicy,
completion_tx: mpsc::UnboundedSender<WorkerModuleGraphFetchCompletion>,
completion_tx: mpsc::UnboundedSender<WorkerModuleGraphFetchEvent>,
) {
// Bootstrap module graphs use outside settings, including data: workers.
// Later dynamic imports belong to the Worker's own execution origin.
@@ -721,6 +721,7 @@ fn start_worker_module_graph_fetch(
let resource_kind = request.module_type().csp_resource_kind(resource_kind);
let initiator = request.initiator_url().clone();
let source_location = request.source_location().cloned();
let csp_events = completion_tx.clone();
let csp_context = crate::content_security_policy::ModuleFetchCspContext::new(
request.url().clone(),
None,
@@ -743,16 +744,15 @@ fn start_worker_module_graph_fetch(
check(ContentSecurityPolicyDisposition::Enforce),
)
},
);
).with_violation_reporter(move |violation| {
let _ = csp_events.send(WorkerModuleGraphFetchEvent::CspViolation(Box::new(violation)));
});
if let Err(error) = csp_context.check_initial_request(request.url()) {
let _ = completion_tx.send(
WorkerModuleGraphFetchCompletion::new(
fetch_id,
request.module_key(),
Err(error.to_string()),
)
.with_csp_violations(csp_context.take_violations()),
);
let _ = completion_tx.send(WorkerModuleGraphFetchEvent::completed(
fetch_id,
request.module_key(),
Err(error.to_string()),
));
return;
}
let browser_request_metadata = match request.browser_request_metadata() {
@@ -766,14 +766,11 @@ fn start_worker_module_graph_fetch(
.with_network_partition_key(network_partition_key)
.with_browser_request_metadata(browser_request_metadata),
Err(error) => {
let _ = completion_tx.send(
WorkerModuleGraphFetchCompletion::new(
fetch_id,
request.module_key(),
Err(error.to_string()),
)
.with_csp_violations(csp_context.take_violations()),
);
let _ = completion_tx.send(WorkerModuleGraphFetchEvent::completed(
fetch_id,
request.module_key(),
Err(error.to_string()),
));
return;
}
};
@@ -844,8 +841,7 @@ fn start_worker_module_graph_fetch(
.with_resource(resource)
.with_response_referrer_policy(response_referrer_policy))
});
let completion = WorkerModuleGraphFetchCompletion::new(fetch_id, completion_key, result)
.with_csp_violations(response_csp_context.take_violations());
let completion = WorkerModuleGraphFetchEvent::completed(fetch_id, completion_key, result);
let _ = completion_tx_for_callback.send(completion);
};
let Some(load) = loader.register_load(
@@ -853,30 +849,46 @@ fn start_worker_module_graph_fetch(
ResourceLoadDisposition::Ordinary,
None,
) else {
let _ = completion_tx.send(
WorkerModuleGraphFetchCompletion::new(
fetch_id,
request.module_key(),
Err("worker module dependency fetch rejected during shutdown".to_owned()),
)
.with_csp_violations(csp_context.take_violations()),
);
let _ = completion_tx.send(WorkerModuleGraphFetchEvent::completed(
fetch_id,
request.module_key(),
Err("worker module dependency fetch rejected during shutdown".to_owned()),
));
return;
};
if let Err(error) = loader
.request_client()
.fetch_cacheable_script_text_callback_with_load(fetch_request, load, send_completion)
{
let _ = completion_tx.send(
WorkerModuleGraphFetchCompletion::new(
fetch_id,
request.module_key(),
Err(format!(
"failed to start module worker dependency fetch `{}`: {error}",
request.url()
)),
)
.with_csp_violations(csp_context.take_violations()),
let _ = completion_tx.send(WorkerModuleGraphFetchEvent::completed(
fetch_id,
request.module_key(),
Err(format!(
"failed to start module worker dependency fetch `{}`: {error}",
request.url()
)),
));
}
}
fn start_worker_module_graph_fetch_batch(
requests: WorkerModuleGraphFetchBatch,
state: &Rc<RefCell<WorkerGlobalState>>,
module_graph_fetch_tx: &mpsc::UnboundedSender<WorkerModuleGraphFetchEvent>,
) {
for request in requests.iter().cloned() {
start_worker_module_graph_fetch(
request,
state.borrow().loader.clone(),
state.borrow().network_partition_key.clone(),
state
.borrow()
.module_static_import_content_security_policies
.clone(),
state
.borrow()
.content_security_policy_snapshot_for_inheritance(),
module_graph_fetch_tx.clone(),
);
}
}
@@ -934,7 +946,7 @@ fn worker_has_pending_indexed_db_tasks(
fn flush_one_worker_indexed_db_task(
scope: &mut v8::PinScope<'_, '_>,
state: &Rc<RefCell<WorkerGlobalState>>,
module_graph_fetch_tx: &mpsc::UnboundedSender<WorkerModuleGraphFetchCompletion>,
module_graph_fetch_tx: &mpsc::UnboundedSender<WorkerModuleGraphFetchEvent>,
) {
let flushed = crate::context_bootstrap::flush_next_indexed_db_task(scope);
if !flushed {
@@ -947,7 +959,7 @@ fn flush_one_worker_indexed_db_task(
fn flush_worker_module_fetches(
scope: &mut v8::PinScope<'_, '_>,
state: &Rc<RefCell<WorkerGlobalState>>,
module_graph_fetch_tx: &mpsc::UnboundedSender<WorkerModuleGraphFetchCompletion>,
module_graph_fetch_tx: &mpsc::UnboundedSender<WorkerModuleGraphFetchEvent>,
) {
for request in take_worker_module_graph_fetches(scope) {
start_worker_module_graph_fetch(
@@ -980,7 +992,7 @@ use crate::worker::script_loading::report_service_worker_script_resource as repo
fn drain_worker_dynamic_module_imports(
scope: &mut v8::PinScope<'_, '_>,
state: &Rc<RefCell<WorkerGlobalState>>,
module_graph_fetch_tx: &mpsc::UnboundedSender<WorkerModuleGraphFetchCompletion>,
module_graph_fetch_tx: &mpsc::UnboundedSender<WorkerModuleGraphFetchEvent>,
) {
const MAX_DYNAMIC_IMPORT_DRAIN_STEPS: usize = 1_000;
for _ in 0..MAX_DYNAMIC_IMPORT_DRAIN_STEPS {
@@ -995,7 +1007,7 @@ fn drain_worker_dynamic_module_imports_for_context(
isolate: &mut v8::OwnedIsolate,
context: &v8::Global<v8::Context>,
state: &Rc<RefCell<WorkerGlobalState>>,
module_graph_fetch_tx: &mpsc::UnboundedSender<WorkerModuleGraphFetchCompletion>,
module_graph_fetch_tx: &mpsc::UnboundedSender<WorkerModuleGraphFetchEvent>,
) {
let scope = pin!(v8::HandleScope::new(isolate));
let scope = &mut scope.init();
@@ -1010,7 +1022,7 @@ fn dispatch_worker_inspector_task(
context: &v8::Global<v8::Context>,
task: WorkerInspectorTask,
state: &Rc<RefCell<WorkerGlobalState>>,
module_graph_fetch_tx: &mpsc::UnboundedSender<WorkerModuleGraphFetchCompletion>,
module_graph_fetch_tx: &mpsc::UnboundedSender<WorkerModuleGraphFetchEvent>,
) {
let (isolate, inspector) = worker_isolate.worker_isolate_and_runtime_inspector();
inspector.execute_task(isolate, task);
@@ -1026,9 +1038,7 @@ async fn run_worker_pre_bootstrap_debugger_pause(
worker_isolate: &mut WorkerIsolateState,
#[cfg(feature = "devtools")] context: &v8::Global<v8::Context>,
state: &Rc<RefCell<WorkerGlobalState>>,
#[cfg(feature = "devtools")] module_graph_fetch_tx: &mpsc::UnboundedSender<
WorkerModuleGraphFetchCompletion,
>,
#[cfg(feature = "devtools")] module_graph_fetch_tx: &mpsc::UnboundedSender<WorkerModuleGraphFetchEvent>,
script_url: &str,
rx: &mut mpsc::UnboundedReceiver<WorkerMessage>,
pending_bootstrap_messages: &mut VecDeque<WorkerMessage>,
@@ -1754,7 +1764,7 @@ async fn worker_main(
mpsc::unbounded_channel::<WorkerFetchEvent>();
let (xhr_completion_tx, mut xhr_completion_rx) = mpsc::unbounded_channel::<WorkerXhrEvent>();
let (module_graph_fetch_tx, mut module_graph_fetch_rx) =
mpsc::unbounded_channel::<WorkerModuleGraphFetchCompletion>();
mpsc::unbounded_channel::<WorkerModuleGraphFetchEvent>();
let (module_evaluation_tx, mut module_evaluation_rx) =
mpsc::unbounded_channel::<WorkerModuleEvaluationCompletion>();
let (websocket_event_tx, mut websocket_events) = WorkerWebSocketEvents::new();
@@ -2156,7 +2166,7 @@ async fn worker_main(
Message(Option<WorkerMessage>),
Fetch(Option<WorkerFetchEvent>),
Xhr(Option<WorkerXhrEvent>),
ModuleGraphFetch(Option<Box<WorkerModuleGraphFetchCompletion>>),
ModuleGraphFetch(Option<WorkerModuleGraphFetchEvent>),
ModuleEvaluation(Option<WorkerModuleEvaluationCompletion>),
ModuleRuntime,
IndexedDb,
@@ -2179,7 +2189,7 @@ async fn worker_main(
msg = rx.recv() => WorkerLoopWake::Message(msg),
completion = fetch_completion_rx.recv() => WorkerLoopWake::Fetch(completion),
completion = xhr_completion_rx.recv() => WorkerLoopWake::Xhr(completion),
completion = module_graph_fetch_rx.recv() => WorkerLoopWake::ModuleGraphFetch(completion.map(Box::new)),
completion = module_graph_fetch_rx.recv() => WorkerLoopWake::ModuleGraphFetch(completion),
completion = module_evaluation_rx.recv() => WorkerLoopWake::ModuleEvaluation(completion),
wake = worker_runtime_wake_rx.recv() => WorkerLoopWake::RuntimeWake(wake),
event = websocket_events.recv() => WorkerLoopWake::WebSocket(event),
@@ -2194,7 +2204,7 @@ async fn worker_main(
msg = rx.recv() => WorkerLoopWake::Message(msg),
completion = fetch_completion_rx.recv() => WorkerLoopWake::Fetch(completion),
completion = xhr_completion_rx.recv() => WorkerLoopWake::Xhr(completion),
completion = module_graph_fetch_rx.recv() => WorkerLoopWake::ModuleGraphFetch(completion.map(Box::new)),
completion = module_graph_fetch_rx.recv() => WorkerLoopWake::ModuleGraphFetch(completion),
completion = module_evaluation_rx.recv() => WorkerLoopWake::ModuleEvaluation(completion),
wake = worker_runtime_wake_rx.recv() => WorkerLoopWake::RuntimeWake(wake),
event = websocket_events.recv() => WorkerLoopWake::WebSocket(event),
@@ -3262,7 +3272,21 @@ async fn worker_main(
WorkerLoopWake::Opfs(None) => {
// OPFS sender dropped, but other work may still be pending.
}
WorkerLoopWake::ModuleGraphFetch(Some(completion)) => {
WorkerLoopWake::ModuleGraphFetch(Some(WorkerModuleGraphFetchEvent::CspViolation(
violation,
))) => {
let scope = pin!(v8::HandleScope::new(worker_isolate.worker_isolate_mut()));
let scope = &mut scope.init();
let ctx = v8::Local::new(scope, &context);
let scope = &mut v8::ContextScope::new(scope, ctx);
let loader = state.borrow().loader.clone();
dispatch_worker_csp_violation_event(scope, &loader, &violation);
perform_worker_microtask_checkpoint_and_report_pending_promise_rejections(scope);
drain_worker_dynamic_module_imports(scope, &state, &module_graph_fetch_tx);
}
WorkerLoopWake::ModuleGraphFetch(Some(WorkerModuleGraphFetchEvent::Complete(
completion,
))) => {
let (isolate, runtime_inspector) =
worker_isolate.worker_isolate_and_runtime_inspector();
let scope = pin!(v8::HandleScope::new(isolate));
@@ -3271,10 +3295,6 @@ async fn worker_main(
let scope = &mut v8::ContextScope::new(scope, ctx);
let global = ctx.global(scope);
if let Some(outcome) = complete_worker_module_graph_fetch(scope, &completion) {
for violation in completion.csp_violations() {
let loader = state.borrow().loader.clone();
dispatch_worker_csp_violation_event(scope, &loader, violation);
}
let resume =
resume_worker_module_trees(scope, pending_module_bootstrap.as_deref_mut());
flush_worker_module_fetches(scope, &state, &module_graph_fetch_tx);
@@ -101,7 +101,7 @@ addEventListener('securitypolicyviolation', event => events.push({
.replace("REQUESTS", &requests.to_string())
}
async fn result(mut worker: WorkerTestHandle) -> Value {
async fn console_result(worker: &mut WorkerTestHandle) -> Value {
let text = timeout(TIMEOUT, async {
loop {
match worker
@@ -119,10 +119,228 @@ async fn result(mut worker: WorkerTestHandle) -> Value {
})
.await
.expect("module imports must settle");
worker.terminate_and_join();
serde_json::from_str(text.strip_prefix("log: ").expect(&text)).unwrap()
}
async fn result(mut worker: WorkerTestHandle) -> Value {
let result = console_result(&mut worker).await;
worker.terminate_and_join();
result
}
struct ParkedModuleResponse {
url: String,
request_rx: oneshot::Receiver<String>,
release_tx: oneshot::Sender<()>,
server: JoinHandle<()>,
}
async fn parked_module_response(kind: &str) -> ParkedModuleResponse {
let listener = TcpListener::bind("127.0.0.1:0").await.unwrap();
let url = format!("http://{}", listener.local_addr().unwrap());
let (request_tx, request_rx) = oneshot::channel();
let (release_tx, release_rx) = oneshot::channel();
let (mime, body) = match kind {
"json" => ("application/json", r#"{"answer":42}"#),
"text" => ("text/plain", "module-text"),
"javascript" => ("text/javascript", "export default 42;"),
_ => unreachable!(),
};
let server = tokio::spawn(async move {
let (mut stream, _) = listener.accept().await.unwrap();
let request = read_http_request_head(&mut stream).await.unwrap();
request_tx.send(request).unwrap();
release_rx.await.unwrap();
let response = format!(
"HTTP/1.1 200 OK\r\nContent-Type: {mime}\r\nAccess-Control-Allow-Origin: *\r\nContent-Length: {}\r\nConnection: close\r\n\r\n{body}",
body.len(),
);
stream.write_all(response.as_bytes()).await.unwrap();
});
ParkedModuleResponse {
url,
request_rx,
release_tx,
server,
}
}
fn pending_response_probe(url: &str, kind: &str, expected_violations: usize) -> String {
r#"
let returned = false;
let callerMicrotask = false;
let settled = false;
const events = [];
queueMicrotask(() => callerMicrotask = true);
addEventListener('securitypolicyviolation', event => {
events.push({directive: event.effectiveDirective, disposition: event.disposition,
native: event instanceof SecurityPolicyViolationEvent, trusted: event.isTrusted,
sourceFile: event.sourceFile, line: event.lineNumber, column: event.columnNumber});
if (events.length === COUNT) {
console.log(JSON.stringify({stage: 'violations', returned, callerMicrotask, settled, events}));
}
});
const pending = KIND === 'javascript' ? import(URL) : import(URL, {with: {type: KIND}});
returned = true;
pending.then(module => {
settled = true;
console.log(JSON.stringify({stage: 'settled', value: KIND === 'json' ? module.default.answer : module.default, events: events.length}));
}, error => console.error(String(error.stack || error)));
"#
.replace("COUNT", &expected_violations.to_string())
.replace("KIND", &serde_json::to_string(kind).unwrap())
.replace("URL", &serde_json::to_string(url).unwrap())
}
#[tokio::test]
async fn worker_module_csp_initial_reports_do_not_wait_for_response() {
ensure_v8();
for script_kind in [WorkerScriptKind::Classic, WorkerScriptKind::Module] {
for global in global_kinds() {
for kind in ["json", "text", "javascript"] {
let parked = parked_module_response(kind).await;
let import_url = format!("{}/module", parked.url);
let worker_url = format!("{}/worker.js", parked.url);
let mut worker = spawn_test_worker_with_options(
WorkerSpawnOptions::new(
pending_response_probe(&import_url, kind, 2),
worker_url.clone(),
)
.with_global_kind(global.clone())
.with_script_kind(script_kind)
.with_content_security_report_only_policies(vec![
"default-src 'none'".into(),
if kind == "javascript" {
"script-src 'none'"
} else {
"connect-src 'none'"
}
.into(),
]),
);
timeout(TIMEOUT, parked.request_rx).await.unwrap().unwrap();
let report = console_result(&mut worker).await;
assert_eq!(report["stage"], "violations", "{report}");
assert_eq!(report["returned"], true);
assert_eq!(report["callerMicrotask"], true);
assert_eq!(report["settled"], false);
for event in report["events"].as_array().unwrap() {
assert_eq!(event["disposition"], "report");
assert_eq!(
event["directive"],
if kind == "javascript" {
"script-src-elem"
} else {
"connect-src"
}
);
assert_eq!(event["native"], true);
assert_eq!(event["trusted"], true);
assert_eq!(event["sourceFile"], worker_url);
assert!(event["line"].as_i64().unwrap() > 0);
assert!(event["column"].as_i64().unwrap() > 0);
}
parked.release_tx.send(()).unwrap();
assert_eq!(
result(worker).await,
json!({
"stage": "settled", "value": if kind == "text" { json!("module-text") } else { json!(42) }, "events": 2
})
);
timeout(TIMEOUT, parked.server).await.unwrap().unwrap();
}
}
}
}
#[tokio::test]
async fn worker_module_csp_redirect_reports_do_not_wait_for_response() {
ensure_v8();
for script_kind in [WorkerScriptKind::Classic, WorkerScriptKind::Module] {
for global in global_kinds() {
for kind in ["json", "text", "javascript"] {
let parked = parked_module_response(kind).await;
let target_url = format!("{}/module", parked.url);
let source = ModuleServer::spawn(move |_| format!(
"HTTP/1.1 302 Found\r\nLocation: {target_url}\r\nContent-Length: 0\r\nConnection: close\r\n\r\n"
)).await;
let mut worker = spawn_test_worker_with_options(
WorkerSpawnOptions::new(
pending_response_probe(&format!("{}/redirect", source.url), kind, 1),
format!("{}/worker.js", source.url),
)
.with_global_kind(global.clone())
.with_script_kind(script_kind)
.with_content_security_report_only_policies(vec![
if kind == "javascript" {
"script-src 'self'"
} else {
"connect-src 'self'"
}
.into(),
]),
);
timeout(TIMEOUT, parked.request_rx).await.unwrap().unwrap();
let report = console_result(&mut worker).await;
assert_eq!(report["stage"], "violations", "{report}");
assert_eq!(report["returned"], true);
assert_eq!(report["settled"], false);
assert_eq!(report["events"][0]["sourceFile"], "");
assert_eq!(report["events"][0]["line"], 0);
assert_eq!(report["events"][0]["column"], 0);
parked.release_tx.send(()).unwrap();
assert_eq!(
result(worker).await,
json!({
"stage": "settled", "value": if kind == "text" { json!("module-text") } else { json!(42) }, "events": 1
})
);
timeout(TIMEOUT, parked.server).await.unwrap().unwrap();
assert_eq!(source.requests.lock().len(), 1);
}
}
}
}
#[tokio::test]
async fn worker_module_csp_tasks_checkpoint_microtasks_before_import_rejection() {
ensure_v8();
let server = ModuleServer::modules().await;
for script_kind in [WorkerScriptKind::Classic, WorkerScriptKind::Module] {
for global in global_kinds() {
let source = r#"
const order = [];
addEventListener('securitypolicyviolation', event => {
order.push(event.disposition);
queueMicrotask(() => order.push(event.disposition + '-microtask'));
});
queueMicrotask(() => order.push('caller-microtask'));
const pending = import('./data.json', {with: {type: 'json'}});
order.push('returned');
pending.catch(error => {
order.push('rejected');
console.log(JSON.stringify({order, name: error.name, native: error instanceof TypeError}));
});
"#;
let worker = spawn_test_worker_with_options(
WorkerSpawnOptions::new(source.into(), format!("{}/worker.js", server.url))
.with_global_kind(global)
.with_script_kind(script_kind)
.with_content_security_policies(vec!["connect-src 'none'".into()])
.with_content_security_report_only_policies(vec!["connect-src 'none'".into()]),
);
assert_eq!(
result(worker).await,
json!({
"order": ["returned", "caller-microtask", "report", "report-microtask", "enforce", "enforce-microtask", "rejected"],
"name": "TypeError", "native": true,
})
);
}
}
assert!(server.requests.lock().is_empty());
}
#[tokio::test]
async fn worker_typed_module_csp_blocks_before_contact_and_reports_every_policy() {
ensure_v8();