chore(cymbal): add shimforge to simplify tests

Replace the telemetry HTTP mock and its flush-and-poll loop with a
thread-local shimforge mock of common_posthog::capture_exception. The
test asserts the handoff directly - HTTP 500, exactly one capture,
UnhandledError::SqlxError(PoolClosed), and the request_id,
batch_event_count and team_count properties - instead of polling an HTTP
mock for up to five seconds.

Add shimforge 0.1.3 as a pinned dev-dependency with its lock entries.

Author: tanglearncode

rust/Cargo.lock

@@ -60,6 +60,7 @@ common-temporal = { path = "../common/temporal" }
 
 
 [dev-dependencies]
+shimforge = "=0.1.3"
 common-compression = { path = "../common/compression" }
 # For constructing IO-flavored RedisErrors in redis_heal classifier tests
 redis = { workspace = true }

rust/cymbal/Cargo.toml

@@ -1,47 +1,22 @@
 use std::sync::Arc;
-use std::time::Duration;
 
 use axum::{body::Body, http::Request};
 use common_redis::MockRedisClient;
-use cymbal::{app_context::AppContext, modes::processing::ProcessingConfig, router::get_router};
-use httpmock::prelude::*;
-use serde_json::json;
+use cymbal::{
+    app_context::AppContext, error::UnhandledError, modes::processing::ProcessingConfig,
+    router::get_router,
+};
+use serde_json::{json, Value};
+use shimforge::{mock, Session};
 use sqlx::PgPool;
 use tower::ServiceExt;
 use uuid::Uuid;
 
 mod common;
 mod utils;
 
-// One test per binary: common_posthog::init configures a process-wide global
-// client, so a second init with a different mock server would be ignored.
 #[sqlx::test(migrations = "./tests/test_migrations")]
 async fn pipeline_failure_is_captured_as_posthog_exception(db: PgPool) {
-    let posthog = MockServer::start_async().await;
-    let capture = posthog
-        .mock_async(|when, then| {
-            when.method(POST)
-                .path("/i/v1/analytics/events")
-                .body_contains("\"$exception\"")
-                .body_contains("UnhandledError")
-                .body_contains("\"service\":\"cymbal-test\"")
-                .body_contains("\"request_id\"");
-            then.status(200).body("{\"results\":{}}");
-        })
-        .await;
-    // Catch-all so an unexpected payload shape fails the specific assertion
-    // below instead of surfacing as a connection-level SDK error.
-    let fallback = posthog
-        .mock_async(|when, then| {
-            when.path_contains("/");
-            then.status(200).body("{\"results\":{}}");
-        })
-        .await;
-
-    common_posthog::init("cymbal-test", Some("test-api-key"), &posthog.base_url())
-        .await
-        .expect("posthog init");
-
     let (addr, _) = common::spawn_stub_server(common::ServerBehavior::Happy).await;
     let mut config = ProcessingConfig::init_with_defaults().unwrap();
     config.remote_resolution_host = "127.0.0.1".to_string();
@@ -68,11 +43,32 @@ async fn pipeline_failure_is_captured_as_posthog_exception(db: PgPool) {
         },
     }]);
 
+    // The route calls capture on this task; SDK delivery is covered by
+    // common/posthog/tests/panic_capture.rs.
+    let mut session = Session::new();
+    let capture = mock!(
+        session,
+        common_posthog::capture_exception::<UnhandledError>,
+        fn(Arc<UnhandledError>, [(&'static str, Value); 3])
+    );
+    capture
+        .expect()
+        .with(|error, properties| {
+            matches!(&**error, UnhandledError::SqlxError(sqlx::Error::PoolClosed))
+                && properties.contains(&("request_id", json!("capture-test-request")))
+                && properties.contains(&("batch_event_count", json!(1)))
+                && properties.contains(&("team_count", json!(1)))
+        })
+        .once()
+        .returns_default();
+    // Enforced when `session` drops, not at call time.
+
     let response = router
         .oneshot(
             Request::builder()
                 .method("POST")
                 .header("content-type", "application/json")
+                .header("x-request-id", "capture-test-request")
                 .uri("/process")
                 .body(Body::from(serde_json::to_vec(&event).unwrap()))
                 .unwrap(),
@@ -83,22 +79,4 @@ async fn pipeline_failure_is_captured_as_posthog_exception(db: PgPool) {
         response.status(),
         reqwest::StatusCode::INTERNAL_SERVER_ERROR
     );
-
-    // The capture is fire-and-forget, and the SDK only buffers it: one event
-    // never reaches `flush_at`, so delivery would otherwise wait on the 5s
-    // `flush_interval_ms`. Flush every turn so this waits on the spawned send
-    // rather than racing that interval.
-    for _ in 0..100 {
-        posthog_rs::flush().await;
-        if capture.hits_async().await > 0 {
-            break;
-        }
-        tokio::time::sleep(Duration::from_millis(50)).await;
-    }
-    assert_eq!(
-        capture.hits_async().await,
-        1,
-        "expected a matching $exception capture; total capture requests seen: {}",
-        fallback.hits_async().await
-    );
 }