Skip to content

armgit / moli

Public Imported from GitHub
0

Best headless browser for AI agents. Lite, Fast, High-Compatibility. Built in Rust

fix(xhr): preserve final MIME types on Blob responses

ldm04b66f751ed4f
diff --git a/moli-content-type/src/tests.rs b/moli-content-type/src/tests.rs
index 38c420b74..4cea9cd3f 100644
--- a/moli-content-type/src/tests.rs
+++ b/moli-content-type/src/tests.rs
@@ -37,6 +37,26 @@ fn whatwg_parser_validates_the_mime_essence() {
assert!(parse_mime_type("text/").is_none());
}
+#[test]
+fn replacing_a_mime_parameter_preserves_order_and_quoted_value_serialization() {
+ let mut mime = parse_mime_type(
+ r#"Text/Plain; title="alpha; \"beta\""; Charset=ASCII; charset=gbk; keep=Value"#,
+ )
+ .unwrap();
+ *mime.parameter_mut("CHARSET").unwrap() = "UTF-8".to_owned();
+ assert_eq!(
+ mime.to_string(),
+ r#"text/plain;title="alpha; \"beta\"";charset=UTF-8;keep=Value"#
+ );
+ assert!(mime.parameter_mut("missing").is_none());
+ mime.set_parameter("BOUNDARY", "A\";B");
+ mime.set_parameter("CHARSET", "GBK");
+ assert_eq!(
+ mime.to_string(),
+ r#"text/plain;title="alpha; \"beta\"";charset=GBK;keep=Value;boundary="A\";B""#
+ );
+}
+
#[test]
fn whatwg_parser_recovers_valid_parameters() {
assert_eq!(
diff --git a/moli-content-type/src/whatwg.rs b/moli-content-type/src/whatwg.rs
index 50dbbcf07..2499101d3 100644
--- a/moli-content-type/src/whatwg.rs
+++ b/moli-content-type/src/whatwg.rs
@@ -36,6 +36,27 @@ impl MimeType {
.find(|(candidate, _)| candidate.eq_ignore_ascii_case(name))
.map(|(_, value)| value.as_str())
}
+
+ /// Mutably borrows the first parameter with the given ASCII-case-insensitive name.
+ pub fn parameter_mut(&mut self, name: &str) -> Option<&mut String> {
+ self.inner
+ .parameters
+ .iter_mut()
+ .find(|(candidate, _)| candidate.eq_ignore_ascii_case(name))
+ .map(|(_, value)| value)
+ }
+
+ /// Sets a parameter without changing its position, or appends it if absent.
+ /// The caller supplies a valid HTTP token name and MIME parameter value.
+ pub fn set_parameter(&mut self, name: &str, value: &str) {
+ if let Some(parameter) = self.parameter_mut(name) {
+ value.clone_into(parameter);
+ } else {
+ self.inner
+ .parameters
+ .push((name.to_ascii_lowercase(), value.to_owned()));
+ }
+ }
}
impl fmt::Display for MimeType {
diff --git a/moli-renderer-v8/src/network_host/xhr/delivery/response.rs b/moli-renderer-v8/src/network_host/xhr/delivery/response.rs
index 3a085bff3..c4202c5b6 100644
--- a/moli-renderer-v8/src/network_host/xhr/delivery/response.rs
+++ b/moli-renderer-v8/src/network_host/xhr/delivery/response.rs
@@ -3,8 +3,8 @@ use super::super::events::{
};
use super::super::*;
use moli_web_mime::{
- effective_response_mime_essence, effective_response_mime_type, is_dom_parser_xml_mime,
- is_html_document_mime, normalize_response_blob_mime_type,
+ effective_response_mime_essence, extract_response_mime_type, is_dom_parser_xml_mime,
+ is_html_document_mime,
};
pub(crate) fn apply_xhr_response(
@@ -572,15 +572,6 @@ fn buffer_value_byte_length(value: v8::Local<'_, v8::Value>) -> Option<usize> {
None
}
-fn xhr_response_mime_value(
- scope: &mut v8::PinScope<'_, '_>,
- xhr: v8::Local<'_, v8::Object>,
- headers: &[(String, String)],
-) -> Option<String> {
- let override_mime = xhr_state_string_property(scope, xhr, XHR_OVERRIDE_MIME_TYPE_SLOT);
- effective_response_mime_type(headers, override_mime.as_deref())
-}
-
fn xhr_response_mime_essence(
scope: &mut v8::PinScope<'_, '_>,
xhr: v8::Local<'_, v8::Object>,
@@ -620,12 +611,17 @@ fn xhr_response_blob_mime_type(
xhr: v8::Local<'_, v8::Object>,
headers: &[(String, String)],
) -> String {
- normalize_response_blob_mime_type(xhr_response_mime_value(scope, xhr, headers).as_deref())
+ // overrideMimeType already stores a parsed and serialized MIME record.
+ // Native response Blobs use that record, not Blob constructor normalization.
+ xhr_state_string_property(scope, xhr, XHR_OVERRIDE_MIME_TYPE_SLOT)
+ .filter(|mime| !mime.is_empty())
+ .or_else(|| extract_response_mime_type(headers).map(|mime| mime.to_string()))
+ .unwrap_or_else(|| "text/xml".to_owned())
}
#[cfg(test)]
mod tests {
- use moli_web_mime::{effective_response_mime_essence, response_blob_mime_type};
+ use moli_web_mime::effective_response_mime_essence;
#[test]
fn xhr_document_response_mime_uses_shared_effective_essence() {
@@ -643,17 +639,4 @@ mod tests {
Some("application/xml".to_owned())
);
}
-
- #[test]
- fn xhr_blob_response_mime_uses_shared_blob_normalization() {
- let headers = vec![(
- "Content-Type".to_owned(),
- "Text/Plain; Charset=UTF-8".to_owned(),
- )];
-
- assert_eq!(
- response_blob_mime_type(&headers),
- "text/plain; charset=utf-8"
- );
- }
}
diff --git a/moli-renderer-v8/src/network_host/xhr/header_surface.rs b/moli-renderer-v8/src/network_host/xhr/header_surface.rs
index 13152a380..947842f40 100644
--- a/moli-renderer-v8/src/network_host/xhr/header_surface.rs
+++ b/moli-renderer-v8/src/network_host/xhr/header_surface.rs
@@ -161,7 +161,10 @@ pub(super) fn xhr_override_mime_type_callback<'s>(
);
return;
}
- set_xhr_state_string(scope, xhr, XHR_OVERRIDE_MIME_TYPE_SLOT, &parsed.mime);
+ let mime = moli_web_mime::parse_mime_type(&parsed.mime)
+ .map(|mime| mime.to_string())
+ .unwrap_or_else(|| "application/octet-stream".to_owned());
+ set_xhr_state_string(scope, xhr, XHR_OVERRIDE_MIME_TYPE_SLOT, &mime);
rv.set_undefined();
}
diff --git a/moli-renderer-v8/src/script_vm/tests/dom_xhr/blob_mime.rs b/moli-renderer-v8/src/script_vm/tests/dom_xhr/blob_mime.rs
new file mode 100644
index 000000000..e7f55757f
--- /dev/null
+++ b/moli-renderer-v8/src/script_vm/tests/dom_xhr/blob_mime.rs
@@ -0,0 +1,42 @@
+use super::*;
+
+#[tokio::test(flavor = "current_thread")]
+async fn xhr_blob_response_mime_preserves_parameters_in_window_and_worker() {
+ let fixture = include_str!("../../../../tests/fixtures/xhr-blob-mime.js");
+ for worker in [false, true] {
+ let loader = static_http_loader(std::iter::empty::<String>());
+ let mut vm =
+ new_page_task_executor_test_vm_with_loader("https://xhr-blob-mime.test/", &loader);
+ vm.eval("globalThis.blobMimeResult = null;").unwrap();
+ let script = if worker {
+ let source = format!(
+ "{fixture}\nxhrBlobMimeProbe().then(postMessage, error => postMessage({{error: String(error.stack || error)}}));"
+ );
+ format!(
+ "const worker = new Worker('data:text/javascript,' + encodeURIComponent({})); worker.onmessage = event => {{ blobMimeResult = event.data; worker.terminate(); }}; worker.onerror = event => {{ blobMimeResult = {{error:event.message}}; event.preventDefault(); }};",
+ serde_json::to_string(&source).unwrap()
+ )
+ } else {
+ format!(
+ "{fixture}\nxhrBlobMimeProbe().then(value => {{ blobMimeResult = value; }}, error => {{ blobMimeResult = {{error:String(error.stack || error)}}; }});"
+ )
+ };
+ vm.eval(&script).unwrap();
+ tokio::time::timeout(std::time::Duration::from_secs(5), async {
+ while vm.eval("blobMimeResult === null").unwrap() == "true" {
+ wait_for_one_selected_page_task_executor_test_turn(&mut vm, &loader)
+ .await
+ .unwrap();
+ }
+ })
+ .await
+ .expect("XHR Blob MIME probe should settle locally");
+ let result: serde_json::Value =
+ serde_json::from_str(&vm.eval("JSON.stringify(blobMimeResult)").unwrap()).unwrap();
+ assert_eq!(result["state"], "pass", "worker={worker}: {result}");
+ assert_eq!(
+ result["checks"].as_array().unwrap().len(),
+ if worker { 120 } else { 60 }
+ );
+ }
+}
diff --git a/moli-renderer-v8/src/script_vm/tests/dom_xhr/mod.rs b/moli-renderer-v8/src/script_vm/tests/dom_xhr/mod.rs
index 22c290800..9a976fcc0 100644
--- a/moli-renderer-v8/src/script_vm/tests/dom_xhr/mod.rs
+++ b/moli-renderer-v8/src/script_vm/tests/dom_xhr/mod.rs
@@ -1,5 +1,6 @@
use super::*;
+mod blob_mime;
mod computed_style;
mod cssom;
mod dom;
diff --git a/moli-renderer-v8/src/script_vm/tests/dom_xhr/xhr.rs b/moli-renderer-v8/src/script_vm/tests/dom_xhr/xhr.rs
index 8e65f8e62..bf5fb475b 100644
--- a/moli-renderer-v8/src/script_vm/tests/dom_xhr/xhr.rs
+++ b/moli-renderer-v8/src/script_vm/tests/dom_xhr/xhr.rs
@@ -779,60 +779,112 @@ fn xml_http_request_methods_apply_webidl_argument_conversion() {
);
}
#[test]
-fn xml_http_request_override_mime_type_affects_response_mime() {
- let mut vm = new_storage_test_vm("https://xhr-override-mime.test/");
+fn xml_http_request_blob_response_uses_final_mime_type() {
+ let cases: &[(&[&str], Option<&str>, &str)] = &[
+ (&[], None, "text/xml"),
+ (&[""], None, "text/xml"),
+ (&["invalid", "*/*"], None, "text/xml"),
+ (&["TEXT/PLAIN;CHARSET=GBK"], None, "text/plain;charset=GBK"),
+ (&["text/plain;title=ÿ"], None, "text/plain;title=\"ÿ\""),
+ (
+ &["text/html;charset=GBK", "text/html;x=y"],
+ None,
+ "text/html;x=y;charset=GBK",
+ ),
+ (
+ &[
+ "text/html;charset=GBK",
+ "text/html;charset=UTF-8",
+ "text/html",
+ ],
+ None,
+ "text/html;charset=GBK",
+ ),
+ (
+ &["text/html;charset=GBK", "x/x", "text/html"],
+ None,
+ "text/html",
+ ),
+ (
+ &["text/html;title=\"A,B\"", "invalid"],
+ None,
+ "text/html;title=\"A,B\"",
+ ),
+ (&["text/plain"], Some("text/custom"), "text/custom"),
+ (
+ &["text/plain"],
+ Some("TEXT/HTML;CHARSET=GBK"),
+ "text/html;charset=GBK",
+ ),
+ (&["text/plain"], Some("x/x;title=ÿ"), "x/x;title=\"ÿ\""),
+ (&[], Some("invalid"), "application/octet-stream"),
+ (&[], Some(""), "application/octet-stream"),
+ (&[], Some("*/*"), "*/*"),
+ ];
+ for (headers, override_mime, expected) in cases {
+ let mut vm = new_storage_test_vm("https://xhr-override-mime.test/");
- vm.eval(
- r#"
+ vm.eval(
+ r#"
(() => {
globalThis.__xhrMime = new XMLHttpRequest();
__xhrMime.open('GET', '/mime');
__xhrMime.responseType = 'blob';
- __xhrMime.overrideMimeType('text/custom');
return 'ready';
})()
"#,
- )
- .expect("xhr override MIME setup should run");
-
- let context_ptr: *const v8::Global<v8::Context> = &vm.page_default_context as *const _;
- vm.renderer_document_isolate
- .with_entered_renderer_document_isolate(move |isolate| {
- let scope = std::pin::pin!(v8::HandleScope::new(isolate));
- let scope = &mut scope.init();
- let context = unsafe { v8::Local::new(scope, &*context_ptr) };
- let scope = &mut v8::ContextScope::new(scope, context);
- let global = context.global(scope);
- let key = v8::String::new(scope, "__xhrMime").expect("xhr key should allocate");
- let xhr_value = global
- .get(scope, key.into())
- .expect("stored XHR should be readable");
- let xhr = v8::Local::<v8::Object>::try_from(xhr_value)
- .expect("stored XHR should be an object");
- crate::network_host::apply_xhr_response_body_source(
- scope,
- xhr,
- moli_fetch::ResponseHead {
- final_url: Url::parse("https://xhr-override-mime.test/mime")
- .expect("response URL should parse"),
- status: 200,
- headers: vec![("Content-Type".to_owned(), "text/plain".to_owned())],
- request_cookie_report: None,
- cookie_set_reports: Vec::new(),
- redirected: false,
- redirect_chain: Vec::new(),
- from_cache: false,
- negotiated_http_version: None,
- },
- moli_fetch::ResponseBody::materialized_bytes(b"body".to_vec()),
- );
- Ok(())
- })
- .expect("xhr response should apply");
+ )
+ .expect("xhr override MIME setup should run");
+ if let Some(override_mime) = override_mime {
+ vm.eval(&format!(
+ "__xhrMime.overrideMimeType({});",
+ serde_json::to_string(override_mime).unwrap()
+ ))
+ .unwrap();
+ }
+ let headers = headers
+ .iter()
+ .map(|value| ("Content-Type".to_owned(), (*value).to_owned()))
+ .collect();
+
+ let context_ptr: *const v8::Global<v8::Context> = &vm.page_default_context as *const _;
+ vm.renderer_document_isolate
+ .with_entered_renderer_document_isolate(move |isolate| {
+ let scope = std::pin::pin!(v8::HandleScope::new(isolate));
+ let scope = &mut scope.init();
+ let context = unsafe { v8::Local::new(scope, &*context_ptr) };
+ let scope = &mut v8::ContextScope::new(scope, context);
+ let global = context.global(scope);
+ let key = v8::String::new(scope, "__xhrMime").expect("xhr key should allocate");
+ let xhr_value = global
+ .get(scope, key.into())
+ .expect("stored XHR should be readable");
+ let xhr = v8::Local::<v8::Object>::try_from(xhr_value)
+ .expect("stored XHR should be an object");
+ crate::network_host::apply_xhr_response_body_source(
+ scope,
+ xhr,
+ moli_fetch::ResponseHead {
+ final_url: Url::parse("https://xhr-override-mime.test/mime")
+ .expect("response URL should parse"),
+ status: 200,
+ headers,
+ request_cookie_report: None,
+ cookie_set_reports: Vec::new(),
+ redirected: false,
+ redirect_chain: Vec::new(),
+ from_cache: false,
+ negotiated_http_version: None,
+ },
+ moli_fetch::ResponseBody::materialized_bytes(b"body".to_vec()),
+ );
+ Ok(())
+ })
+ .expect("xhr response should apply");
- let result = vm
- .eval(
- r#"
+ let result = vm
+ .eval(
+ r#"
(() => {
const probe = callback => {
try {
@@ -849,10 +901,11 @@ fn xml_http_request_override_mime_type_affects_response_mime() {
].join('|');
})()
"#,
- )
- .expect("xhr override MIME response probe should run");
+ )
+ .expect("xhr override MIME response probe should run");
- assert_eq!(result, "4|text/custom|throw:InvalidStateError");
+ assert_eq!(result, format!("4|{expected}|throw:InvalidStateError"));
+ }
}
#[test]
diff --git a/moli-renderer-v8/tests/fixtures/xhr-blob-mime.js b/moli-renderer-v8/tests/fixtures/xhr-blob-mime.js
new file mode 100644
index 000000000..063604b90
--- /dev/null
+++ b/moli-renderer-v8/tests/fixtures/xhr-blob-mime.js
@@ -0,0 +1,43 @@
+async function xhrBlobMimeProbe(extraCases = []) {
+ const checks = [];
+ const cases = [
+ ['default data MIME', 'data:,%00%FF%80', undefined, 'text/plain;charset=US-ASCII', 'text/plain;charset=US-ASCII'],
+ ['response parameters', 'data:Text/Plain;Charset=GBK;Title=MiXeD,%00%FF%80', undefined, 'text/plain;charset=GBK;title=MiXeD', 'text/plain;charset=GBK;title=MiXeD'],
+ ['override parameters', 'data:text/plain,%00%FF%80', 'TEXT/HTML;CHARSET=GBK', 'text/html;charset=GBK', 'text/plain'],
+ ['quoted parameter', 'data:text/plain,%00%FF%80', 'text/plain;TITLE="AbC ; dEf"', 'text/plain;title="AbC ; dEf"', 'text/plain'],
+ ['escaped parameter', 'data:text/plain,%00%FF%80', 'text/plain;title="AbC\\\"DeF"', 'text/plain;title="AbC\\\"DeF"', 'text/plain'],
+ ['empty parameter', 'data:text/plain,%00%FF%80', 'text/plain;charset=""', 'text/plain;charset=""', 'text/plain'],
+ ['duplicate parameter', 'data:text/plain,%00%FF%80', 'text/plain;CHARSET=GBK;charset=utf-8', 'text/plain;charset=GBK', 'text/plain'],
+ ['non-ASCII parameter', 'data:text/plain,%00%FF%80', 'text/plain;title=ÿ', 'text/plain;title="ÿ"', 'text/plain'],
+ ['tab parameter', 'data:text/plain,%00%FF%80', 'text/plain;title="A\tB"', 'text/plain;title="A\tB"', 'text/plain'],
+ ['invalid override', 'data:text/plain,%00%FF%80', 'not-a-mime-type', 'application/octet-stream', 'text/plain'],
+ ['empty override', 'data:text/plain,%00%FF%80', '', 'application/octet-stream', 'text/plain'],
+ ['wildcard override', 'data:text/plain,%00%FF%80', '*/*', '*/*', 'text/plain'],
+ ...extraCases
+ ];
+ for (const asynchronous of typeof document === 'undefined' ? [true, false] : [true]) {
+ for (const [index, [label, url, override, expected, header]] of cases.entries()) {
+ const check = (name, pass, actual = '') => checks.push({label: `${asynchronous}/${label}/${name}`, pass, actual: String(actual)});
+ const xhr = new XMLHttpRequest();
+ if (override !== undefined && index % 2 === 0) xhr.overrideMimeType(override);
+ xhr.open('GET', url, asynchronous);
+ xhr.responseType = 'blob';
+ if (override !== undefined && index % 2 !== 0) xhr.overrideMimeType(override);
+ if (asynchronous) {
+ await new Promise((resolve, reject) => {
+ xhr.onload = resolve;
+ xhr.onerror = () => reject(new Error(label + ': request failed'));
+ xhr.send();
+ });
+ } else xhr.send();
+ const blob = xhr.response;
+ check('response Blob and identity', blob instanceof Blob && blob === xhr.response);
+ check('final MIME', blob.type === expected, blob.type);
+ check('original response header', xhr.getResponseHeader('content-type') === header, xhr.getResponseHeader('content-type'));
+ check('response bytes', blob.size === 3 && String(new Uint8Array(await blob.arrayBuffer())) === '0,255,128', blob.size);
+ const normalized = /^[\x20-\x7e]*$/.test(expected) ? expected.toLowerCase() : '';
+ check('Blob constructor normalization', new Blob([], {type: expected}).type === normalized);
+ }
+ }
+ return {state: checks.every(check => check.pass) ? 'pass' : 'fail', checks};
+}
diff --git a/moli-web-mime/src/headers.rs b/moli-web-mime/src/headers.rs
index e40839db9..ff73f36fa 100644
--- a/moli-web-mime/src/headers.rs
+++ b/moli-web-mime/src/headers.rs
@@ -20,6 +20,60 @@ pub fn response_content_type(headers: &[(String, String)]) -> Option<String> {
response_header_value(headers, "content-type")
}
+/// The MIME record returned by Fetch's "extract a MIME type" algorithm.
+///
+/// Combine Content-Type fields before splitting so quoted strings, including
+/// unterminated ones, can span fields. Ignore invalid MIME values and `*/*`.
+/// Repeated values with the same essence inherit the first value's charset
+/// when their own charset is absent.
+pub fn extract_response_mime_type(
+ headers: &[(String, String)],
+) -> Option<moli_content_type::MimeType> {
+ let combined = response_header_values(headers, "content-type").join(", ");
+ let mut quoted = false;
+ let mut escaped = false;
+ let mut essence = None;
+ let mut charset = None;
+ let mut mime_type = None;
+ for value in combined.split(|character| {
+ if escaped {
+ escaped = false;
+ false
+ } else if quoted && character == '\\' {
+ escaped = true;
+ false
+ } else if character == '"' {
+ quoted = !quoted;
+ false
+ } else {
+ character == ',' && !quoted
+ }
+ }) {
+ let Some(mut parsed) = moli_content_type::parse_mime_type(value) else {
+ continue;
+ };
+ let parsed_essence = parsed.essence();
+ if parsed_essence == "*/*" {
+ continue;
+ }
+ if essence.as_ref() != Some(&parsed_essence) {
+ charset = parsed.parameter("charset").map(str::to_owned);
+ essence = Some(parsed_essence);
+ } else if parsed.parameter("charset").is_none()
+ && let Some(charset) = &charset
+ {
+ parsed.set_parameter("charset", charset);
+ }
+ mime_type = Some(parsed);
+ }
+ mime_type
+}
+
+/// The essence returned by Fetch's "extract a MIME type" algorithm.
+pub fn extract_response_mime_essence(headers: &[(String, String)]) -> Option<String> {
+ extract_response_mime_type(headers).map(|mime| mime.essence())
+}
+
pub fn response_headers_indicate_attachment_download(headers: &[(String, String)]) -> bool {
headers.iter().any(|(name, value)| {
let Ok(name) = http::HeaderName::from_bytes(name.as_bytes()) else {
diff --git a/moli-web-mime/src/lib.rs b/moli-web-mime/src/lib.rs
index 615e882d2..4262227c3 100644
--- a/moli-web-mime/src/lib.rs
+++ b/moli-web-mime/src/lib.rs
@@ -23,16 +23,16 @@ pub use data_url::{
};
pub use destination::FetchDestination;
pub use headers::{
- effective_response_mime_essence, effective_response_mime_type,
- normalize_response_blob_mime_type, response_blob_mime_type, response_content_type,
- response_document_content_type, response_header_value, response_header_values,
- response_headers_indicate_attachment_download, response_headers_indicate_binary_document,
- response_headers_indicate_raw_document,
+ effective_response_mime_essence, effective_response_mime_type, extract_response_mime_essence,
+ extract_response_mime_type, normalize_response_blob_mime_type, response_blob_mime_type,
+ response_content_type, response_document_content_type, response_header_value,
+ response_header_values, response_headers_indicate_attachment_download,
+ response_headers_indicate_binary_document, response_headers_indicate_raw_document,
};
pub use media::{MediaMimeSupport, is_media_source_type_supported, media_mime_support};
pub use parse::{
mime_charset, mime_essence, mime_parameter, normalize_web_api_mime_type, parse_mime,
- request_header_content_type_essence,
+ parse_mime_type, request_header_content_type_essence,
};
pub use resource::{
known_url_path_mime_essence, resource_mime_essence_for_path, resource_mime_essence_for_url,
diff --git a/moli-web-mime/src/parse.rs b/moli-web-mime/src/parse.rs
index 447e5b0a5..9bae9f550 100644
--- a/moli-web-mime/src/parse.rs
+++ b/moli-web-mime/src/parse.rs
@@ -1,7 +1,5 @@
-use moli_content_type::parse_mime_type;
-
pub use moli_content_type::{
- mime_charset, mime_essence, mime_parameter, normalize_web_api_mime_type,
+ mime_charset, mime_essence, mime_parameter, normalize_web_api_mime_type, parse_mime_type,
};
pub fn parse_mime(input: &str) -> Option<mime::Mime> {
diff --git a/moli-web-mime/src/tests.rs b/moli-web-mime/src/tests.rs
index e475520a9..114541750 100644
--- a/moli-web-mime/src/tests.rs
+++ b/moli-web-mime/src/tests.rs
@@ -324,6 +324,145 @@ fn reads_response_header_values_case_insensitively() {
assert_eq!(response_header_value(&headers, "Bad Header"), None);
}
+#[test]
+fn extracts_response_mime_essence_from_the_combined_header_list() {
+ let cases: &[(&[&str], Option<&str>)] = &[
+ (&[], None),
+ (&[""], None),
+ (&["*/*", "not-a-mime-type"], None),
+ (&["application/json"], Some("application/json")),
+ (&["Text/CSS; charset=utf-16"], Some("text/css")),
+ (
+ &["text/plain", "application/json"],
+ Some("application/json"),
+ ),
+ (&["application/json", "text/plain"], Some("text/plain")),
+ (&["application/json", "invalid"], Some("application/json")),
+ (&["application/json", "*/*", ""], Some("application/json")),
+ (&["text/plain, application/json"], Some("application/json")),
+ (&["application/json, text/plain"], Some("text/plain")),
+ (
+ &["application/json, invalid, */*"],
+ Some("application/json"),
+ ),
+ (&["text/plain; charset=gbk, text/css"], Some("text/css")),
+ (
+ &[r#"text/plain; a=",application/json""#],
+ Some("text/plain"),
+ ),
+ (
+ &[r#"text/plain; a="x\",application/json""#],
+ Some("text/plain"),
+ ),
+ (
+ &[r#"text/plain; a="x\\", application/json"#],
+ Some("application/json"),
+ ),
+ (
+ &[r#"text/plain; a=""#, "application/json"],
+ Some("text/plain"),
+ ),
+ (&[r#"text/plain;""#, "application/json"], Some("text/plain")),
+ (&["applic(ation/vnd.api+json"], None),
+ (&["application/vnd)api+json"], None),
+ (&["text /css"], None),
+ (&["application/vnd.中文+json"], None),
+ ];
+ for (values, expected) in cases {
+ let mut headers: Vec<_> = values
+ .iter()
+ .enumerate()
+ .map(|(index, value)| {
+ (
+ if index % 2 == 0 {
+ "Content-Type"
+ } else {
+ "cOnTeNt-TyPe"
+ }
+ .to_owned(),
+ (*value).to_owned(),
+ )
+ })
+ .collect();
+ headers.push(("X-Content-Type".to_owned(), "application/json".to_owned()));
+ assert_eq!(
+ extract_response_mime_essence(&headers).as_deref(),
+ *expected,
+ "{values:?}"
+ );
+ }
+}
+
+#[test]
+fn extracts_response_mime_parameters_with_charset_inheritance() {
+ let cases: &[(&[&str], Option<&str>)] = &[
+ (&[], None),
+ (&["", "invalid", "*/*"], None),
+ (&["TEXT/PLAIN;CHARSET=GBK"], Some("text/plain;charset=GBK")),
+ (&["text/plain;p=MiXeD"], Some("text/plain;p=MiXeD")),
+ (&["text/plain;p=ÿ"], Some("text/plain;p=\"ÿ\"")),
+ (&["text/plain;charset=GBK", "text/html"], Some("text/html")),
+ (
+ &["text/html;charset=GBK;a=b", "text/html;x=y"],
+ Some("text/html;x=y;charset=GBK"),
+ ),
+ (
+ &["text/html;charset=GBK;a=b, text/html;x=y"],
+ Some("text/html;x=y;charset=GBK"),
+ ),
+ (
+ &[
+ "text/html;charset=GBK",
+ "text/html;charset=UTF-8",
+ "text/html",
+ ],
+ Some("text/html;charset=GBK"),
+ ),
+ (
+ &["text/html", "text/html;charset=GBK", "text/html"],
+ Some("text/html"),
+ ),
+ (
+ &["text/html;charset=GBK", "x/x", "text/html;x=y"],
+ Some("text/html;x=y"),
+ ),
+ (
+ &["text/html;charset=GBK", "invalid", "*/*", "", "text/html"],
+ Some("text/html;charset=GBK"),
+ ),
+ (
+ &["text/html;charset=\"\"", "text/html;x=y"],
+ Some("text/html;x=y;charset=\"\""),
+ ),
+ (
+ &[r#"text/html;charset="A\"B""#, "text/html"],
+ Some(r#"text/html;charset="A\"B""#),
+ ),
+ (
+ &[r#"text/html;x="A,B";charset=GBK"#, "text/html"],
+ Some("text/html;charset=GBK"),
+ ),
+ (
+ &[r#"text/html;x="A"#, "text/plain;charset=GBK"],
+ Some(r#"text/html;x="A, text/plain;charset=GBK""#),
+ ),
+ ];
+ for (values, expected) in cases {
+ let mut headers: Vec<_> = values
+ .iter()
+ .map(|value| ("cOnTeNt-TyPe".to_owned(), (*value).to_owned()))
+ .collect();
+ headers.push(("X-Content-Type".to_owned(), "text/ignored".to_owned()));
+ assert_eq!(
+ extract_response_mime_type(&headers)
+ .map(|mime| mime.to_string())
+ .as_deref(),
+ *expected,
+ "{values:?}"
+ );
+ }
+}
+
#[test]
fn derives_effective_response_mime_for_body_consumers() {
let headers = vec![(