Best headless browser for AI agents. Lite, Fast, High-Compatibility. Built in Rust
Rust ai-agentsai-toolsbrowserbrowser-automationcloud-browserheadlessheadless-browserkitesurfplaywrightpuppeteerrustservoweb-crawlerweb-crawlingweb-scraperweb-scraping
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.rsindex 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.rsindex 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.rsindex 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.rsindex 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.rsnew file mode 100644index 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.rsindex 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.rsindex 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.jsnew file mode 100644index 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.rsindex 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.rsindex 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.rsindex 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.rsindex 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![(