chore: add test to assert retries

Author: not-matthias

src/upload/uploader.rs

@@ -378,4 +378,97 @@ mod tests {
         )
         .await;
     }
+
+    /// Spawns a local TCP server that always answers `503` (a retryable status) and
+    /// counts how many connections (= upload attempts) it receives.
+    fn spawn_mock_returning_503() -> (String, std::sync::Arc<std::sync::atomic::AtomicUsize>) {
+        use std::io::{Read, Write};
+        use std::net::TcpListener;
+        use std::sync::Arc;
+        use std::sync::atomic::{AtomicUsize, Ordering};
+
+        let listener = TcpListener::bind("127.0.0.1:0").unwrap();
+        let url = format!("http://{}/upload", listener.local_addr().unwrap());
+        let hits = Arc::new(AtomicUsize::new(0));
+
+        let hits_loop = hits.clone();
+        std::thread::spawn(move || {
+            for stream in listener.incoming() {
+                let Ok(mut stream) = stream else { continue };
+                hits_loop.fetch_add(1, Ordering::SeqCst);
+                std::thread::spawn(move || {
+                    let mut buf = [0u8; 2048];
+                    let _ = stream.read(&mut buf);
+                    let body = "transient";
+                    let resp = format!(
+                        "HTTP/1.1 503 Service Unavailable\r\nContent-Length: {}\r\nConnection: close\r\n\r\n{}",
+                        body.len(),
+                        body
+                    );
+                    let _ = stream.write_all(resp.as_bytes());
+                });
+            }
+        });
+
+        (url, hits)
+    }
+
+    fn upload_data_for(url: String) -> UploadData {
+        UploadData {
+            status: "success".to_string(),
+            upload_url: url,
+            run_id: "test-run".to_string(),
+        }
+    }
+
+    /// WallTime/Memory path: an on-disk archive is streamed via `STREAMING_CLIENT`,
+    /// which has no retry middleware, so `send_streamed_with_retry` rebuilds the
+    /// stream on each attempt. A transient `503` must be retried 3 times (4 attempts
+    /// total). Slow (~7s) because of the default exponential backoff (1s, 2s, 4s).
+    #[tokio::test]
+    async fn streamed_upload_is_retried() {
+        use std::sync::atomic::Ordering;
+
+        let (url, hits) = spawn_mock_returning_503();
+
+        let path = tempfile::NamedTempFile::new()
+            .unwrap()
+            .into_temp_path()
+            .keep()
+            .unwrap();
+        std::fs::write(&path, b"profile-archive").unwrap();
+        let archive = ProfileArchive::new_uncompressed_on_disk(path).unwrap();
+
+        let result = upload_profile_archive(&upload_data_for(url), archive).await;
+
+        assert!(result.is_err(), "a 503 should surface as an error after retries");
+        assert_eq!(
+            hits.load(Ordering::SeqCst),
+            4,
+            "streamed upload should be attempted 4 times (1 + 3 retries)"
+        );
+    }
+
+    /// Valgrind path: an in-memory archive goes through `REQUEST_CLIENT`, which retries
+    /// transient failures 3 times. Confirms the same `503` mock is genuinely retryable,
+    /// so the single attempt above is due to the client, not the status code.
+    ///
+    /// Slow (~7s) because of the default exponential backoff (1s, 2s, 4s).
+    #[tokio::test]
+    async fn in_memory_upload_is_retried() {
+        use std::sync::atomic::Ordering;
+
+        let (url, hits) = spawn_mock_returning_503();
+
+        let archive = ProfileArchive::new_compressed_in_memory(b"profile-archive".to_vec());
+
+        let result = upload_profile_archive(&upload_data_for(url), archive).await;
+
+        assert!(result.is_err(), "a 503 should surface as an error");
+        assert_eq!(
+            hits.load(Ordering::SeqCst),
+            4,
+            "in-memory upload should be attempted 4 times (1 + 3 retries)"
+        );
+    }
 }