refactor(decompression-plz): cargo fmt linting

Author: darkseid-is

decompression-plz/src/decompression/state.rs

@@ -218,7 +218,6 @@ pub fn decompression_runner<'a>(
     let mut state =
         DecompressionState::start(main, extra, encodings, buf.writer());
     loop {
-        dbg!(&state);
         state = state.try_next()?;
         if state.is_ended() {
             return Ok(state);

decompression-plz/src/state.rs

@@ -1,8 +1,6 @@
 use body_plz::variants::Body;
 use bytes::BytesMut;
-use header_plz::body_headers::{
-    content_encoding::ContentEncoding, encoding_info::EncodingInfo,
-};
+use header_plz::body_headers::encoding_info::EncodingInfo;
 
 use crate::{
     decode_struct::DecodeStruct,
@@ -61,9 +59,6 @@ where
                         .unwrap()
                         .encodings_as_mut()
                         .pop();
-                    //if encoding_infos.last().unwrap().encodings().is_empty() {
-                    //    encoding_infos.pop();
-                    //}
                 }
 
                 let mut next_state = if is_chunked_te_only(&encoding_infos) {

decompression-plz/tests/test_cases/chunked.rs

@@ -1,7 +1,7 @@
 use super::*;
 use body_plz::variants::chunked::ChunkType;
 use decompression_plz::chunked::{chunked_to_raw, partial_chunked_to_raw};
-use tests_utils::all_compressed_data;
+use tests_utils::{INPUT, all_compressed_data};
 
 const HEADERS: &str = "Host: example.com\r\n\
                        Content-Type: text/html; charset=utf-8\r\n\
@@ -129,51 +129,192 @@ fn build_all_compressed_chunk_body() -> Body {
     Body::Chunked(chunk_vec)
 }
 
-#[test]
-fn test_chunked_with_compression() {
-    let headers = "Host: example.com\r\n\
-                   Content-Type: text/html; charset=utf-8\r\n\
-                   Transfer-Encoding: br, deflate, identity, gzip, zstd, chunked\r\n\
-                   \r\n";
+#[track_caller]
+fn assert_chunked_encoding(
+    headers: &str,
+    with_ce: bool,
+    extra: Option<BytesMut>,
+) {
     let mut buf = BytesMut::new();
 
+    let verify = if extra.is_none() {
+        "Host: example.com\r\n\
+         Content-Type: text/html; charset=utf-8\r\n\
+         Content-Length: 11\r\n\r\n\
+         hello world"
+    } else {
+        "Host: example.com\r\n\
+         Content-Type: text/html; charset=utf-8\r\n\
+         Content-Length: 22\r\n\r\n\
+         hello worldhello world"
+    };
+
     let mut tm = TestMessage::build(
         headers.into(),
         build_all_compressed_chunk_body(),
-        None,
+        extra,
     );
+
     let mut state = DecodeState::init(&mut tm, &mut buf);
     state = state.try_next().unwrap();
     assert!(matches!(state, DecodeState::TransferEncoding(..)));
 
+    if with_ce {
+        state = state.try_next().unwrap();
+        assert!(matches!(state, DecodeState::ContentEncoding(..)));
+    }
+
     state = state.try_next().unwrap();
     assert!(matches!(state, DecodeState::UpdateContentLength(..)));
 
     state = state.try_next().unwrap();
     assert!(state.is_ended());
 
-    let verify = "Host: example.com\r\n\
-                  Content-Type: text/html; charset=utf-8\r\n\
-                  Content-Length: 11\r\n\r\n\
-                  hello world";
     let result = tm.into_bytes();
     assert_eq!(result, verify);
 }
 
+#[test]
+fn test_chunked_with_compression() {
+    let headers = "Host: example.com\r\n\
+                   Content-Type: text/html; charset=utf-8\r\n\
+                   Transfer-Encoding: br, deflate, identity, gzip, zstd, chunked\r\n\
+                   \r\n";
+
+    assert_chunked_encoding(headers, false, None);
+}
+
+#[test]
+fn test_chunked_with_compression_extra_raw() {
+    let headers = "Host: example.com\r\n\
+                   Content-Type: text/html; charset=utf-8\r\n\
+                   Transfer-Encoding: br, deflate, identity, gzip, zstd, chunked\r\n\
+                   \r\n";
+
+    assert_chunked_encoding(headers, false, Some(INPUT.into()));
+}
+
+#[test]
+fn test_chunked_with_compress_extra_compressed_together() {
+    let body = all_compressed_data(); // len 53
+    let mut chunk_vec = vec![
+        ChunkType::Size("10\r\n".into()),
+        ChunkType::Chunk(body[0..10].into()),
+        ChunkType::Size("10\r\n".into()),
+        ChunkType::Chunk(body[10..20].into()),
+        ChunkType::Size("10\r\n".into()),
+        ChunkType::Chunk(body[20..30].into()),
+        ChunkType::Size("10\r\n".into()),
+        ChunkType::Chunk(body[30..40].into()),
+        ChunkType::Size("10\r\n".into()),
+    ];
+
+    for chunk in chunk_vec.iter_mut() {
+        if let ChunkType::Chunk(chunk) = chunk {
+            chunk.extend_from_slice("\r\n".as_bytes());
+        }
+    }
+    let chunk_body = Body::Chunked(chunk_vec);
+    let extra = BytesMut::from(&body[40..]);
+
+    let headers = "Host: example.com\r\n\
+                   Content-Type: text/html; charset=utf-8\r\n\
+                   Transfer-Encoding: br, deflate, identity, gzip, zstd, chunked\r\n\
+                   \r\n";
+
+    let mut tm = TestMessage::build(headers.into(), chunk_body, Some(extra));
+
+    let mut buf = BytesMut::new();
+    let mut state = DecodeState::init(&mut tm, &mut buf);
+    state = state.try_next().unwrap();
+    assert!(matches!(state, DecodeState::TransferEncoding(..)));
+
+    state = state.try_next().unwrap();
+    assert!(matches!(state, DecodeState::UpdateContentLength(..)));
+
+    state = state.try_next().unwrap();
+    assert!(state.is_ended());
+    assert_eq!(tm.into_bytes(), VERIFY_SINGLE_HEADER_BODY_ONLY);
+}
+
+#[test]
+fn test_chunked_with_compress_extra_compressed_separate() {
+    let body = build_all_compressed_chunk_body();
+    let extra = all_compressed_data();
+
+    let headers = "Host: example.com\r\n\
+                   Content-Type: text/html; charset=utf-8\r\n\
+                   Transfer-Encoding: br, deflate, identity, gzip, zstd, chunked\r\n\
+                   \r\n";
+
+    let mut tm = TestMessage::build(headers.into(), body, Some(extra));
+
+    let mut buf = BytesMut::new();
+    let mut state = DecodeState::init(&mut tm, &mut buf);
+    state = state.try_next().unwrap();
+    assert!(matches!(state, DecodeState::TransferEncoding(..)));
+
+    state = state.try_next().unwrap();
+    assert!(matches!(state, DecodeState::UpdateContentLength(..)));
+
+    state = state.try_next().unwrap();
+    assert!(state.is_ended());
+    assert_eq!(tm.into_bytes(), VERIFY_SINGLE_HEADER_BODY_AND_EXTRA);
+}
+
+/// Ce
 #[test]
 fn test_chunked_with_ce_compression() {
     let headers = "Host: example.com\r\n\
                    Content-Type: text/html; charset=utf-8\r\n\
                    Transfer-Encoding: chunked\r\n\
+                   Content-Encoding: br, deflate, identity, gzip, zstd\r\n\r\n";
+
+    assert_chunked_encoding(headers, true, None);
+}
+
+#[test]
+fn test_chunked_with_ce_compression_extra_raw() {
+    let headers = "Host: example.com\r\n\
+                   Content-Type: text/html; charset=utf-8\r\n\
+                   Transfer-Encoding: chunked\r\n\
+                   Content-Encoding: br, deflate, identity, gzip, zstd\r\n\r\n";
+
+    assert_chunked_encoding(headers, true, Some(INPUT.into()));
+}
+
+#[test]
+fn test_chunked_with_ce_compress_extra_compressed_together() {
+    let body = all_compressed_data(); // len 53
+    let mut chunk_vec = vec![
+        ChunkType::Size("10\r\n".into()),
+        ChunkType::Chunk(body[0..10].into()),
+        ChunkType::Size("10\r\n".into()),
+        ChunkType::Chunk(body[10..20].into()),
+        ChunkType::Size("10\r\n".into()),
+        ChunkType::Chunk(body[20..30].into()),
+        ChunkType::Size("10\r\n".into()),
+        ChunkType::Chunk(body[30..40].into()),
+        ChunkType::Size("10\r\n".into()),
+    ];
+
+    for chunk in chunk_vec.iter_mut() {
+        if let ChunkType::Chunk(chunk) = chunk {
+            chunk.extend_from_slice("\r\n".as_bytes());
+        }
+    }
+    let chunk_body = Body::Chunked(chunk_vec);
+    let extra = BytesMut::from(&body[40..]);
+
+    let headers = "Host: example.com\r\n\
+                   Content-Type: text/html; charset=utf-8\r\n\
                    Content-Encoding: br, deflate, identity, gzip, zstd\r\n\
+                   Transfer-Encoding: chunked\r\n\
                    \r\n";
-    let mut buf = BytesMut::new();
 
-    let mut tm = TestMessage::build(
-        headers.into(),
-        build_all_compressed_chunk_body(),
-        None,
-    );
+    let mut tm = TestMessage::build(headers.into(), chunk_body, Some(extra));
+
+    let mut buf = BytesMut::new();
     let mut state = DecodeState::init(&mut tm, &mut buf);
     state = state.try_next().unwrap();
     assert!(matches!(state, DecodeState::TransferEncoding(..)));
@@ -186,11 +327,36 @@ fn test_chunked_with_ce_compression() {
 
     state = state.try_next().unwrap();
     assert!(state.is_ended());
+    assert_eq!(tm.into_bytes(), VERIFY_SINGLE_HEADER_BODY_ONLY);
+}
 
-    let verify = "Host: example.com\r\n\
-                  Content-Type: text/html; charset=utf-8\r\n\
-                  Content-Length: 11\r\n\r\n\
-                  hello world";
-    let result = tm.into_bytes();
-    assert_eq!(result, verify);
+#[test]
+fn test_chunked_with_ce_compress_extra_compressed_separate() {
+    let body = build_all_compressed_chunk_body();
+    let extra = all_compressed_data();
+
+    let headers = "Host: example.com\r\n\
+                   Content-Type: text/html; charset=utf-8\r\n\
+                   Content-Encoding: br, deflate, identity, gzip, zstd\r\n\
+                   Transfer-Encoding: chunked\r\n\
+                   \r\n";
+
+    let mut tm = TestMessage::build(headers.into(), body, Some(extra));
+
+    let mut buf = BytesMut::new();
+    let mut state = DecodeState::init(&mut tm, &mut buf);
+    state = state.try_next().unwrap();
+    assert!(matches!(state, DecodeState::TransferEncoding(..)));
+
+    state = state.try_next().unwrap();
+    assert!(matches!(state, DecodeState::ContentEncoding(..)));
+
+    state = state.try_next().unwrap();
+    assert!(matches!(state, DecodeState::UpdateContentLength(..)));
+
+    state = state.try_next().unwrap();
+    assert!(state.is_ended());
+    assert_eq!(tm.into_bytes(), VERIFY_SINGLE_HEADER_BODY_AND_EXTRA);
 }
+
+// Partial

decompression-plz/tests/test_cases/partial/multi_header.rs

@@ -1 +1,90 @@
 use super::*;
+
+#[track_caller]
+fn assert_partial_decompressed_multi_header(
+    encoding: &str,
+    extra: Option<BytesMut>,
+) {
+    let headers = format!(
+        "Host: example.com\r\n\
+        Content-Type: text/html; charset=utf-8\r\n\
+        {encoding}: br\r\n\
+        Some-Other-Header: value\r\n\
+        {encoding}: deflate, gzip, {ALL_COMPRESSIONS}\r\n\
+        Content-Length: 11\r\n\r\n",
+    );
+
+    let expected_state = encoding_state(encoding);
+
+    let verify = if extra.is_none() {
+        format!(
+            "Host: example.com\r\n\
+            Content-Type: text/html; charset=utf-8\r\n\
+            {encoding}: br\r\n\
+            Some-Other-Header: value\r\n\
+            {encoding}: deflate, gzip\r\n\
+            Content-Length: 11\r\n\r\n\
+            hello world",
+        )
+    } else {
+        format!(
+            "Host: example.com\r\n\
+            Content-Type: text/html; charset=utf-8\r\n\
+            {encoding}: br\r\n\
+            Some-Other-Header: value\r\n\
+            {encoding}: deflate, gzip\r\n\
+            Content-Length: 22\r\n\r\n\
+            hello worldhello world",
+        )
+    };
+
+    let mut tm = TestMessage::build(
+        headers.as_bytes().into(),
+        Body::Raw(all_compressed_data()),
+        extra,
+    );
+
+    let mut buf = BytesMut::new();
+    let mut state = DecodeState::init(&mut tm, &mut buf);
+    state = state.try_next().unwrap();
+    assert!((expected_state)(&state));
+
+    state = state.try_next().unwrap();
+    assert!(matches!(state, DecodeState::UpdateContentLengthAndErr(..)));
+
+    if let Err(e) = state.try_next() {
+        assert!(matches!(e, MultiDecompressErrorReason::Partial { .. }));
+        let result = tm.into_bytes();
+
+        assert_eq!(result, verify);
+    } else {
+        panic!()
+    }
+}
+
+#[test]
+fn test_partial_te_multi_header() {
+    assert_partial_decompressed_multi_header(TRANSFER_ENCODING, None);
+}
+
+#[test]
+fn test_partial_te_multi_header_extra_raw() {
+    assert_partial_decompressed_multi_header(
+        TRANSFER_ENCODING,
+        Some(INPUT.into()),
+    );
+}
+
+//
+#[test]
+fn test_partial_ce_multi_header() {
+    assert_partial_decompressed_multi_header(CONTENT_ENCODING, None);
+}
+
+#[test]
+fn test_partial_ce_multi_header_extra_raw() {
+    assert_partial_decompressed_multi_header(
+        CONTENT_ENCODING,
+        Some(INPUT.into()),
+    );
+}

decompression-plz/tests/test_cases/partial/single_header.rs

@@ -95,3 +95,11 @@ fn test_partial_te_single_header_extra_raw() {
 fn test_partial_ce_single_header() {
     assert_partial_decompressed_single_header(CONTENT_ENCODING, None);
 }
+
+#[test]
+fn test_partial_ce_single_header_extra_raw() {
+    assert_partial_decompressed_single_header(
+        CONTENT_ENCODING,
+        Some(INPUT.into()),
+    );
+}