test: widen event coverage — cost.rs, daily/cost stats, OTEL payload shape

- cost: test_estimate_gpt4o_exact, case_insensitive, free_model, fallback_exact
- storage_json: test_get_event_stats_daily_counts_and_total_cost (daily_counts + total_cost_estimate)
- state: test_emit_wide_event_payload_has_otel_shape (@timestamp, event.name, review)

Made-with: Cursor

Author: haasonsaas

src/server/cost.rs

@@ -63,4 +63,27 @@ mod tests {
         let cost = estimate_cost_usd("unknown-model-xyz", 1_000_000);
         assert_eq!(cost, FALLBACK_PRICE_PER_M);
     }
+
+    #[test]
+    fn test_estimate_gpt4o_exact() {
+        // 1M tokens × $2.5/M = $2.5
+        assert_eq!(estimate_cost_usd("gpt-4o", 1_000_000), 2.5);
+    }
+
+    #[test]
+    fn test_estimate_case_insensitive() {
+        assert_eq!(estimate_cost_usd("GPT-4O", 1_000_000), 2.5);
+        assert_eq!(estimate_cost_usd("Claude-Opus-4", 2_000_000), 10.0);
+    }
+
+    #[test]
+    fn test_estimate_free_model() {
+        assert_eq!(estimate_cost_usd("nemotron-3-nano", 1_000_000), 0.0);
+    }
+
+    #[test]
+    fn test_estimate_fallback_exact() {
+        let cost = estimate_cost_usd("custom-xyz", 500_000);
+        assert_eq!(cost, 0.5);
+    }
 }

src/server/state.rs

@@ -832,6 +832,36 @@ mod tests {
         assert_eq!(count_diff_files(diff), 2);
     }
 
+    #[test]
+    fn test_emit_wide_event_payload_has_otel_shape() {
+        let event = ReviewEventBuilder::new("r-otel", "review.completed", "head", "gpt-4o")
+            .duration_ms(100)
+            .build();
+        let timestamp = event
+            .created_at
+            .map(|t| t.to_rfc3339())
+            .unwrap_or_else(|| chrono::Utc::now().to_rfc3339());
+        let payload = serde_json::json!({
+            "@timestamp": timestamp,
+            "event": { "name": "review.event", "kind": "event" },
+            "review": event
+        });
+        let json = serde_json::to_string(&payload).unwrap();
+        assert!(
+            json.contains("@timestamp"),
+            "OTEL payload must include @timestamp"
+        );
+        assert!(
+            json.contains("\"name\":\"review.event\""),
+            "OTEL payload must include event.name for filtering"
+        );
+        assert!(
+            json.contains("\"review\""),
+            "OTEL payload must include review object"
+        );
+        assert!(json.contains("r-otel"), "payload must contain review_id");
+    }
+
     #[test]
     fn test_review_event_builder_minimal() {
         let event = ReviewEventBuilder::new("r1", "review.completed", "head", "gpt-4o").build();

src/server/storage_json.rs

@@ -1219,6 +1219,90 @@ mod tests {
         assert_eq!(stats.by_repo[0].avg_score, Some(9.0_f64));
     }
 
+    #[tokio::test]
+    async fn test_get_event_stats_daily_counts_and_total_cost() {
+        let dir = tempfile::tempdir().unwrap();
+        let backend = JsonStorageBackend::new(&dir.path().join("reviews.json"));
+
+        let day1 = chrono::NaiveDate::from_ymd_opt(2025, 3, 1)
+            .unwrap()
+            .and_hms_opt(10, 0, 0)
+            .unwrap()
+            .and_utc();
+        let day2 = chrono::NaiveDate::from_ymd_opt(2025, 3, 2)
+            .unwrap()
+            .and_hms_opt(10, 0, 0)
+            .unwrap()
+            .and_utc();
+
+        let mut s1 = make_session_with_event(
+            "r1",
+            0,
+            ReviewStatus::Complete,
+            "review.completed",
+            "gpt-4o",
+            "head",
+            100,
+        );
+        if let Some(ref mut e) = s1.event {
+            e.created_at = Some(day1);
+            e.cost_estimate_usd = Some(1.5);
+        }
+        let mut s2 = make_session_with_event(
+            "r2",
+            1,
+            ReviewStatus::Failed,
+            "review.failed",
+            "gpt-4o",
+            "head",
+            200,
+        );
+        if let Some(ref mut e) = s2.event {
+            e.created_at = Some(day1);
+            e.cost_estimate_usd = Some(0.5);
+        }
+        let mut s3 = make_session_with_event(
+            "r3",
+            2,
+            ReviewStatus::Complete,
+            "review.completed",
+            "gpt-4o",
+            "staged",
+            300,
+        );
+        if let Some(ref mut e) = s3.event {
+            e.created_at = Some(day2);
+            e.cost_estimate_usd = Some(2.0);
+        }
+
+        backend.save_review(&s1).await.unwrap();
+        backend.save_review(&s2).await.unwrap();
+        backend.save_review(&s3).await.unwrap();
+
+        let stats = backend
+            .get_event_stats(&EventFilters::default())
+            .await
+            .unwrap();
+
+        assert_eq!(stats.daily_counts.len(), 2, "expected two distinct days");
+        let day1_entry = stats
+            .daily_counts
+            .iter()
+            .find(|d| d.date == "2025-03-01")
+            .unwrap();
+        assert_eq!(day1_entry.completed, 1);
+        assert_eq!(day1_entry.failed, 1);
+        let day2_entry = stats
+            .daily_counts
+            .iter()
+            .find(|d| d.date == "2025-03-02")
+            .unwrap();
+        assert_eq!(day2_entry.completed, 1);
+        assert_eq!(day2_entry.failed, 0);
+
+        assert_eq!(stats.total_cost_estimate, 4.0, "1.5 + 0.5 + 2.0");
+    }
+
     // ---------------------------------------------------------------
     // 7. is_empty (via internal state check)
     // ---------------------------------------------------------------