test(chunk-upload): Add test for full chunk upload

Add a test for an entire chunk upload (with only one chunk). The test verifies that the Sentry CLI makes the expected API calls to the assemble endpiont and to the chunk upload endpoint. We check that the request data (including the uploaded file chunk) are exactly the same as what we expect them to be. Our expectation is based on current behavior as of when this change is being made; we assume the current behavior is the correct behavior.

Also, bump MSRV to 1.80 to allow using `LazyLock`, and expect a lint that shows up only after bumping MSRV (I will fix the lint in a separate PR).

Author: szokeasaurusrex

Cargo.toml

@@ -4,7 +4,7 @@ build = "build.rs"
 name = "sentry-cli"
 version = "2.39.1"
 edition = "2021"
-rust-version = "1.65"
+rust-version = "1.80"
 
 [dependencies]
 anylog = "0.6.3"

src/commands/sourcemaps/explain.rs

@@ -228,6 +228,7 @@ fn fetch_release_artifact_file_metadata(
         release,
         &artifact.id,
     )?;
+    #[expect(clippy::manual_inspect)]
     file_metadata
         .ok_or_else(|| format_err!("Could not retrieve file metadata: {}", &artifact.id))
         .map(|f| {

tests/integration/_expected_requests/debug_files/upload/chunk_upload.bin

@@ -1,7 +1,23 @@
+use std::sync::atomic::{AtomicBool, Ordering};
+use std::sync::LazyLock;
+use std::{fs, str};
+
 use assert_cmd::Command;
+use regex::bytes::Regex;
 
 use crate::integration::{test_utils::env, MockEndpointBuilder, TestManager};
 
+/// This regex is used to extract the boundary from the content-type header.
+/// We need to match the boundary, since it changes with each request.
+/// The regex matches the format as specified in
+/// https://www.w3.org/Protocols/rfc1341/7_2_Multipart.html.
+static CONTENT_TYPE_REGEX: LazyLock<Regex> = LazyLock::new(|| {
+    Regex::new(
+        r#"^multipart\/form-data; boundary=(?<boundary>[\w'\(\)+,\-\.\/:=? ]{0,69}[\w'\(\)+,\-\.\/:=?])$"#
+    )
+    .expect("Regex is valid")
+});
+
 #[test]
 fn command_debug_files_upload() {
     TestManager::new()
@@ -189,3 +205,110 @@ fn ensure_correct_assemble_call() {
     manager.assert_mock_endpoints();
     command_result.success();
 }
+
+#[test]
+/// This test simulates a full chunk upload (with only one chunk).
+/// It verifies that the Sentry CLI makes the expected API calls to the chunk upload endpoint
+/// and that the data sent to the chunk upload endpoint is exactly as expected.
+/// It also verifies that the correct calls are made to the assemble endpoint.
+fn ensure_correct_chunk_upload() {
+    let is_first_assemble_call = AtomicBool::new(true);
+    let expected_chunk_body =
+        fs::read("tests/integration/_expected_requests/debug_files/upload/chunk_upload.bin")
+            .expect("expected chunk body file should be present");
+
+    let manager = TestManager::new()
+        .mock_endpoint(
+            MockEndpointBuilder::new("GET", "/api/0/organizations/wat-org/chunk-upload/")
+                .with_response_file("debug_files/get-chunk-upload.json"),
+        )
+        .mock_endpoint(
+            MockEndpointBuilder::new("POST", "/api/0/organizations/wat-org/chunk-upload/")
+                .with_response_fn(move |request| {
+                    let content_type_headers = request.header("content-type");
+                    assert_eq!(
+                        content_type_headers.len(),
+                        1,
+                        "content-type header should be present exactly once, found {} times",
+                        content_type_headers.len()
+                    );
+
+                    let content_type = content_type_headers[0].as_bytes();
+
+                    let boundary = CONTENT_TYPE_REGEX
+                        .captures(content_type)
+                        .expect("content-type should match regex")
+                        .name("boundary")
+                        .expect("boundary should be present")
+                        .as_bytes();
+
+                    let boundary_str = str::from_utf8(boundary).expect("boundary should be valid utf-8");
+
+                    let boundary_escaped = regex::escape(boundary_str);
+
+                    let body_regex = Regex::new(&format!(
+                        r#"^--{boundary_escaped}(?<chunk_body>(?s-u:.)*?)--{boundary_escaped}--\s*$"#
+                    ))
+                    .expect("regex should be valid");
+
+                    let body = request.body().expect("body should be readable");
+
+                    let chunk_body = body_regex
+                        .captures(body)
+                        .expect("body should match regex")
+                        .name("chunk_body")
+                        .expect("chunk_body section should be present")
+                        .as_bytes();
+
+                    assert_eq!(chunk_body, expected_chunk_body);
+
+                    vec![] // Client does not expect a response body
+                }),
+        )
+        .mock_endpoint(
+            MockEndpointBuilder::new(
+                "POST",
+                "/api/0/projects/wat-org/wat-project/files/difs/assemble/",
+            )
+            .with_header_matcher("content-type", "application/json")
+            .with_matcher(r#"{"21b76b717dbbd8c89e42d92b29667ac87aa3c124":{"name":"SrcGenSampleApp.pdb","debug_id":"c02651ae-cd6f-492d-bc33-0b83111e7106-8d8e7c60","chunks":["21b76b717dbbd8c89e42d92b29667ac87aa3c124"]}}"#)
+            .with_response_fn(move |_| {
+                if is_first_assemble_call.swap(false, Ordering::Relaxed) {
+                    r#"{
+                        "21b76b717dbbd8c89e42d92b29667ac87aa3c124": {
+                            "state": "not_found",
+                            "missingChunks": ["21b76b717dbbd8c89e42d92b29667ac87aa3c124"]
+                        }
+                    }"#
+                } else {
+                    r#"{
+                        "21b76b717dbbd8c89e42d92b29667ac87aa3c124": {
+                            "state": "created",
+                            "missingChunks": []
+                        }
+                    }"#
+                }
+                .into()
+            })
+            .expect(2),
+        );
+
+    let mut command = Command::cargo_bin("sentry-cli").expect("sentry-cli should be available");
+
+    command.args(
+        "debug-files upload --include-sources tests/integration/_fixtures/SrcGenSampleApp.pdb"
+            .split(' '),
+    );
+
+    env::set_all(manager.server_info(), |k, v| {
+        command.env(k, v.as_ref());
+    });
+
+    let command_result = command.assert();
+
+    // First assert the mock was called as expected, then that the command was successful.
+    // This is because failure with the mock assertion can cause the command to fail, and
+    // the mock assertion failure is likely more interesting in this case.
+    manager.assert_mock_endpoints();
+    command_result.success();
+}

tests/integration/debug_files/upload.rs

@@ -1,4 +1,4 @@
-use mockito::{IntoHeaderName, Matcher, Mock, ServerGuard};
+use mockito::{IntoHeaderName, Matcher, Mock, Request, ServerGuard};
 
 /// Builder for a mock endpoint.
 ///
@@ -41,6 +41,17 @@ impl MockEndpointBuilder {
         self
     }
 
+    /// Set the response body of the mock endpoint using a function that takes
+    /// the request and returns the response body.
+    /// This function can also be used to perform arbitrary assertions on the request.
+    pub fn with_response_fn(
+        mut self,
+        callback: impl Fn(&Request) -> Vec<u8> + Send + Sync + 'static,
+    ) -> Self {
+        self.builder = Box::new(|server| (self.builder)(server).with_body_from_request(callback));
+        self
+    }
+
     /// Set the response body of the mock endpoint to a file with the given path.
     /// The path is relative to the `tests/integration/_responses` directory.
     pub fn with_response_file(mut self, path: &str) -> Self {