curl,winrt fix req header override

Author: bdbai

backends/curl/src/request.rs

@@ -50,7 +50,12 @@ pub fn populate_request<S, H: Handler>(
     }
     .into_nyquest_result("set CURLOPT_CUSTOMREQUEST")?;
     let mut headers = List::new();
-    for (name, value) in &options.default_headers {
+    for (name, value) in options.default_headers.iter().filter(|(name, _)| {
+        // FIXME: This is O(len(additional) * len(default))
+        !req.additional_headers
+            .iter()
+            .any(|(n, _)| n.eq_ignore_ascii_case(name))
+    }) {
         headers
             .append(&format!("{name}: {value}"))
             .into_nyquest_result("default_headers curl_slist_append")?;

backends/winrt/src/client.rs

@@ -54,7 +54,11 @@ impl WinrtClient {
         }
         let mut default_content_headers = vec![];
         for (name, value) in options.default_headers {
-            if is_header_name_content_related(&name) {
+            if name.eq_ignore_ascii_case("content-type") {
+                // If a request has a body, the content-type value is required from the user.
+                // Otherwise if there is no body, the content-type header will never be sent.
+                // So we can safely ignore the default content-type header.
+            } else if is_header_name_content_related(&name) {
                 default_content_headers.push((HSTRING::from(name), HSTRING::from(value)));
             } else {
                 client

backends/winrt/src/request.rs

@@ -33,7 +33,7 @@ impl WinrtClient {
         .into_nyquest_result()?;
         let req_msg = HttpRequestMessage::Create(&method, &uri).into_nyquest_result()?;
         // TODO: cache method
-        if !req.additional_headers.is_empty() || !self.default_content_headers.is_empty() {
+        if !req.additional_headers.is_empty() {
             let headers = req_msg.Headers().into_nyquest_result()?;
             for (name, value) in &req.additional_headers {
                 headers

nyquest-backend-tests/src/fixtures/scenarios.rs

@@ -1 +1,2 @@
 mod chunked_encoding;
+mod request_header_override;

nyquest-backend-tests/src/fixtures/scenarios/request_header_override.rs

@@ -0,0 +1,79 @@
+#[cfg(test)]
+mod tests {
+    use http_body_util::Full;
+    #[cfg(feature = "blocking")]
+    use nyquest::blocking::Body as NyquestBlockingBody;
+    #[cfg(feature = "async")]
+    use nyquest::r#async::Body as NyquestAsyncBody;
+    use nyquest::Request as NyquestRequest;
+
+    use crate::*;
+
+    #[test]
+    fn test_request_header_override() {
+        const PATH: &str = "scenarios/request_header_override";
+        const DEFAULT_HEADER_NAME: &str = "x-default-header";
+        const DEFAULT_HEADER_VALUE: &str = "default";
+        const EXPECTED_HEADER_VALUE: &str = "expected";
+        const BODY_TEXT: &str = "Hello, plain text!";
+
+        let _handle = crate::add_hyper_fixture(PATH, {
+            move |req| async move {
+                let content_type_headers: Vec<_> = req
+                    .headers()
+                    .get_all(DEFAULT_HEADER_NAME)
+                    .iter()
+                    .map(|h| h.to_str().unwrap_or_default())
+                    .collect();
+                let content_type_headers = content_type_headers.join("; ");
+
+                let response_body = Bytes::from(content_type_headers.into_bytes());
+                let res = Response::new(Full::new(response_body));
+
+                (res, Ok(()))
+            }
+        });
+
+        let assertions = |received_content_type: &str| {
+            assert_eq!(received_content_type, EXPECTED_HEADER_VALUE);
+        };
+
+        #[cfg(feature = "blocking")]
+        {
+            let builder = crate::init_builder_blocking()
+                .unwrap()
+                .with_header(DEFAULT_HEADER_NAME, DEFAULT_HEADER_VALUE);
+            let client = builder.build_blocking().unwrap();
+            let res = client
+                .request(
+                    NyquestRequest::post(PATH)
+                        .with_body(NyquestBlockingBody::plain_text(BODY_TEXT))
+                        .with_header(DEFAULT_HEADER_NAME, EXPECTED_HEADER_VALUE),
+                )
+                .unwrap();
+            let content_type = res.text().unwrap();
+            assertions(&content_type);
+        }
+
+        #[cfg(feature = "async")]
+        {
+            let content_type = TOKIO_RT.block_on(async {
+                let builder = crate::init_builder()
+                    .await
+                    .unwrap()
+                    .with_header(DEFAULT_HEADER_NAME, DEFAULT_HEADER_VALUE);
+                let client = builder.build_async().await.unwrap();
+                let res = client
+                    .request(
+                        NyquestRequest::post(PATH)
+                            .with_body(NyquestAsyncBody::plain_text(BODY_TEXT))
+                            .with_header(DEFAULT_HEADER_NAME, EXPECTED_HEADER_VALUE),
+                    )
+                    .await
+                    .unwrap();
+                res.text().await.unwrap()
+            });
+            assertions(&content_type);
+        }
+    }
+}