Files
codex/codex-rs/tui/src/app_server_session/fs_preview_tests.rs
T
Felipe Coury 59d8c79789 Add app-server file preview read helpers (#61887)
## What changed

Add session helpers to resolve file paths against the source thread's workspace and read preview bytes through `fs/readFile`. Require a workspace on the app-server host, restrict reads to POSIX paths, and reject reads when the workspace changes.

Add text document validation that rejects invalid UTF-8 and control characters other than tabs and line endings.

## Testing

Add a mock WebSocket app-server test covering source-thread metadata requests, relative path resolution, large text reads, invalid UTF-8, binary content, and workspace changes during a read.

GitOrigin-RevId: b51cb227e478d72cba42309828e40bbffff6d847
2026-11-16 21:46:24 +00:00

90 lines
3.6 KiB
Rust

#![cfg(test)]
use super::*;
use crate::app_server_session::ThreadParamsMode;
use crate::backend_id::BackendId;
use codex_app_server_protocol::JSONRPCMessage;
use futures::SinkExt;
use futures::StreamExt;
use pretty_assertions::assert_eq;
use tokio::net::TcpListener;
use tokio_tungstenite::tungstenite::Message;
#[tokio::test]
async fn remote_preview_requests_the_source_thread_and_validates_text() -> Result<()> {
let listener = TcpListener::bind("127.0.0.1:0").await?;
let endpoint = crate::resolve_remote_addr(&format!("ws://{}", listener.local_addr()?))?;
let source = ThreadId::new();
let text = "\tfirst\r\nsecond\n".repeat(80_000);
let encoded_text = STANDARD.encode(&text);
let server = tokio::spawn(async move {
let (stream, _) = listener.accept().await?;
let mut socket = tokio_tungstenite::accept_async(stream).await?;
let mut workspace = "/workspace";
let mut responses = [
encoded_text,
STANDARD.encode([0xff]),
STANDARD.encode(b"bad\0"),
STANDARD.encode("stale"),
]
.into_iter();
while let Some(Ok(Message::Text(wire))) = socket.next().await {
let JSONRPCMessage::Request(request) = serde_json::from_str(&wire)? else {
continue;
};
let mut reply = match request.method.as_str() {
"initialize" => json!({"result": {"userAgent": "reader-test/1"}}),
"thread/read" => {
let params: codex_app_server_protocol::ThreadReadParams =
serde_json::from_value(request.params.expect("thread params"))?;
assert_eq!(
params,
codex_app_server_protocol::ThreadReadParams {
thread_id: source.to_string(),
include_turns: false,
}
);
json!({"result": {"thread": {"environments": [
{"environmentId": "local", "cwd": workspace, "runtimeWorkspaceRoots": []}
]}}})
}
"fs/readFile" => {
assert_eq!(request.params, Some(json!({"path": "/workspace/notes.md"})));
let data_base64 = responses.next().expect("one preview request per case");
if responses.len() == 0 {
workspace = "/other";
}
json!({"result": {"dataBase64": data_base64}})
}
method => panic!("unexpected RPC: {method}"),
};
reply["id"] = json!(request.id);
socket.send(Message::Text(reply.to_string().into())).await?;
}
assert!(responses.next().is_none());
Ok::<_, color_eyre::Report>(())
});
let session = AppServerSession::new(
BackendId::new(),
crate::connect_remote_app_server(endpoint).await?,
ThreadParamsMode::Remote,
);
let path = AppServerPath::from_app_server("notes.md");
let resolved = session.resolve_thread_file(source, &path).await?;
assert_eq!(session.read_document(source, &path, &resolved).await?, text);
for expected in [
"Not a UTF-8 text file",
"Not a text file",
"Workspace changed",
] {
let error = session
.read_document(source, &path, &resolved)
.await
.unwrap_err();
assert!(format!("{error:#}").contains(expected), "{error:#}");
}
session.shutdown().await?;
server.await??;
Ok(())
}