test(acp-nats): cover TerminalKillFailingClient and jsonrpc_error_response for coverage gate

Author: yordis

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

@@ -37,15 +37,9 @@ fn jsonrpc_error_response(
             "message": message
         }
     });
-    serde_json::to_vec(&response).unwrap_or_else(|e| {
-        format!(
-            "{{\"jsonrpc\":\"2.0\",\"id\":null,\"error\":{{\"code\":{},\"message\":\"failed to serialize error response: {}\"}}}}",
-            i32::from(code),
-            e
-        )
-        .into_bytes()
-    })
-    .into()
+    serde_json::to_vec(&response)
+        .expect("serializing JSON-RPC error response should not fail")
+        .into()
 }
 
 async fn publish_backpressure_error_reply<N: PublishClient + FlushClient, S: JsonSerialize>(
@@ -301,6 +295,7 @@ mod tests {
         KillTerminalCommandRequest, KillTerminalCommandResponse, ReadTextFileRequest,
         ReadTextFileResponse, Request, RequestId, RequestPermissionOutcome,
         RequestPermissionRequest, RequestPermissionResponse, SessionNotification, SessionUpdate,
+        ToolCallUpdate, ToolCallUpdateFields,
     };
     use async_trait::async_trait;
     use std::cell::RefCell;
@@ -849,6 +844,150 @@ mod tests {
         assert_eq!(nats.published_messages(), vec!["_INBOX.reply"]);
     }
 
+    #[tokio::test]
+    async fn dispatch_client_method_dispatches_session_update_with_terminal_kill_failing_client() {
+        let nats = MockNatsClient::new();
+        let client = TerminalKillFailingClient;
+        let session_id = AcpSessionId::new("sess-1").unwrap();
+
+        let notification = SessionNotification::new(
+            "sess-1",
+            SessionUpdate::AgentMessageChunk(ContentChunk::new(ContentBlock::from("hi"))),
+        );
+        let payload = bytes::Bytes::from(serde_json::to_vec(&notification).unwrap());
+
+        let parsed = crate::nats::ParsedClientSubject {
+            session_id,
+            method: ClientMethod::SessionUpdate,
+        };
+
+        let ctx = DispatchContext {
+            nats: &nats,
+            client: &client,
+            serializer: &StdJsonSerialize,
+        };
+        dispatch_client_method(
+            "acp.sess-1.client.session.update",
+            parsed,
+            payload,
+            None,
+            &ctx,
+        )
+        .await;
+    }
+
+    #[tokio::test]
+    async fn dispatch_client_method_dispatches_fs_read_text_file_with_terminal_kill_failing_client()
+    {
+        let nats = MockNatsClient::new();
+        let client = TerminalKillFailingClient;
+        let session_id = AcpSessionId::new("sess-1").unwrap();
+
+        let envelope = Request {
+            id: RequestId::Number(1),
+            method: std::sync::Arc::from("fs/read_text_file"),
+            params: Some(ReadTextFileRequest::new(
+                agent_client_protocol::SessionId::from("sess-1"),
+                "/tmp/foo.txt".to_string(),
+            )),
+        };
+        let payload = bytes::Bytes::from(serde_json::to_vec(&envelope).unwrap());
+
+        let parsed = crate::nats::ParsedClientSubject {
+            session_id,
+            method: ClientMethod::FsReadTextFile,
+        };
+
+        let ctx = DispatchContext {
+            nats: &nats,
+            client: &client,
+            serializer: &StdJsonSerialize,
+        };
+        dispatch_client_method(
+            "acp.sess-1.client.fs.read_text_file",
+            parsed,
+            payload,
+            Some("_INBOX.reply".to_string()),
+            &ctx,
+        )
+        .await;
+
+        assert_eq!(nats.published_messages(), vec!["_INBOX.reply"]);
+    }
+
+    #[tokio::test]
+    async fn dispatch_client_method_dispatches_terminal_create_with_terminal_kill_failing_client() {
+        let nats = MockNatsClient::new();
+        let client = TerminalKillFailingClient;
+        let session_id = AcpSessionId::new("sess-1").unwrap();
+
+        let envelope = Request {
+            id: RequestId::Number(1),
+            method: std::sync::Arc::from("terminal/create"),
+            params: Some(CreateTerminalRequest::new("sess-1", "echo hi")),
+        };
+        let payload = bytes::Bytes::from(serde_json::to_vec(&envelope).unwrap());
+
+        let parsed = crate::nats::ParsedClientSubject {
+            session_id,
+            method: ClientMethod::TerminalCreate,
+        };
+
+        let ctx = DispatchContext {
+            nats: &nats,
+            client: &client,
+            serializer: &StdJsonSerialize,
+        };
+        dispatch_client_method(
+            "acp.sess-1.client.terminal.create",
+            parsed,
+            payload,
+            Some("_INBOX.reply".to_string()),
+            &ctx,
+        )
+        .await;
+
+        assert_eq!(nats.published_messages(), vec!["_INBOX.reply"]);
+    }
+
+    #[tokio::test]
+    async fn dispatch_client_method_dispatches_request_permission_with_terminal_kill_failing_client()
+     {
+        let nats = MockNatsClient::new();
+        let client = TerminalKillFailingClient;
+        let session_id = AcpSessionId::new("sess-1").unwrap();
+
+        let tool_call = ToolCallUpdate::new("call-1", ToolCallUpdateFields::new());
+        let request = RequestPermissionRequest::new("sess-1", tool_call, vec![]);
+        let envelope = Request {
+            id: RequestId::Number(1),
+            method: std::sync::Arc::from("session/request_permission"),
+            params: Some(request),
+        };
+        let payload = bytes::Bytes::from(serde_json::to_vec(&envelope).unwrap());
+
+        let parsed = crate::nats::ParsedClientSubject {
+            session_id,
+            method: ClientMethod::SessionRequestPermission,
+        };
+
+        let ctx = DispatchContext {
+            nats: &nats,
+            client: &client,
+            serializer: &StdJsonSerialize,
+        };
+        dispatch_client_method(
+            "acp.sess-1.client.session.request_permission",
+            parsed,
+            payload,
+            Some("_INBOX.reply".to_string()),
+            &ctx,
+        )
+        .await;
+
+        assert_eq!(nats.published_messages(), vec!["_INBOX.reply"]);
+    }
+
     #[tokio::test]
     async fn dispatch_client_method_dispatches_fs_read_text_file_with_advanced_mock() {
         let nats = AdvancedMockNatsClient::new();