test(trogon-github): cover ack failure and ack timeout handler paths

Signed-off-by: Yordis Prieto <yordis.prieto@gmail.com>

Author: yordis

rsworkspace/crates/trogon-github/src/server.rs

@@ -458,4 +458,125 @@ mod tests {
         assert_eq!(resp.status(), StatusCode::OK);
         assert_eq!(publisher.published_payloads(), vec![Bytes::new()]);
     }
+
+    // ── ack failure / timeout paths ──────────────────────────────────────────
+
+    mod ack_test_support {
+        use super::*;
+        use async_nats::jetstream::publish::PublishAck;
+        use std::sync::Arc;
+        use std::sync::Mutex;
+        use trogon_nats::mocks::MockError;
+
+        #[derive(Clone)]
+        enum AckBehavior {
+            Fail,
+            Hang,
+        }
+
+        #[derive(Clone)]
+        pub struct AckFailPublisher {
+            behavior: Arc<Mutex<AckBehavior>>,
+        }
+
+        impl AckFailPublisher {
+            pub fn failing() -> Self {
+                Self {
+                    behavior: Arc::new(Mutex::new(AckBehavior::Fail)),
+                }
+            }
+
+            pub fn hanging() -> Self {
+                Self {
+                    behavior: Arc::new(Mutex::new(AckBehavior::Hang)),
+                }
+            }
+        }
+
+        pub enum AckFuture {
+            Fail,
+            Hang,
+        }
+
+        impl IntoFuture for AckFuture {
+            type Output = Result<PublishAck, MockError>;
+            type IntoFuture = std::pin::Pin<Box<dyn Future<Output = Self::Output> + Send>>;
+
+            fn into_future(self) -> Self::IntoFuture {
+                match self {
+                    AckFuture::Fail => {
+                        Box::pin(async { Err(MockError("simulated ack failure".to_string())) })
+                    }
+                    AckFuture::Hang => Box::pin(std::future::pending()),
+                }
+            }
+        }
+
+        impl JetStreamPublisher for AckFailPublisher {
+            type PublishError = MockError;
+            type AckFuture = AckFuture;
+
+            async fn publish_with_headers<S: ToSubject + Send>(
+                &self,
+                _subject: S,
+                _headers: async_nats::HeaderMap,
+                _payload: Bytes,
+            ) -> Result<AckFuture, MockError> {
+                let behavior = self.behavior.lock().unwrap().clone();
+                match behavior {
+                    AckBehavior::Fail => Ok(AckFuture::Fail),
+                    AckBehavior::Hang => Ok(AckFuture::Hang),
+                }
+            }
+        }
+    }
+
+    use ack_test_support::AckFailPublisher;
+    use async_nats::subject::ToSubject;
+
+    #[tokio::test]
+    async fn ack_failure_returns_500() {
+        let publisher = AckFailPublisher::failing();
+
+        let state = AppState {
+            js: publisher,
+            webhook_secret: None,
+            subject_prefix: "github".to_string(),
+            nats_ack_timeout: Duration::from_secs(10),
+        };
+
+        let app = Router::new()
+            .route("/webhook", post(handle_webhook::<AckFailPublisher>))
+            .with_state(state);
+
+        let resp = app
+            .oneshot(webhook_request(b"{}", "push", "del-9", None))
+            .await
+            .unwrap();
+
+        assert_eq!(resp.status(), StatusCode::INTERNAL_SERVER_ERROR);
+    }
+
+    #[tokio::test]
+    async fn ack_timeout_returns_500() {
+        let publisher = AckFailPublisher::hanging();
+
+        let state = AppState {
+            js: publisher,
+            webhook_secret: None,
+            subject_prefix: "github".to_string(),
+            nats_ack_timeout: Duration::from_millis(10),
+        };
+
+        let app = Router::new()
+            .route("/webhook", post(handle_webhook::<AckFailPublisher>))
+            .with_state(state);
+
+        let resp = app
+            .oneshot(webhook_request(b"{}", "push", "del-10", None))
+            .await
+            .unwrap();
+
+        assert_eq!(resp.status(), StatusCode::INTERNAL_SERVER_ERROR);
+    }
 }