feat(header-plz): added methods for determining only chunked and identity transfer encoding and only identity content encoding for BodyHeader struct

1. is_chunked_te_only
2. is_identity_te_only
3. is_identity_ce_only

Author: darkseid-is

header-plz/src/body_headers/mod.rs

@@ -52,13 +52,38 @@ impl BodyHeader {
             self.transfer_type = Some(transfer_type);
         }
     }
+
+    fn has_single_te_encoding(&self, encoding: &ContentEncoding) -> bool {
+        self.transfer_encoding.as_ref().is_some_and(|einfo_vec| {
+            einfo_vec.len() == 1
+                && einfo_vec[0].encodings().len() == 1
+                && &einfo_vec[0].encodings()[0] == encoding
+        })
+    }
+
+    pub fn is_chunked_te_only(&self) -> bool {
+        self.has_single_te_encoding(&ContentEncoding::Chunked)
+    }
+
+    pub fn is_identity_te_only(&self) -> bool {
+        self.has_single_te_encoding(&ContentEncoding::Identity)
+    }
+
+    pub fn is_identity_ce_only(&self) -> bool {
+        self.content_encoding.as_ref().is_some_and(|einfo_vec| {
+            einfo_vec.len() == 1
+                && einfo_vec[0].encodings().len() == 1
+                && einfo_vec[0].encodings()[0] == ContentEncoding::Identity
+        })
+    }
 }
 
 #[cfg(test)]
 mod tests {
 
     use super::*;
 
+    // sanitize
     #[test]
     fn test_bodyheader_sanitize_all() {
         let body = BodyHeader {
@@ -83,8 +108,9 @@ mod tests {
         assert!(body.sanitize().is_none());
     }
 
+    // content type
     #[test]
-    fn test_bodyheader_contenttype() {
+    fn test_bodyheader_content_type() {
         let body = BodyHeader {
             content_type: Some(ContentType::Application),
             ..Default::default()
@@ -93,8 +119,140 @@ mod tests {
     }
 
     #[test]
-    fn test_bodyheader_contenttype_default() {
+    fn test_bodyheader_content_type_default() {
         let body = BodyHeader::default();
         assert_eq!(body.content_type(), ContentType::Unknown);
     }
+
+    // chunked te position
+    #[test]
+    fn test_bodyheader_chunked_te_position_none() {
+        let body = BodyHeader::default();
+        assert_eq!(body.chunked_te_position(), None);
+    }
+
+    #[test]
+    fn test_bodyheader_chunked_te_position_single() {
+        let body = BodyHeader {
+            transfer_encoding: Some(vec![EncodingInfo::new(
+                0,
+                vec![ContentEncoding::Chunked],
+            )]),
+            ..Default::default()
+        };
+        assert_eq!(body.chunked_te_position(), Some((0, 0)));
+    }
+
+    #[test]
+    fn test_bodyheader_chunked_te_position_multi() {
+        let body = BodyHeader {
+            transfer_encoding: Some(vec![
+                EncodingInfo::new(0, vec![ContentEncoding::Brotli]),
+                EncodingInfo::new(1, vec![ContentEncoding::Identity]),
+                EncodingInfo::new(1, vec![ContentEncoding::Gzip]),
+                EncodingInfo::new(1, vec![ContentEncoding::Chunked]),
+            ]),
+            ..Default::default()
+        };
+        assert_eq!(body.chunked_te_position(), Some((3, 0)));
+    }
+
+    // is_chunked_te_only
+    #[test]
+    fn test_bodyheader_is_chunked_te_only_true() {
+        let body = BodyHeader {
+            transfer_encoding: Some(vec![EncodingInfo::new(
+                0,
+                vec![ContentEncoding::Chunked],
+            )]),
+            ..Default::default()
+        };
+        assert!(body.is_chunked_te_only());
+    }
+
+    #[test]
+    fn test_bodyheader_is_chunked_te_only_none_false() {
+        let body = BodyHeader::default();
+        assert!(!body.is_chunked_te_only());
+    }
+
+    #[test]
+    fn test_bodyheader_is_chunked_te_only_multi_false() {
+        let body = BodyHeader {
+            transfer_encoding: Some(vec![
+                EncodingInfo::new(0, vec![ContentEncoding::Brotli]),
+                EncodingInfo::new(1, vec![ContentEncoding::Identity]),
+                EncodingInfo::new(1, vec![ContentEncoding::Gzip]),
+                EncodingInfo::new(1, vec![ContentEncoding::Chunked]),
+            ]),
+            ..Default::default()
+        };
+        assert!(!body.is_chunked_te_only());
+    }
+
+    // is_identity_te_only
+    #[test]
+    fn test_bodyheader_is_identity_te_only_true() {
+        let body = BodyHeader {
+            transfer_encoding: Some(vec![EncodingInfo::new(
+                0,
+                vec![ContentEncoding::Identity],
+            )]),
+            ..Default::default()
+        };
+        assert!(body.is_identity_te_only());
+    }
+
+    #[test]
+    fn test_bodyheader_is_identity_te_only_none_false() {
+        let body = BodyHeader::default();
+        assert!(!body.is_identity_te_only());
+    }
+
+    #[test]
+    fn test_bodyheader_is_identity_te_only_multi_false() {
+        let body = BodyHeader {
+            transfer_encoding: Some(vec![
+                EncodingInfo::new(0, vec![ContentEncoding::Brotli]),
+                EncodingInfo::new(1, vec![ContentEncoding::Identity]),
+                EncodingInfo::new(1, vec![ContentEncoding::Gzip]),
+                EncodingInfo::new(1, vec![ContentEncoding::Chunked]),
+            ]),
+            ..Default::default()
+        };
+        assert!(!body.is_identity_te_only());
+    }
+
+    // is_identity_ce_only
+    #[test]
+    fn test_bodyheader_is_identity_ce_only_true() {
+        let body = BodyHeader {
+            content_encoding: Some(vec![EncodingInfo::new(
+                0,
+                vec![ContentEncoding::Identity],
+            )]),
+            ..Default::default()
+        };
+        assert!(body.is_identity_ce_only());
+    }
+
+    #[test]
+    fn test_bodyheader_is_identity_ce_only_none_false() {
+        let body = BodyHeader::default();
+        assert!(!body.is_identity_ce_only());
+    }
+
+    #[test]
+    fn test_bodyheader_is_identity_ce_only_multi_false() {
+        let body = BodyHeader {
+            content_encoding: Some(vec![
+                EncodingInfo::new(0, vec![ContentEncoding::Brotli]),
+                EncodingInfo::new(1, vec![ContentEncoding::Identity]),
+                EncodingInfo::new(1, vec![ContentEncoding::Gzip]),
+                EncodingInfo::new(1, vec![ContentEncoding::Chunked]),
+            ]),
+            ..Default::default()
+        };
+        assert!(!body.is_identity_ce_only());
+    }
 }