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::content_security_policy::ContentSecurityPolicy;
use moli_fetch::{FetchCancelHandle, Request, RequestCredentialsMode, ScriptFetchRequestMetadata};
use moli_shared_worker::{
SharedWorkerClientOwnerId, SharedWorkerCredentialsMode, SharedWorkerDescriptor,
SharedWorkerKey, SharedWorkerSameSiteCookies, SharedWorkerScriptType,
};
use url::Url;
use crate::{
content_security_policy::{
ContentSecurityPolicyReportingEndpoints, ContentSecurityPolicyResourceKind,
ensure_content_security_policy_allows_url,
},
context_bootstrap::{SharedStorageBucketStore, WeakIndexedDbManager},
network::ResourceRequestClient,
page_task_queue::{
RendererPageSharedWorkerClientEventRealmSender, RendererWorkerHostBridgeEventSender,
},
protocol_types::NavigationResponse,
referrer_policy::response_referrer_policy_from_headers,
runtime::RendererWorkerContextRuntime,
service_worker_runtime::{
ServiceWorkerClientId, ServiceWorkerClientType, ServiceWorkerRequestDestination,
ServiceWorkerRuntimeService,
},
types::{MessagePortId, SubresourcePolicyContext},
worker::{WorkerNetworkPolicy, WorkerScriptKind},
};
#[derive(Clone, Debug)]
pub(crate) struct SharedWorkerScriptLoad {
kind: SharedWorkerScriptLoadKind,
}
#[derive(Clone, Debug, Eq, PartialEq)]
pub(super) struct SharedWorkerLoadedScript {
pub(super) script_url: String,
pub(super) source: String,
pub(super) response_referrer_policy: Option<String>,
pub(super) response_policy_context: Option<SubresourcePolicyContext>,
pub(super) response_content_security_policies: Vec<ContentSecurityPolicy>,
pub(super) response_content_security_report_only_policies: Vec<ContentSecurityPolicy>,
pub(super) response_content_security_reporting_endpoints:
ContentSecurityPolicyReportingEndpoints,
}
#[derive(Clone, Debug)]
pub(super) enum SharedWorkerScriptLoadKind {
Ready(SharedWorkerLoadedScript),
Blob { script_url: Url },
Fetch(Box<SharedWorkerScriptFetch>),
Failure { message: String },
}
#[derive(Clone, Debug)]
pub(super) struct SharedWorkerScriptFetch {
pub(super) request_client: ResourceRequestClient,
pub(super) task_runner: crate::network::RendererResourceTaskRunner,
pub(super) script_url: Url,
pub(super) initiator_url: Url,
pub(super) request_policy: SharedWorkerScriptRequestPolicy,
}
#[derive(Clone)]
pub(crate) struct SharedWorkerLaunchParams {
pub(super) key: SharedWorkerKey,
pub(super) script_load: SharedWorkerScriptLoad,
pub(super) launch_context: SharedWorkerLaunchContext,
pub(super) client_port_id: MessagePortId,
pub(super) worker_port_id: MessagePortId,
pub(super) client_owner_id: SharedWorkerClientOwnerId,
pub(super) client_event_realm: RendererPageSharedWorkerClientEventRealmSender,
pub(super) worker_host_bridge_sender: RendererWorkerHostBridgeEventSender,
pub(super) parent_service_worker_client_id: Option<ServiceWorkerClientId>,
pub(super) reserved_service_worker_client_id: Option<ServiceWorkerClientId>,
}
#[derive(Clone)]
pub(crate) struct SharedWorkerLaunchContext {
pub(super) name: String,
pub(super) request_client: ResourceRequestClient,
pub(super) execution_policy: SharedWorkerExecutionPolicy,
}
#[derive(Clone)]
pub(crate) struct SharedWorkerExecutionPolicy {
pub(super) script_kind: WorkerScriptKind,
pub(super) module_static_import_initiator_url: Url,
pub(super) module_static_import_content_security_policies: Vec<ContentSecurityPolicy>,
pub(super) network_policy: WorkerNetworkPolicy,
pub(super) policy_context: SubresourcePolicyContext,
pub(super) worker_context_runtime: RendererWorkerContextRuntime,
pub(super) service_worker_runtime: Option<ServiceWorkerRuntimeService>,
pub(super) indexed_db_manager: Option<WeakIndexedDbManager>,
pub(super) storage_bucket_store: Option<SharedStorageBucketStore>,
pub(super) storage_key_top_level_site: Option<String>,
pub(super) module_credentials_mode: RequestCredentialsMode,
}
#[derive(Clone, Debug, Eq, PartialEq)]
pub(crate) struct SharedWorkerScriptRequestPolicy {
pub(super) credentials_mode: RequestCredentialsMode,
pub(super) same_site_cookies: SharedWorkerSameSiteCookies,
pub(super) document_referrer_policy: Option<String>,
pub(super) network_partition_key: Option<String>,
pub(super) document_content_security_policies: Vec<ContentSecurityPolicy>,
}
impl SharedWorkerLaunchParams {
pub(crate) fn new(
key: SharedWorkerKey,
script_load: SharedWorkerScriptLoad,
launch_context: SharedWorkerLaunchContext,
client_port_id: MessagePortId,
worker_port_id: MessagePortId,
client_owner_id: SharedWorkerClientOwnerId,
parent_service_worker_client_id: Option<ServiceWorkerClientId>,
client_event_realm: RendererPageSharedWorkerClientEventRealmSender,
worker_host_bridge_sender: RendererWorkerHostBridgeEventSender,
) -> Self {
Self {
key,
script_load,
launch_context,
client_port_id,
worker_port_id,
client_owner_id,
client_event_realm,
worker_host_bridge_sender,
parent_service_worker_client_id,
reserved_service_worker_client_id: None,
}
}
pub(super) fn reserve_service_worker_worker_client_for_main_script(&mut self) {
if self.reserved_service_worker_client_id.is_some()
|| !self.script_load.can_reserve_service_worker_worker_client()
{
return;
}
let Some(service_worker_runtime) = self
.launch_context
.execution_policy
.service_worker_runtime
.as_ref()
else {
return;
};
let Ok(script_url) = Url::parse(self.key.script_url()) else {
return;
};
let secure_context = self
.launch_context
.execution_policy
.network_policy
.secure_context;
let storage_key = self.key.storage_key().serialized_storage_key();
let client_id = if matches!(script_url.scheme(), "http" | "https") {
Some(
service_worker_runtime.register_reserved_worker_client_with_storage_key(
script_url,
storage_key,
ServiceWorkerClientType::SharedWorker,
secure_context,
),
)
} else if script_url.scheme() == "blob" {
let Some(parent_client_id) = self.parent_service_worker_client_id else {
return;
};
service_worker_runtime
.register_reserved_worker_client_inheriting_controller_from_client(
script_url,
storage_key,
ServiceWorkerClientType::SharedWorker,
secure_context,
parent_client_id,
)
} else {
None
};
let Some(client_id) = client_id else {
return;
};
self.reserved_service_worker_client_id = Some(client_id);
}
pub(super) fn unregister_reserved_service_worker_client(&mut self) {
let Some(client_id) = self.reserved_service_worker_client_id.take() else {
return;
};
if let Some(service_worker_runtime) = self
.launch_context
.execution_policy
.service_worker_runtime
.as_ref()
{
service_worker_runtime.unregister_client(client_id);
}
}
}
impl SharedWorkerLaunchContext {
pub(crate) fn new(
name: String,
request_client: ResourceRequestClient,
execution_policy: SharedWorkerExecutionPolicy,
) -> Self {
Self {
name,
request_client,
execution_policy,
}
}
}
impl SharedWorkerExecutionPolicy {
pub(crate) fn new(
script_kind: WorkerScriptKind,
module_static_import_initiator_url: Url,
module_static_import_content_security_policies: Vec<ContentSecurityPolicy>,
network_policy: WorkerNetworkPolicy,
policy_context: SubresourcePolicyContext,
worker_context_runtime: RendererWorkerContextRuntime,
storage_key_top_level_site: Option<String>,
module_credentials_mode: RequestCredentialsMode,
) -> Self {
Self {
script_kind,
module_static_import_initiator_url,
module_static_import_content_security_policies,
network_policy,
policy_context,
worker_context_runtime,
service_worker_runtime: None,
indexed_db_manager: None,
storage_bucket_store: None,
storage_key_top_level_site,
module_credentials_mode,
}
}
pub(crate) fn with_service_worker_runtime(
mut self,
runtime: ServiceWorkerRuntimeService,
) -> Self {
self.service_worker_runtime = Some(runtime);
self
}
pub(crate) fn with_storage_bucket_store(mut self, store: SharedStorageBucketStore) -> Self {
self.storage_bucket_store = Some(store);
self
}
pub(crate) fn with_indexed_db_manager(mut self, manager: Option<WeakIndexedDbManager>) -> Self {
self.indexed_db_manager = manager;
self
}
}
impl SharedWorkerScriptRequestPolicy {
pub(crate) fn from_descriptor(
descriptor: &SharedWorkerDescriptor,
same_site_cookies: SharedWorkerSameSiteCookies,
document_referrer_policy: Option<String>,
network_partition_key: Option<String>,
document_content_security_policies: Vec<ContentSecurityPolicy>,
) -> Self {
Self {
credentials_mode: shared_worker_script_credentials_mode(descriptor),
same_site_cookies,
document_referrer_policy,
network_partition_key,
document_content_security_policies,
}
}
pub(crate) fn credentials_mode(&self) -> RequestCredentialsMode {
self.credentials_mode
}
pub(crate) fn ensure_allows_script_url(
&self,
document_url: &Url,
script_url: &Url,
) -> Result<(), String> {
ensure_content_security_policy_allows_url(
&self.document_content_security_policies,
document_url,
script_url,
ContentSecurityPolicyResourceKind::SharedWorkerScript,
|| {
format!(
"Failed to load shared worker script `{script_url}`: blocked by Content Security Policy."
)
},
)
}
}
impl SharedWorkerLoadedScript {
pub(super) fn new(script_url: String, source: String) -> Self {
Self {
script_url,
source,
response_referrer_policy: None,
response_policy_context: None,
response_content_security_policies: Vec::new(),
response_content_security_report_only_policies: Vec::new(),
response_content_security_reporting_endpoints:
ContentSecurityPolicyReportingEndpoints::default(),
}
}
pub(super) fn with_response_referrer_policy(
mut self,
response_referrer_policy: Option<String>,
) -> Self {
self.response_referrer_policy = response_referrer_policy;
self
}
pub(super) fn with_response_policy_context(
mut self,
response_policy_context: SubresourcePolicyContext,
) -> Self {
self.response_policy_context = Some(response_policy_context);
self
}
pub(super) fn with_response_content_security_policies(
mut self,
response_content_security_policies: Vec<ContentSecurityPolicy>,
) -> Self {
self.response_content_security_policies = response_content_security_policies;
self
}
pub(super) fn with_response_content_security_report_only_policies(
mut self,
response_content_security_report_only_policies: Vec<ContentSecurityPolicy>,
) -> Self {
self.response_content_security_report_only_policies =
response_content_security_report_only_policies;
self
}
pub(super) fn with_response_content_security_reporting_endpoints(
mut self,
response_content_security_reporting_endpoints: ContentSecurityPolicyReportingEndpoints,
) -> Self {
self.response_content_security_reporting_endpoints =
response_content_security_reporting_endpoints;
self
}
}
impl SharedWorkerScriptLoad {
pub(crate) fn ready(script_url: String, script_source: String) -> Self {
Self {
kind: SharedWorkerScriptLoadKind::Ready(SharedWorkerLoadedScript::new(
script_url,
script_source,
)),
}
}
pub(crate) fn blob(script_url: Url) -> Self {
Self {
kind: SharedWorkerScriptLoadKind::Blob { script_url },
}
}
pub(crate) fn fetch(
request_client: ResourceRequestClient,
task_runner: crate::network::RendererResourceTaskRunner,
script_url: Url,
initiator_url: Url,
request_policy: SharedWorkerScriptRequestPolicy,
) -> Self {
Self {
kind: SharedWorkerScriptLoadKind::Fetch(Box::new(SharedWorkerScriptFetch {
request_client,
task_runner,
script_url,
initiator_url,
request_policy,
})),
}
}
pub(crate) fn failure(message: impl Into<String>) -> Self {
Self {
kind: SharedWorkerScriptLoadKind::Failure {
message: message.into(),
},
}
}
pub(super) fn into_kind(self) -> SharedWorkerScriptLoadKind {
self.kind
}
fn can_reserve_service_worker_worker_client(&self) -> bool {
matches!(
self.kind,
SharedWorkerScriptLoadKind::Blob { .. } | SharedWorkerScriptLoadKind::Fetch(_)
)
}
}
pub(super) async fn fetch_shared_worker_script_source_async(
request_client: &ResourceRequestClient,
resource_task_runner: crate::network::RendererResourceTaskRunner,
script_url: &Url,
initiator_url: &Url,
request_policy: SharedWorkerScriptRequestPolicy,
service_worker_runtime: Option<ServiceWorkerRuntimeService>,
reserved_service_worker_client_id: Option<ServiceWorkerClientId>,
cancel_handle: FetchCancelHandle,
) -> Result<SharedWorkerLoadedScript, String> {
if cancel_handle.is_cancelled() {
return Err("SharedWorker script load canceled.".to_owned());
}
let mut request_url = script_url.clone();
request_url.set_fragment(None);
let request = shared_worker_script_request(&request_url, initiator_url, request_policy)?;
if let (Some(service_worker_runtime), Some(client_id)) = (
service_worker_runtime.as_ref(),
reserved_service_worker_client_id,
) && let Some(response) = service_worker_runtime
.fetch_main_resource_for_worker_client(
client_id,
&request,
request_client,
resource_task_runner,
ServiceWorkerRequestDestination::SharedWorker,
cancel_handle.clone(),
)
.await?
{
return loaded_shared_worker_script_from_navigation_response(
response,
initiator_url,
script_url,
);
}
if cancel_handle.is_cancelled() {
return Err("SharedWorker script load canceled.".to_owned());
}
let response = request_client
.fetch_text_stream_with_cancel(request, cancel_handle)
.await
.map_err(|error| format!("Failed to load shared worker script `{request_url}`: {error}"))?;
loaded_shared_worker_script_from_fetch_response(response, initiator_url, script_url)
}
fn loaded_shared_worker_script_from_fetch_response(
response: moli_fetch::Response,
initiator_url: &Url,
script_url: &Url,
) -> Result<SharedWorkerLoadedScript, String> {
crate::worker::ensure_worker_script_redirect_chain_same_origin(
initiator_url,
&response.redirect_chain,
&response.final_url,
)
.map_err(|message| format!("Failed to load shared worker script `{script_url}`: {message}"))?;
moli_fetch::ensure_http_status_success(response.final_url.as_str(), response.status, false)
.map_err(|error| error.to_string())?;
crate::worker::ensure_worker_script_mime_acceptable(
&response.final_url,
&response.headers,
response.body_bytes(),
)?;
let response_referrer_policy = response_referrer_policy(&response.headers);
let response_policy_context =
worker_policy_context_from_response(&response.final_url, &response.headers);
let response_content_security_policies =
crate::content_security_policy::content_security_policy_headers(&response.headers);
let response_content_security_report_only_policies =
crate::content_security_policy::content_security_policy_report_only_headers(
&response.headers,
);
let response_content_security_reporting_endpoints =
crate::content_security_policy::content_security_policy_reporting_endpoints_from_headers(
&response.headers,
&response.final_url,
);
let (head, body) = response.into_text_parts();
let mut final_url = head.final_url;
final_url.set_fragment(script_url.fragment());
Ok(SharedWorkerLoadedScript::new(final_url.to_string(), body)
.with_response_referrer_policy(response_referrer_policy)
.with_response_policy_context(response_policy_context)
.with_response_content_security_policies(response_content_security_policies)
.with_response_content_security_report_only_policies(
response_content_security_report_only_policies,
)
.with_response_content_security_reporting_endpoints(
response_content_security_reporting_endpoints,
))
}
fn loaded_shared_worker_script_from_navigation_response(
response: NavigationResponse,
initiator_url: &Url,
script_url: &Url,
) -> Result<SharedWorkerLoadedScript, String> {
let (head, body, body_bytes) = response.into_parts();
crate::worker::ensure_worker_script_redirect_chain_same_origin(
initiator_url,
&head.redirect_chain,
&head.final_url,
)
.map_err(|message| {
format!(
"Failed to load shared worker script `{}`: {message}",
head.final_url
)
})?;
moli_fetch::ensure_http_status_success(head.final_url.as_str(), head.status, false)
.map_err(|error| error.to_string())?;
crate::worker::ensure_worker_script_mime_acceptable(
&head.final_url,
&head.headers,
&body_bytes,
)?;
let response_referrer_policy = response_referrer_policy(&head.headers);
let response_policy_context =
worker_policy_context_from_response(&head.final_url, &head.headers);
let response_content_security_policies =
crate::content_security_policy::content_security_policy_headers(&head.headers);
let response_content_security_report_only_policies =
crate::content_security_policy::content_security_policy_report_only_headers(&head.headers);
let response_content_security_reporting_endpoints =
crate::content_security_policy::content_security_policy_reporting_endpoints_from_headers(
&head.headers,
&head.final_url,
);
let mut final_url = head.final_url;
final_url.set_fragment(script_url.fragment());
Ok(SharedWorkerLoadedScript::new(final_url.to_string(), body)
.with_response_referrer_policy(response_referrer_policy)
.with_response_policy_context(response_policy_context)
.with_response_content_security_policies(response_content_security_policies)
.with_response_content_security_report_only_policies(
response_content_security_report_only_policies,
)
.with_response_content_security_reporting_endpoints(
response_content_security_reporting_endpoints,
))
}
fn shared_worker_script_request(
request_url: &Url,
initiator_url: &Url,
request_policy: SharedWorkerScriptRequestPolicy,
) -> Result<Request, String> {
let request = Request::new("GET", request_url.as_str(), None, vec![])
.map_err(|error| error.to_string())
.map(|request| {
request
.with_credentials_mode(request_policy.credentials_mode)
.with_page_network_policy()
.with_initiator_url(initiator_url)
.with_request_origin(moli_url::WebOrigin::from_url(initiator_url))
.with_network_partition_key(request_policy.network_partition_key.clone())
.with_script_fetch_metadata(ScriptFetchRequestMetadata {
document_referrer_policy: request_policy.document_referrer_policy.clone(),
..ScriptFetchRequestMetadata::default()
})
})?;
Ok(match request_policy.same_site_cookies {
SharedWorkerSameSiteCookies::All => request,
SharedWorkerSameSiteCookies::None => request.with_cross_site_cookie_context(),
})
}
pub(super) fn shared_worker_script_credentials_mode(
descriptor: &SharedWorkerDescriptor,
) -> RequestCredentialsMode {
match descriptor.script_type() {
SharedWorkerScriptType::Classic => RequestCredentialsMode::SameOrigin,
SharedWorkerScriptType::Module => match descriptor.credentials_mode() {
SharedWorkerCredentialsMode::Omit => RequestCredentialsMode::Omit,
SharedWorkerCredentialsMode::SameOrigin => RequestCredentialsMode::SameOrigin,
SharedWorkerCredentialsMode::Include => RequestCredentialsMode::Include,
},
}
}
pub(super) fn load_shared_worker_blob_script_source(
script_url: &Url,
) -> Result<SharedWorkerLoadedScript, String> {
let mut resource_url = script_url.clone();
resource_url.set_fragment(None);
crate::blob::object_url_body_and_type(resource_url.as_str())
.map(|(body, _)| SharedWorkerLoadedScript::new(script_url.to_string(), body))
.ok_or_else(|| {
format!("Failed to load shared worker script `{script_url}`: blob URL is unavailable.")
})
}
fn response_referrer_policy(headers: &[(String, Vec<u8>)]) -> Option<String> {
response_referrer_policy_from_headers(headers)
}
fn worker_policy_context_from_response(
final_url: &Url,
headers: &[(String, Vec<u8>)],
) -> SubresourcePolicyContext {
SubresourcePolicyContext {
cross_origin_embedder_policy:
crate::cross_origin_isolation::cross_origin_embedder_policy_from_headers(headers),
document_isolation_policy:
crate::cross_origin_isolation::document_isolation_policy_from_headers(headers),
cross_origin_isolated:
crate::cross_origin_isolation::response_headers_enable_cross_origin_isolation(
final_url, headers,
),
}
}
#[cfg(test)]
mod tests {
use super::*;
fn descriptor(
script_type: SharedWorkerScriptType,
credentials_mode: SharedWorkerCredentialsMode,
) -> SharedWorkerDescriptor {
SharedWorkerDescriptor::new(
script_type,
credentials_mode,
false,
moli_shared_worker::SharedWorkerCreationContextType::Secure,
)
}
#[test]
fn shared_worker_fetch_credentials_mode_tracks_module_options() {
assert_eq!(
shared_worker_script_credentials_mode(&descriptor(
SharedWorkerScriptType::Module,
SharedWorkerCredentialsMode::Omit
)),
RequestCredentialsMode::Omit
);
assert_eq!(
shared_worker_script_credentials_mode(&descriptor(
SharedWorkerScriptType::Module,
SharedWorkerCredentialsMode::SameOrigin
)),
RequestCredentialsMode::SameOrigin
);
assert_eq!(
shared_worker_script_credentials_mode(&descriptor(
SharedWorkerScriptType::Module,
SharedWorkerCredentialsMode::Include
)),
RequestCredentialsMode::Include
);
}
#[test]
fn shared_worker_script_request_applies_module_credentials_option() {
let request_url = Url::parse("https://app.test/worker.js").unwrap();
let initiator = Url::parse("https://app.test/page.html").unwrap();
for (credentials_mode, expected) in [
(
SharedWorkerCredentialsMode::Omit,
RequestCredentialsMode::Omit,
),
(
SharedWorkerCredentialsMode::SameOrigin,
RequestCredentialsMode::SameOrigin,
),
(
SharedWorkerCredentialsMode::Include,
RequestCredentialsMode::Include,
),
] {
let request = shared_worker_script_request(
&request_url,
&initiator,
SharedWorkerScriptRequestPolicy::from_descriptor(
&descriptor(SharedWorkerScriptType::Module, credentials_mode),
SharedWorkerSameSiteCookies::All,
None,
None,
Vec::new(),
),
)
.unwrap();
assert_eq!(request.credentials_mode, expected);
assert!(request.uses_page_network_policy());
}
}
#[test]
fn shared_worker_script_request_same_site_none_forces_cross_site_cookie_context() {
let request_url = Url::parse("https://app.test/worker.js").unwrap();
let initiator = Url::parse("https://app.test/page.html").unwrap();
let request = shared_worker_script_request(
&request_url,
&initiator,
SharedWorkerScriptRequestPolicy::from_descriptor(
&descriptor(
SharedWorkerScriptType::Classic,
SharedWorkerCredentialsMode::SameOrigin,
),
SharedWorkerSameSiteCookies::None,
None,
None,
Vec::new(),
),
)
.unwrap();
assert!(request.cookie_context.site_context.is_cross_site());
}
#[test]
fn classic_shared_worker_fetch_ignores_credentials_option_for_script_request() {
assert_eq!(
shared_worker_script_credentials_mode(&descriptor(
SharedWorkerScriptType::Classic,
SharedWorkerCredentialsMode::Omit
)),
RequestCredentialsMode::SameOrigin
);
assert_eq!(
shared_worker_script_credentials_mode(&descriptor(
SharedWorkerScriptType::Classic,
SharedWorkerCredentialsMode::Include
)),
RequestCredentialsMode::SameOrigin
);
}
#[test]
fn shared_worker_response_policy_context_uses_response_headers() {
let headers: Vec<(String, Vec<u8>)> = vec![
(
"Cross-Origin-Embedder-Policy".to_owned(),
b"require-corp".to_vec(),
),
(
"Document-Isolation-Policy".to_owned(),
b"isolate-and-credentialless".to_vec(),
),
];
let final_url = Url::parse("https://worker.test/shared.js").unwrap();
let policy_context = worker_policy_context_from_response(&final_url, &headers);
assert_eq!(
policy_context.cross_origin_embedder_policy,
crate::cross_origin_isolation::CrossOriginEmbedderPolicy::RequireCorp
);
assert_eq!(
policy_context.document_isolation_policy,
crate::cross_origin_isolation::DocumentIsolationPolicy::IsolateAndCredentialless
);
assert!(policy_context.cross_origin_isolated);
}
#[test]
fn shared_worker_script_request_carries_document_referrer_policy() {
let request_url = Url::parse("https://cdn.test/worker.js").unwrap();
let initiator = Url::parse("https://app.test/page.html").unwrap();
let request = shared_worker_script_request(
&request_url,
&initiator,
SharedWorkerScriptRequestPolicy::from_descriptor(
&descriptor(
SharedWorkerScriptType::Classic,
SharedWorkerCredentialsMode::SameOrigin,
),
SharedWorkerSameSiteCookies::All,
Some("no-referrer".to_owned()),
None,
Vec::new(),
),
)
.unwrap();
assert_eq!(
request
.subresource_request_metadata()
.and_then(|metadata| metadata.document_referrer_policy.as_deref()),
Some("no-referrer")
);
}
#[test]
fn shared_worker_script_request_carries_network_partition_key() {
let request_url = Url::parse("https://cdn.test/worker.js").unwrap();
let initiator = Url::parse("https://app.test/page.html").unwrap();
let request = shared_worker_script_request(
&request_url,
&initiator,
SharedWorkerScriptRequestPolicy::from_descriptor(
&descriptor(
SharedWorkerScriptType::Classic,
SharedWorkerCredentialsMode::SameOrigin,
),
SharedWorkerSameSiteCookies::All,
None,
Some("credentialless-key".to_owned()),
Vec::new(),
),
)
.unwrap();
assert_eq!(request.network_partition_key(), Some("credentialless-key"));
}
#[test]
fn shared_worker_response_referrer_policy_combines_header_instances() {
let headers: Vec<(String, Vec<u8>)> = vec![
("Referrer-Policy".to_owned(), b"no-referrer".to_vec()),
("referrer-policy".to_owned(), b"future-policy".to_vec()),
];
assert_eq!(
response_referrer_policy(&headers),
Some("no-referrer".to_owned())
);
}
#[test]
fn shared_worker_response_referrer_policy_uses_last_valid_token() {
let headers: Vec<(String, Vec<u8>)> = vec![(
"Referrer-Policy".to_owned(),
b"not-yet-standardized, no-referrer".to_vec(),
)];
assert_eq!(
response_referrer_policy(&headers),
Some("no-referrer".to_owned())
);
}
#[test]
fn shared_worker_response_referrer_policy_ignores_invalid_later_header() {
let headers: Vec<(String, Vec<u8>)> = vec![
("Referrer-Policy".to_owned(), b"no-referrer".to_vec()),
(
"Referrer-Policy".to_owned(),
b"not-yet-standardized".to_vec(),
),
];
assert_eq!(
response_referrer_policy(&headers),
Some("no-referrer".to_owned())
);
}
}