fix: Accept-Encoding handling to work correctly if only two compression schemes are available (#361)

* Fix Accept-Encoding handling to work correctly if only two compression schemes are available
* Fixed typo and slightly extended test

---------

Co-authored-by: Jose Quintana <1700322+joseluisq@users.noreply.github.com>

Author: palant

src/compression.rs

@@ -64,6 +64,18 @@ pub const TEXT_MIME_TYPES: [&str; 24] = [
     "application/wasm",
 ];
 
+/// List of encodings that can be handled given enabled features.
+const AVAILABLE_ENCODINGS: &[ContentCoding] = &[
+    #[cfg(any(feature = "compression", feature = "compression-deflate"))]
+    ContentCoding::DEFLATE,
+    #[cfg(any(feature = "compression", feature = "compression-gzip"))]
+    ContentCoding::GZIP,
+    #[cfg(any(feature = "compression", feature = "compression-brotli"))]
+    ContentCoding::BROTLI,
+    #[cfg(any(feature = "compression", feature = "compression-zstd"))]
+    ContentCoding::ZSTD,
+];
+
 /// Create a wrapping handler that compresses the Body of a [`hyper::Response`]
 /// using gzip, `deflate`, `brotli` or `zstd` if is specified in the `Accept-Encoding` header, adding
 /// `content-encoding: <coding>` to the Response's [`HeaderMap`].
@@ -226,45 +238,12 @@ pub fn create_encoding_header(existing: Option<HeaderValue>, coding: ContentCodi
 #[inline(always)]
 pub fn get_preferred_encoding(headers: &HeaderMap<HeaderValue>) -> Option<ContentCoding> {
     if let Some(ref accept_encoding) = headers.typed_get::<AcceptEncoding>() {
-        tracing::trace!("request with accept-ecoding header: {:?}", accept_encoding);
-
-        let encoding = accept_encoding.preferred_encoding();
-        if let Some(preferred_enc) = encoding {
-            let mut feature_formats = Vec::<ContentCoding>::with_capacity(5);
-            if cfg!(feature = "compression-deflate") {
-                feature_formats.push(ContentCoding::DEFLATE);
-            }
-            if cfg!(feature = "compression-gzip") {
-                feature_formats.push(ContentCoding::GZIP);
-            }
-            if cfg!(feature = "compression-brotli") {
-                feature_formats.push(ContentCoding::BROTLI);
-            }
-            if cfg!(feature = "compression-zstd") {
-                feature_formats.push(ContentCoding::ZSTD);
-            }
+        tracing::trace!("request with accept-encoding header: {:?}", accept_encoding);
 
-            // If there is only one Cargo compression feature enabled
-            // then re-evaluate the preferred encoding and return
-            // that feature compression algorithm as `ContentCoding` only
-            // if was contained in the `AcceptEncoding` value.
-            if feature_formats.len() == 1 {
-                let feature_enc = *feature_formats.first().unwrap();
-                if feature_enc != preferred_enc
-                    && accept_encoding
-                        .sorted_encodings()
-                        .any(|enc| enc == feature_enc)
-                {
-                    tracing::trace!(
-                        "preferred encoding {:?} is re-evalated to {:?} because is the only compression feature enabled that matches the `accept-encoding` header",
-                        preferred_enc,
-                        feature_enc
-                    );
-                    return Some(feature_enc);
-                }
+        for encoding in accept_encoding.sorted_encodings() {
+            if AVAILABLE_ENCODINGS.contains(&encoding) {
+                return Some(encoding);
             }
-
-            return encoding;
         }
     }
     None

src/headers_ext/accept_encoding.rs

@@ -48,12 +48,6 @@ impl Header for AcceptEncoding {
 }
 
 impl AcceptEncoding {
-    /// Returns the most preferred encoding that is specified by the header,
-    /// if one is specified.
-    pub(crate) fn preferred_encoding(&self) -> Option<ContentCoding> {
-        self.0.iter().next().map(ContentCoding::from)
-    }
-
     /// Returns a quality sorted iterator of the `ContentCoding`
     pub(crate) fn sorted_encodings(&self) -> impl Iterator<Item = ContentCoding> + '_ {
         self.0.iter().map(ContentCoding::from)
@@ -66,18 +60,14 @@ mod tests {
 
     #[test]
     fn from_static() {
-        let val = HeaderValue::from_static("deflate, gzip;q=1.0, br;q=0.9");
+        let val = HeaderValue::from_static("deflate, zstd;q=0.7, gzip;q=1.0, br;q=0.9");
         let accept_enc = AcceptEncoding(val.into());
 
-        assert_eq!(
-            accept_enc.preferred_encoding(),
-            Some(ContentCoding::DEFLATE)
-        );
-
         let mut encodings = accept_enc.sorted_encodings();
         assert_eq!(encodings.next(), Some(ContentCoding::DEFLATE));
         assert_eq!(encodings.next(), Some(ContentCoding::GZIP));
         assert_eq!(encodings.next(), Some(ContentCoding::BROTLI));
+        assert_eq!(encodings.next(), Some(ContentCoding::ZSTD));
         assert_eq!(encodings.next(), None);
     }
 }

tests/static_files.rs

@@ -671,12 +671,25 @@ mod tests {
     ))]
     #[tokio::test]
     async fn handle_file_compressions() {
-        let encodings = ["gzip", "deflate", "br", "zstd", "xyz"];
+        let encodings = [
+            #[cfg(any(feature = "compression", feature = "compression-gzip"))]
+            "gzip",
+            #[cfg(any(feature = "compression", feature = "compression-deflate"))]
+            "deflate",
+            #[cfg(any(feature = "compression", feature = "compression-brotli"))]
+            "br",
+            #[cfg(any(feature = "compression", feature = "compression-zstd"))]
+            "zstd",
+            "xyz",
+        ];
         let method = &Method::GET;
 
         for enc in encodings {
             let mut headers = HeaderMap::new();
-            headers.insert(http::header::ACCEPT_ENCODING, enc.parse().unwrap());
+            headers.insert(
+                http::header::ACCEPT_ENCODING,
+                format!("identity, {enc}").parse().unwrap(),
+            );
 
             match static_files::handle(&HandleOpts {
                 method,