fix: cover uncovered lines from claim check PR

rsworkspace/crates/trogon-nats/src/jetstream/claim_check.rs

@@ -241,6 +241,29 @@ mod tests {
         let stripped = strip_claim_headers(headers);
         assert_eq!(stripped.get("X-Custom").unwrap().as_str(), "value");
     }
+
+    #[test]
+    fn claim_resolve_error_display_missing_key() {
+        let err: ClaimResolveError<String> = ClaimResolveError::MissingKey;
+        let msg = err.to_string();
+        assert!(msg.contains(HEADER_CLAIM_KEY));
+    }
+
+    #[test]
+    fn claim_resolve_error_display_store_failed() {
+        let err: ClaimResolveError<String> =
+            ClaimResolveError::StoreFailed("connection refused".to_string());
+        let msg = err.to_string();
+        assert!(msg.contains("connection refused"));
+    }
+
+    #[test]
+    fn claim_resolve_error_display_read_failed() {
+        let io_err = std::io::Error::new(std::io::ErrorKind::BrokenPipe, "pipe broke");
+        let err: ClaimResolveError<String> = ClaimResolveError::ReadFailed(io_err);
+        let msg = err.to_string();
+        assert!(msg.contains("pipe broke"));
+    }
 }
 
 #[cfg(all(test, feature = "test-support"))]

rsworkspace/crates/trogon-nats/src/jetstream/mocks.rs

@@ -832,4 +832,22 @@ mod tests {
             vec![AckKindSnapshot::AckWith(AckKindValue::Next)]
         );
     }
+
+    #[test]
+    fn mock_object_store_default() {
+        let store = MockObjectStore::default();
+        assert!(store.stored_objects().is_empty());
+    }
+
+    #[tokio::test]
+    async fn mock_object_store_fail_next_get() {
+        let store = MockObjectStore::new();
+        store.seed("key", Bytes::from("data"));
+        store.fail_next_get();
+        let result = ObjectStoreGet::get(&store, "key").await;
+        assert!(result.is_err());
+
+        let result = ObjectStoreGet::get(&store, "key").await;
+        assert!(result.is_ok());
+    }
 }

rsworkspace/crates/trogon-nats/src/jetstream/publish.rs

@@ -102,4 +102,11 @@ mod tests {
         let outcome: PublishOutcome<String> = PublishOutcome::Published;
         outcome.log_on_error("test");
     }
+
+    #[test]
+    fn log_on_error_logs_store_failed() {
+        let err: Box<dyn std::error::Error + Send + Sync> = "store down".into();
+        let outcome: PublishOutcome<String> = PublishOutcome::StoreFailed(err);
+        outcome.log_on_error("test");
+    }
 }

rsworkspace/crates/trogon-source-slack/src/server.rs

@@ -1431,4 +1431,22 @@ mod tests {
         assert_eq!(resp.status(), StatusCode::BAD_REQUEST);
         assert_unroutable(&publisher, "missing_interaction_type");
     }
+
+    #[tokio::test]
+    async fn router_with_system_clock_responds_to_health() {
+        let publisher = MockJetStreamPublisher::new();
+        let app = router(wrap_publisher(publisher), &test_config());
+
+        let resp = app
+            .oneshot(
+                Request::builder()
+                    .uri("/health")
+                    .body(Body::empty())
+                    .unwrap(),
+            )
+            .await
+            .unwrap();
+
+        assert_eq!(resp.status(), StatusCode::OK);
+    }
 }

rsworkspace/crates/trogon-std/src/http.rs

@@ -33,4 +33,9 @@ mod tests {
         let size = HttpBodySizeMax::new(ByteSize::mib(1)).unwrap();
         assert_eq!(size.as_usize(), 1024 * 1024);
     }
+
+    #[test]
+    fn new_zero_returns_none() {
+        assert!(HttpBodySizeMax::new(ByteSize::b(0)).is_none());
+    }
 }