test: update protocol fixtures

1 files changed, 30 insertions, 27 deletions

diff --git a/tests/client_mode.rs b/tests/client_mode.rs
index 8aea0dda..25e7d42c 100644
--- a/tests/client_mode.rs
+++ b/tests/client_mode.rs
@@ -167,6 +167,7 @@ struct FrameWire {
     height: u16,
     cursor: Option<CursorWire>,
     hyperlinks: Vec<String>,
+    graphics: Vec<u8>,
 }
 
 #[allow(dead_code)]
@@ -219,7 +220,7 @@ fn frame_contains_text(frame: &FrameWire, needle: &str) -> bool {
         }
         text.push('\n');
     }
-    let _ = frame.height;
+    let _ = (frame.height, frame.graphics.len());
     if let Some(cursor) = frame.cursor.as_ref() {
         let _ = (cursor.x, cursor.y, cursor.visible);
     }
@@ -250,8 +251,8 @@ fn client_connects_and_receives_frame() {
     // Connect and handshake.
     let mut stream = UnixStream::connect(&client_socket).expect("should connect to client socket");
     let (version, error) =
-        client_handshake(&mut stream, 4, 80, 24).expect("handshake should succeed");
-    assert_eq!(version, 4, "server should report protocol version 4");
+        client_handshake(&mut stream, 5, 80, 24).expect("handshake should succeed");
+    assert_eq!(version, 5, "server should report protocol version 5");
     assert!(
         error.is_none(),
         "handshake should not have error: {:?}",
@@ -330,8 +331,8 @@ fn client_sees_headless_startup_config_diagnostic() {
 
     let mut stream = UnixStream::connect(&client_socket).expect("should connect to client socket");
     let (version, error) =
-        client_handshake(&mut stream, 4, 80, 24).expect("handshake should succeed");
-    assert_eq!(version, 4);
+        client_handshake(&mut stream, 5, 80, 24).expect("handshake should succeed");
+    assert_eq!(version, 5);
     assert!(error.is_none(), "{:?}", error);
 
     stream
@@ -379,8 +380,8 @@ fn client_input_forwarded_to_pane() {
     // Connect and handshake.
     let mut stream = UnixStream::connect(&client_socket).expect("should connect to client socket");
     let (version, error) =
-        client_handshake(&mut stream, 4, 80, 24).expect("handshake should succeed");
-    assert_eq!(version, 4);
+        client_handshake(&mut stream, 5, 80, 24).expect("handshake should succeed");
+    assert_eq!(version, 5);
     assert!(error.is_none(), "{:?}", error);
 
     // Send an Input message containing "echo hello\n".
@@ -433,8 +434,8 @@ fn client_resize_sends_message() {
     // Connect and handshake.
     let mut stream = UnixStream::connect(&client_socket).expect("should connect to client socket");
     let (version, error) =
-        client_handshake(&mut stream, 4, 80, 24).expect("handshake should succeed");
-    assert_eq!(version, 4);
+        client_handshake(&mut stream, 5, 80, 24).expect("handshake should succeed");
+    assert_eq!(version, 5);
     assert!(error.is_none(), "{:?}", error);
 
     // Drain the initial frame(s).
@@ -443,11 +444,13 @@ fn client_resize_sends_message() {
         .unwrap();
     while read_server_message(&mut stream).is_ok() {}
 
-    // Send a Resize message: ClientMessage::Resize is variant 2: { cols: u16, rows: u16 }
+    // Send a Resize message: ClientMessage::Resize is variant 2.
     let resize_payload = {
         let mut buf = encode_varint_u32(2); // variant 2 = Resize
         buf.extend_from_slice(&encode_varint_u16(120)); // cols
         buf.extend_from_slice(&encode_varint_u16(40)); // rows
+        buf.extend_from_slice(&encode_varint_u32(8)); // cell_width_px
+        buf.extend_from_slice(&encode_varint_u32(16)); // cell_height_px
         buf
     };
     let framed = frame_message(&resize_payload);
@@ -490,8 +493,8 @@ fn server_shutdown_sends_message_to_client() {
     // Connect and handshake.
     let mut stream = UnixStream::connect(&client_socket).expect("should connect to client socket");
     let (version, error) =
-        client_handshake(&mut stream, 4, 80, 24).expect("handshake should succeed");
-    assert_eq!(version, 4);
+        client_handshake(&mut stream, 5, 80, 24).expect("handshake should succeed");
+    assert_eq!(version, 5);
     assert!(error.is_none(), "{:?}", error);
 
     // Send SIGINT so the server takes the graceful shutdown path and
@@ -718,8 +721,8 @@ fn client_receives_frame_after_pane_output() {
     // Connect and handshake.
     let mut stream = UnixStream::connect(&client_socket).expect("should connect to client socket");
     let (version, error) =
-        client_handshake(&mut stream, 4, 80, 24).expect("handshake should succeed");
-    assert_eq!(version, 4);
+        client_handshake(&mut stream, 5, 80, 24).expect("handshake should succeed");
+    assert_eq!(version, 5);
     assert!(error.is_none(), "{:?}", error);
 
     // Read the initial frame (server renders immediately on client connect).
@@ -772,8 +775,8 @@ fn navigate_mode_keybind_dispatch_in_server() {
     // Connect and handshake.
     let mut stream = UnixStream::connect(&client_socket).expect("should connect to client socket");
     let (version, error) =
-        client_handshake(&mut stream, 4, 80, 24).expect("handshake should succeed");
-    assert_eq!(version, 4);
+        client_handshake(&mut stream, 5, 80, 24).expect("handshake should succeed");
+    assert_eq!(version, 5);
     assert!(error.is_none(), "{:?}", error);
 
     // Drain initial frames.
@@ -890,8 +893,8 @@ fn graceful_shutdown_sends_server_shutdown_to_client() {
     // Connect and handshake.
     let mut stream = UnixStream::connect(&client_socket).expect("should connect to client socket");
     let (version, error) =
-        client_handshake(&mut stream, 4, 80, 24).expect("handshake should succeed");
-    assert_eq!(version, 4);
+        client_handshake(&mut stream, 5, 80, 24).expect("handshake should succeed");
+    assert_eq!(version, 5);
     assert!(error.is_none(), "{:?}", error);
 
     // Drain initial frame(s).
@@ -907,7 +910,7 @@ fn graceful_shutdown_sends_server_shutdown_to_client() {
         }
     }
 
-    // The client should receive a ServerShutdown message (variant 3)
+    // The client should receive a ServerShutdown message (variant 4)
     // before the connection is closed, not just an abrupt EOF.
     stream
         .set_read_timeout(Some(Duration::from_secs(5)))
@@ -916,8 +919,8 @@ fn graceful_shutdown_sends_server_shutdown_to_client() {
     match result {
         Ok((variant, _payload)) => {
             assert_eq!(
-                variant, 3,
-                "expected ServerShutdown (variant 3), got variant {variant}"
+                variant, 4,
+                "expected ServerShutdown (variant 4), got variant {variant}"
             );
         }
         Err(e) => {
@@ -988,8 +991,8 @@ fn client_receives_notify_on_agent_state_change() {
     // Connect as a client and perform handshake.
     let mut stream = UnixStream::connect(&client_socket).expect("should connect");
     let (version, error) =
-        client_handshake(&mut stream, 4, 80, 24).expect("handshake should succeed");
-    assert_eq!(version, 4);
+        client_handshake(&mut stream, 5, 80, 24).expect("handshake should succeed");
+    assert_eq!(version, 5);
     assert!(error.is_none(), "{:?}", error);
 
     // Drain initial frame(s).
@@ -1040,8 +1043,8 @@ fn client_receives_notify_on_agent_state_change() {
     let mut report_response = String::new();
     report_reader.read_line(&mut report_response).unwrap();
 
-    // Read messages from the client stream and look for Notify (variant 4).
-    // Notify = ServerMessage variant index 4 (after Welcome=0, Frame=1, Terminal=2, ServerShutdown=3).
+    // Read messages from the client stream and look for Notify (variant 5).
+    // Notify = ServerMessage variant index 5.
     stream
         .set_read_timeout(Some(Duration::from_secs(5)))
         .unwrap();
@@ -1050,7 +1053,7 @@ fn client_receives_notify_on_agent_state_change() {
     while Instant::now() < deadline {
         match read_server_message(&mut stream) {
             Ok((variant, _payload)) => {
-                if variant == 4 {
+                if variant == 5 {
                     // ServerMessage::Notify — found it!
                     found_notify = true;
                     break;
@@ -1136,7 +1139,7 @@ fn client_receives_notify_on_agent_state_change() {
     while Instant::now() < deadline {
         match read_server_message(&mut stream) {
             Ok((variant, _payload)) => {
-                if variant == 4 {
+                if variant == 5 {
                     // Found a Notify message — that's good enough.
                     // The test already verified the Blocked→Notify path above.
                     found_done_notify = true;