test(acp-nats): add unit tests for terminal_wait_for_exit to satisfy coverage gate

Author: yordis

rsworkspace/crates/acp-nats/src/client/terminal_wait_for_exit.rs

@@ -105,3 +105,273 @@ fn parse_request(
 
     Ok(request)
 }
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use agent_client_protocol::{
+        Request, RequestId, RequestPermissionRequest, RequestPermissionResponse,
+        SessionNotification, TerminalExitStatus, WaitForTerminalExitRequest,
+        WaitForTerminalExitResponse,
+    };
+    use async_trait::async_trait;
+    use std::time::Duration;
+
+    struct MockClient;
+
+    #[async_trait(?Send)]
+    impl agent_client_protocol::Client for MockClient {
+        async fn session_notification(
+            &self,
+            _: SessionNotification,
+        ) -> agent_client_protocol::Result<()> {
+            Ok(())
+        }
+
+        async fn request_permission(
+            &self,
+            _: RequestPermissionRequest,
+        ) -> agent_client_protocol::Result<RequestPermissionResponse> {
+            Err(agent_client_protocol::Error::new(
+                -32603,
+                "not implemented in test mock",
+            ))
+        }
+
+        async fn wait_for_terminal_exit(
+            &self,
+            _: WaitForTerminalExitRequest,
+        ) -> agent_client_protocol::Result<WaitForTerminalExitResponse> {
+            Ok(WaitForTerminalExitResponse::new(
+                TerminalExitStatus::new().exit_code(0u32),
+            ))
+        }
+    }
+
+    struct FailingClient;
+
+    #[async_trait(?Send)]
+    impl agent_client_protocol::Client for FailingClient {
+        async fn session_notification(
+            &self,
+            _: SessionNotification,
+        ) -> agent_client_protocol::Result<()> {
+            Ok(())
+        }
+
+        async fn request_permission(
+            &self,
+            _: RequestPermissionRequest,
+        ) -> agent_client_protocol::Result<RequestPermissionResponse> {
+            Err(agent_client_protocol::Error::new(
+                -32603,
+                "not implemented in test mock",
+            ))
+        }
+
+        async fn wait_for_terminal_exit(
+            &self,
+            _: WaitForTerminalExitRequest,
+        ) -> agent_client_protocol::Result<WaitForTerminalExitResponse> {
+            Err(agent_client_protocol::Error::new(
+                -32603,
+                "mock wait_for_terminal_exit failure",
+            ))
+        }
+    }
+
+    struct TimeoutClient;
+
+    #[async_trait(?Send)]
+    impl agent_client_protocol::Client for TimeoutClient {
+        async fn session_notification(
+            &self,
+            _: SessionNotification,
+        ) -> agent_client_protocol::Result<()> {
+            Ok(())
+        }
+
+        async fn request_permission(
+            &self,
+            _: RequestPermissionRequest,
+        ) -> agent_client_protocol::Result<RequestPermissionResponse> {
+            Err(agent_client_protocol::Error::new(
+                -32603,
+                "not implemented in test mock",
+            ))
+        }
+
+        async fn wait_for_terminal_exit(
+            &self,
+            _: WaitForTerminalExitRequest,
+        ) -> agent_client_protocol::Result<WaitForTerminalExitResponse> {
+            tokio::time::sleep(Duration::from_secs(60)).await;
+            Ok(WaitForTerminalExitResponse::new(
+                TerminalExitStatus::new().exit_code(0u32),
+            ))
+        }
+    }
+
+    #[tokio::test]
+    async fn handle_success_returns_serialized_response() {
+        let client = MockClient;
+        let envelope = Request {
+            id: RequestId::Number(1),
+            method: std::sync::Arc::from("terminal/wait_for_exit"),
+            params: Some(WaitForTerminalExitRequest::new("sess-1", "term-001")),
+        };
+        let payload = serde_json::to_vec(&envelope).unwrap();
+
+        let result = handle(&payload, &client, "sess-1", Duration::from_secs(5)).await;
+
+        assert!(result.is_ok());
+        let bytes = result.unwrap();
+        let parsed: serde_json::Value = serde_json::from_slice(&bytes).unwrap();
+        assert_eq!(parsed.get("id"), Some(&serde_json::Value::from(1)));
+        assert!(parsed.get("result").is_some());
+    }
+
+    #[tokio::test]
+    async fn handle_malformed_json_returns_error() {
+        let client = MockClient;
+
+        let result = handle(b"not json", &client, "sess-1", Duration::from_secs(5)).await;
+
+        assert!(matches!(
+            result,
+            Err(TerminalWaitForExitError::MalformedJson(_))
+        ));
+    }
+
+    #[tokio::test]
+    async fn handle_invalid_params_returns_error() {
+        let client = MockClient;
+        let payload = br#"{"id":1,"method":"terminal/wait_for_exit","params":{}}"#;
+
+        let result = handle(payload, &client, "sess-1", Duration::from_secs(5)).await;
+
+        assert!(matches!(
+            result,
+            Err(TerminalWaitForExitError::InvalidParams(_))
+        ));
+    }
+
+    #[tokio::test]
+    async fn handle_params_null_returns_error() {
+        let client = MockClient;
+        let payload = br#"{"id":1,"method":"terminal/wait_for_exit","params":null}"#;
+
+        let result = handle(payload, &client, "sess-1", Duration::from_secs(5)).await;
+
+        assert!(matches!(
+            result,
+            Err(TerminalWaitForExitError::InvalidParams(_))
+        ));
+    }
+
+    #[tokio::test]
+    async fn handle_session_id_mismatch_returns_error() {
+        let client = MockClient;
+        let envelope = Request {
+            id: RequestId::Number(1),
+            method: std::sync::Arc::from("terminal/wait_for_exit"),
+            params: Some(WaitForTerminalExitRequest::new("sess-b", "term-001")),
+        };
+        let payload = serde_json::to_vec(&envelope).unwrap();
+
+        let result = handle(&payload, &client, "sess-a", Duration::from_secs(5)).await;
+
+        assert!(matches!(
+            result,
+            Err(TerminalWaitForExitError::InvalidParams(_))
+        ));
+    }
+
+    #[tokio::test]
+    async fn handle_client_error_returns_error() {
+        let client = FailingClient;
+        let envelope = Request {
+            id: RequestId::Number(1),
+            method: std::sync::Arc::from("terminal/wait_for_exit"),
+            params: Some(WaitForTerminalExitRequest::new("sess-1", "term-001")),
+        };
+        let payload = serde_json::to_vec(&envelope).unwrap();
+
+        let result = handle(&payload, &client, "sess-1", Duration::from_secs(5)).await;
+
+        assert!(matches!(
+            result,
+            Err(TerminalWaitForExitError::ClientError(_))
+        ));
+    }
+
+    #[tokio::test]
+    async fn handle_timeout_returns_error() {
+        let client = TimeoutClient;
+        let envelope = Request {
+            id: RequestId::Number(1),
+            method: std::sync::Arc::from("terminal/wait_for_exit"),
+            params: Some(WaitForTerminalExitRequest::new("sess-1", "term-001")),
+        };
+        let payload = serde_json::to_vec(&envelope).unwrap();
+
+        let result = handle(&payload, &client, "sess-1", Duration::from_millis(10)).await;
+
+        assert!(matches!(result, Err(TerminalWaitForExitError::TimedOut)));
+    }
+
+    #[test]
+    fn error_code_and_message_malformed_json() {
+        let err = TerminalWaitForExitError::MalformedJson(
+            serde_json::from_str::<serde_json::Value>("{").unwrap_err(),
+        );
+        let (code, msg) = error_code_and_message(&err);
+        assert_eq!(code, ErrorCode::ParseError);
+        assert!(msg.contains("Malformed terminal/wait_for_exit"));
+    }
+
+    #[test]
+    fn error_code_and_message_invalid_params() {
+        let err = TerminalWaitForExitError::InvalidParams(agent_client_protocol::Error::new(
+            -32602,
+            "bad params",
+        ));
+        let (code, msg) = error_code_and_message(&err);
+        assert_eq!(i32::from(code), -32602);
+        assert_eq!(msg, "bad params");
+    }
+
+    #[test]
+    fn error_code_and_message_timed_out() {
+        let err = TerminalWaitForExitError::TimedOut;
+        let (code, msg) = error_code_and_message(&err);
+        assert_eq!(code, ErrorCode::InternalError);
+        assert_eq!(msg, "Timed out waiting for terminal exit");
+    }
+
+    #[test]
+    fn error_code_and_message_client_error() {
+        let err = TerminalWaitForExitError::ClientError(agent_client_protocol::Error::new(
+            -32603,
+            "client failed",
+        ));
+        let (code, msg) = error_code_and_message(&err);
+        assert_eq!(i32::from(code), -32603);
+        assert_eq!(msg, "client failed");
+    }
+
+    #[test]
+    fn terminal_wait_for_exit_error_display() {
+        let err = TerminalWaitForExitError::TimedOut;
+        assert!(err.to_string().contains("Timed out"));
+    }
+
+    #[test]
+    fn terminal_wait_for_exit_error_source() {
+        let err = TerminalWaitForExitError::TimedOut;
+        assert!(err.source().is_none());
+        let json_err =
+            TerminalWaitForExitError::MalformedJson(serde_json::from_str::<()>("{").unwrap_err());
+        assert!(json_err.source().is_some());
+    }
+}