add tests for content-length and content-range headers, as well as returned body size

this uses the content-length header returned by a non-ranged HEAD request as a reference value

tests/content_length.rs

@@ -0,0 +1,157 @@
+#![cfg(system_deps)]
+
+use reqwest::header::{CONTENT_LENGTH, CONTENT_RANGE, RANGE};
+use reqwest::{Response, StatusCode};
+
+use common::{pict_rs_test_config, upload_form, with_pict_rs, PictRsResult, UploadResponse};
+
+mod common;
+
+fn response_content_length(response: &Response) -> u64 {
+    response
+        .headers()
+        .get(CONTENT_LENGTH)
+        .expect("no content-length")
+        .to_str()
+        .expect("content-length to str")
+        .parse::<u64>()
+        .expect("content-length must be u64")
+}
+
+fn response_content_range(response: &Response) -> &str {
+    response
+        .headers()
+        .get(CONTENT_RANGE)
+        .expect("no content-length")
+        .to_str()
+        .expect("content-range to str")
+}
+
+#[test]
+fn ensure_consistent_content_length() {
+    let address = "127.0.0.1:9200";
+
+    let config = pict_rs_test_config(address);
+
+    with_pict_rs(config, || async {
+        let client = reqwest::Client::new();
+
+        let form = upload_form(["./client-examples/earth.gif"]).await;
+
+        let response = client
+            .post(format!("http://{address}/image"))
+            .multipart(form)
+            .send()
+            .await
+            .expect("send request");
+
+        let upload = response
+            .json::<PictRsResult<UploadResponse>>()
+            .await
+            .expect("valid response")
+            .unwrap();
+
+        let alias = &upload.files[0].file;
+        let original_url = format!("http://{address}/image/original/{alias}");
+
+        // Range-less HEAD request
+        let response = client
+            .head(&original_url)
+            .send()
+            .await
+            .expect("HEAD request");
+        assert!(
+            response.status().is_success(),
+            "HEAD response is not success"
+        );
+
+        let image_size = response_content_length(&response);
+        assert!(image_size > 0, "HEAD content length is 0");
+
+        // Range-less GET request
+        let response = client.get(&original_url).send().await.expect("GET request");
+        assert!(
+            response.status().is_success(),
+            "GET response is not success"
+        );
+
+        let content_length = response_content_length(&response);
+        assert_eq!(
+            content_length, image_size,
+            "GET content-length {} does not match expected value of {}",
+            content_length, image_size
+        );
+
+        let body_length = response.bytes().await.expect("GET body").len() as u64;
+        assert_eq!(
+            body_length, image_size,
+            "GET body size {} does not match expected value of {}",
+            body_length, image_size
+        );
+
+        let range_header_value = "bytes=0-1";
+        let expected_content_range = format!("bytes 0-1/{image_size}");
+        let expected_ranged_content_length = 2;
+
+        // Ranged HEAD request
+        let response = client
+            .head(&original_url)
+            .header(RANGE, range_header_value)
+            .send()
+            .await
+            .expect("ranged HEAD request");
+        assert_eq!(
+            response.status(),
+            StatusCode::PARTIAL_CONTENT,
+            "ranged HEAD response is not 206 Partial Content"
+        );
+
+        let content_length = response_content_length(&response);
+        assert_eq!(
+            content_length, expected_ranged_content_length,
+            "ranged HEAD content-length {} does not match expected value of {}",
+            content_length, expected_ranged_content_length
+        );
+
+        let content_range = response_content_range(&response);
+        assert_eq!(
+            content_range, expected_content_range,
+            "ranged HEAD content-range {:?} does not match expected value of {:?}",
+            content_range, expected_content_range
+        );
+
+        // Ranged GET request
+        let response = client
+            .get(&original_url)
+            .header(RANGE, range_header_value)
+            .send()
+            .await
+            .expect("ranged GET request");
+        assert!(
+            response.status().is_success(),
+            "ranged GET response is not success"
+        );
+
+        let content_length = response_content_length(&response);
+        assert_eq!(
+            content_length, expected_ranged_content_length,
+            "ranged GET content-length {} does not match expected value of {}",
+            content_length, expected_ranged_content_length
+        );
+
+        let content_range = response_content_range(&response);
+        assert_eq!(
+            content_range, expected_content_range,
+            "ranged GET content-range {:?} does not match expected value of {:?}",
+            content_range, expected_content_range
+        );
+
+        let body_length = response.bytes().await.expect("ranged GET body").len() as u64;
+        assert_eq!(
+            body_length, expected_ranged_content_length,
+            "GET body size {} does not match expected value of {}",
+            body_length, expected_ranged_content_length
+        );
+    })
+    .unwrap();
+}