test(acp-nats): add coverage for client/mod.rs helpers and dispatcher

Add unit tests for the previously uncovered code in client/mod.rs:
- jsonrpc_error_response: valid id, code, and message serialization
- extract_request_id: valid id, missing id, and invalid JSON
- handle_client_request: dispatches SessionUpdate to the handler

These cover the private helpers and the dispatch path that cannot be
reached through run() without a live NATS subscriber.

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

Author: yordis

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

@@ -192,19 +192,35 @@ async fn handle_client_request<
 #[cfg(test)]
 mod tests {
     use super::*;
-    use agent_client_protocol::{RequestPermissionRequest, RequestPermissionResponse};
+    use crate::session_id::AcpSessionId;
+    use agent_client_protocol::{
+        ContentBlock, ContentChunk, RequestPermissionRequest, RequestPermissionResponse,
+        SessionNotification, SessionUpdate,
+    };
     use async_trait::async_trait;
+    use std::cell::RefCell;
     use trogon_nats::MockNatsClient;
     use trogon_std::time::SystemClock;
 
-    struct MockClient;
+    struct MockClient {
+        notifications: RefCell<Vec<String>>,
+    }
+
+    impl MockClient {
+        fn new() -> Self {
+            Self {
+                notifications: RefCell::new(Vec::new()),
+            }
+        }
+    }
 
     #[async_trait(?Send)]
     impl Client for MockClient {
         async fn session_notification(
             &self,
-            _: agent_client_protocol::SessionNotification,
+            n: agent_client_protocol::SessionNotification,
         ) -> agent_client_protocol::Result<()> {
+            self.notifications.borrow_mut().push(format!("{:?}", n));
             Ok(())
         }
 
@@ -228,8 +244,79 @@ mod tests {
             &opentelemetry::global::meter("acp-nats-test"),
             crate::config::Config::for_test("acp"),
         ));
-        let client = Rc::new(MockClient);
+        let client = Rc::new(MockClient::new());
 
         run(nats, client, bridge).await;
     }
+
+    #[test]
+    fn jsonrpc_error_response_contains_code_and_message() {
+        let bytes = jsonrpc_error_response(
+            serde_json::Value::Number(1.into()),
+            ErrorCode::InvalidParams,
+            "bad input",
+        );
+        let v: serde_json::Value = serde_json::from_slice(&bytes).unwrap();
+        assert_eq!(v["jsonrpc"], "2.0");
+        assert_eq!(v["id"], 1);
+        assert_eq!(v["error"]["message"], "bad input");
+        assert_eq!(v["error"]["code"], i32::from(ErrorCode::InvalidParams));
+    }
+
+    #[test]
+    fn extract_request_id_returns_id_from_valid_payload() {
+        let payload = br#"{"jsonrpc":"2.0","id":42,"method":"foo"}"#;
+        let id = extract_request_id(payload);
+        assert_eq!(id, serde_json::Value::Number(42.into()));
+    }
+
+    #[test]
+    fn extract_request_id_returns_null_for_missing_id() {
+        let payload = br#"{"jsonrpc":"2.0","method":"foo"}"#;
+        let id = extract_request_id(payload);
+        assert_eq!(id, serde_json::Value::Null);
+    }
+
+    #[test]
+    fn extract_request_id_returns_null_for_invalid_json() {
+        let id = extract_request_id(b"not json");
+        assert_eq!(id, serde_json::Value::Null);
+    }
+
+    #[tokio::test]
+    async fn handle_client_request_dispatches_session_update() {
+        let nats = MockNatsClient::new();
+        let bridge = Bridge::new(
+            nats.clone(),
+            SystemClock,
+            &opentelemetry::global::meter("acp-nats-test"),
+            crate::config::Config::for_test("acp"),
+        );
+        let client = MockClient::new();
+        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,
+        };
+
+        handle_client_request(
+            "acp.sess-1.client.session.update",
+            parsed,
+            payload,
+            None,
+            &nats,
+            &client,
+            &bridge,
+        )
+        .await;
+
+        assert_eq!(client.notifications.borrow().len(), 1);
+    }
 }