test(benchmarks-website): adopt Result<()> + ? in tests, drop unwraps

CLAUDE.md asks tests to return `Result<()>` and use `?` instead of
`unwrap`. Two test functions and one helper still leaned on
`unwrap()`:

- `migrate::tests::flush_all_does_not_overcount_on_failure` plus its
  `open_db_without` helper.
- `classifier::tests::random_access_bins_dataset_pattern`.
- `read_routes_serve_after_ingest` in
  `vortex-bench-server/tests/ingest.rs`.

The `axum::serve(listener, app).await.unwrap()` calls inside the
spawned background-server closures stay — they're inside
`tokio::spawn`'s unit-returning future, so `?` cannot propagate, and
panicking on a setup failure is the right shape there.

`cargo test -p vortex-bench-server -p vortex-bench-migrate` is green;
no snapshot rewrites needed.

Signed-off-by: Claude <noreply@anthropic.com>

Author: claude

benchmarks-website/migrate/src/classifier.rs

@@ -793,6 +793,8 @@ fn split_engine_format(series: &str) -> Option<(String, String)> {
 
 #[cfg(test)]
 mod tests {
+    use anyhow::Context as _;
+
     use super::*;
 
     fn record(name: &str) -> V2Record {
@@ -836,14 +838,16 @@ mod tests {
     }
 
     #[test]
-    fn random_access_bins_dataset_pattern() {
-        let bin = classify(&record("random-access/taxi/take/parquet")).unwrap();
+    fn random_access_bins_dataset_pattern() -> anyhow::Result<()> {
+        let bin = classify(&record("random-access/taxi/take/parquet"))
+            .context("classify returned None for a known-good 4-part random-access name")?;
         assert_eq!(
             bin,
             V3Bin::RandomAccess {
                 dataset: "taxi/take".into(),
                 format: "parquet".into(),
             }
         );
+        Ok(())
     }
 }

benchmarks-website/migrate/src/migrate.rs

@@ -869,12 +869,12 @@ mod tests {
 
     use super::*;
 
-    fn open_db_without(table: &str) -> (tempfile::TempDir, Connection) {
-        let dir = tempfile::TempDir::new().unwrap();
+    fn open_db_without(table: &str) -> Result<(tempfile::TempDir, Connection)> {
+        let dir = tempfile::TempDir::new()?;
         let path = dir.path().join("v3.duckdb");
-        let conn = open_target_db(&path).unwrap();
-        conn.execute_batch(&format!("DROP TABLE {table}")).unwrap();
-        (dir, conn)
+        let conn = open_target_db(&path)?;
+        conn.execute_batch(&format!("DROP TABLE {table}"))?;
+        Ok((dir, conn))
     }
 
     fn one_query_row() -> QueryMeasurement {
@@ -898,12 +898,12 @@ mod tests {
     }
 
     #[test]
-    fn flush_all_does_not_overcount_on_failure() {
+    fn flush_all_does_not_overcount_on_failure() -> Result<()> {
         // Drop `compression_times` before flushing so the second
         // flush in `flush_all` fails. The first (queries) succeeded,
         // so its counter must be set; the failed table's counter and
         // every later table's counter must stay at zero.
-        let (_dir, conn) = open_db_without("compression_times");
+        let (_dir, conn) = open_db_without("compression_times")?;
 
         let mut summary = MigrationSummary::default();
         let mut q = QueryAccum::default();
@@ -931,5 +931,6 @@ mod tests {
             summary.compression_size_inserted, 0,
             "later flushes never ran"
         );
+        Ok(())
     }
 }

benchmarks-website/server/tests/ingest.rs

@@ -283,7 +283,13 @@ async fn read_routes_serve_after_ingest() -> Result<()> {
     assert!(body["display_name"].is_string());
     assert!(body["unit"].is_string());
     assert!(body["commits"].is_array());
-    assert_eq!(body["commits"].as_array().unwrap().len(), 1);
+    assert_eq!(
+        body["commits"]
+            .as_array()
+            .context("commits is array")?
+            .len(),
+        1
+    );
     assert!(body["series"].is_object());
     Ok(())
 }