Replace connection panic integration test with unit test

src/server/connection.rs

@@ -86,7 +86,6 @@ async fn process_stream<F, T>(
 
 #[cfg(test)]
 mod tests {
-    use metrics_util::debugging::{DebugValue, DebuggingRecorder};
     use rstest::rstest;
     use tokio::{
         net::{TcpListener, TcpStream},
@@ -212,50 +211,4 @@ mod tests {
                 .ok_or_else(|| "panic log not found".to_string())
         });
     }
-
-    /// Panics increment the connection panic counter.
-    #[rstest]
-    #[tokio::test]
-    async fn connection_panic_metric_increments(
-        factory: impl Fn() -> WireframeApp + Send + Sync + Clone + 'static,
-    ) {
-        let recorder = DebuggingRecorder::new();
-        let snapshotter = recorder.snapshotter();
-        recorder.install().expect("recorder install");
-
-        let app_factory = move || {
-            factory()
-                .on_connection_setup(|| async { panic!("boom") })
-                .unwrap()
-        };
-        let tracker = TaskTracker::new();
-        let listener = TcpListener::bind("127.0.0.1:0").await.unwrap();
-        let addr = listener.local_addr().unwrap();
-
-        let task = tokio::spawn({
-            let tracker = tracker.clone();
-            let app_factory = app_factory;
-            async move {
-                let (stream, _) = listener.accept().await.unwrap();
-                spawn_connection_task::<_, ()>(stream, app_factory, None, None, &tracker);
-                tracker.close();
-                tracker.wait().await;
-            }
-        });
-
-        let client = TcpStream::connect(addr).await.unwrap();
-        client.writable().await.unwrap();
-        client.try_write(&[0; 8]).unwrap();
-        drop(client);
-
-        task.await.unwrap();
-        tokio::task::yield_now().await;
-
-        let metrics = snapshotter.snapshot().into_vec();
-        let found = metrics.iter().any(|(k, _, _, v)| {
-            k.key().name() == crate::metrics::CONNECTION_PANICS
-                && matches!(v, DebugValue::Counter(c) if *c > 0)
-        });
-        assert!(found, "connection panic metric not recorded");
-    }
 }

tests/metrics.rs

@@ -3,6 +3,7 @@
 //! These tests verify that counters and gauges update as expected using
 //! `metrics_util::debugging::DebuggingRecorder`.
 use metrics_util::debugging::{DebugValue, DebuggingRecorder, Snapshotter};
+use rstest::rstest;
 
 /// Creates a debugging recorder and snapshotter for metrics testing.
 fn debugging_recorder_setup() -> (Snapshotter, DebuggingRecorder) {
@@ -62,22 +63,32 @@ fn error_metric_increments() {
     assert!(found, "error metric not recorded");
 }
 
-#[test]
-fn connection_panic_metric_increments() {
+#[rstest]
+#[case(1)]
+#[case(2)]
+fn inc_connection_panics_counts(#[case] expected: u64) {
+    // Arrange
     let (snapshotter, recorder) = debugging_recorder_setup();
+
+    // Act
     metrics::with_local_recorder(&recorder, || {
-        wireframe::metrics::inc_connection_panics();
+        (0..expected).for_each(|_| wireframe::metrics::inc_connection_panics());
     });
 
+    // Assert
+    assert_counter_eq(
+        &snapshotter,
+        wireframe::metrics::CONNECTION_PANICS,
+        expected,
+    );
+}
+
+fn assert_counter_eq(snapshotter: &Snapshotter, name: &str, expected: u64) {
     let metrics = snapshotter.snapshot().into_vec();
-    let count = metrics
-        .iter()
-        .find_map(|(k, _, _, v)| {
-            (k.key().name() == wireframe::metrics::CONNECTION_PANICS).then_some(match v {
-                DebugValue::Counter(c) => *c,
-                _ => 0,
-            })
-        })
-        .unwrap_or(0);
-    assert_eq!(1, count, "panic metric not recorded");
+    assert!(
+        metrics.iter().any(|(key, _, _, value)| {
+            key.key().name() == name && matches!(value, DebugValue::Counter(c) if *c == expected)
+        }),
+        "expected {name} == {expected}, got {metrics:#?}"
+    );
 }