Lutra/crates/lsp/tests/fake_server.rs
danny 81831c90e0 M3.2: LSP client core (framing, supervision, requests, document sync)
crates/lsp is now a library: Content-Length JSON-RPC framing over stdio
(32 MiB cap, malformed frames dropped and reported, fuzzed), Server::spawn
with initialize/initialized (utf-16, incremental sync, completion, hover,
signatureHelp, definition, references, rename, publishDiagnostics),
typed requests with timeouts and $/cancelRequest, answers to server
requests (configuration nulls, MethodNotFound), events on a bounded
channel, supervision with backoff restarts that reopen documents and
give up after 5 crashes in 2 min, shutdown/exit, and incremental
document sync from lutra_text edits. Tested against a scripted fake
server binary; docs: architecture, G6.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-10-18 00:57:10 +02:00

502 lines
16 KiB
Rust

//! The client against the scripted fake server (`lutra-lsp-fake`):
//! initialize, server requests, requests, queueing, timeout, cancel,
//! document sync, diagnostics, malformed output, crash and restart, giving
//! up, shutdown. One ignored test runs against a real Phpactor.
#![allow(
clippy::unwrap_used,
clippy::expect_used,
clippy::indexing_slicing,
clippy::panic,
clippy::unreachable
)]
use std::path::{Path, PathBuf};
use std::sync::mpsc::{self, Receiver};
use std::sync::{Mutex, MutexGuard};
use std::time::{Duration, Instant};
use lutra_lsp::{
Location, LspError, MessageLevel, RestartPolicy, Server, ServerEvent, ServerOptions, Status,
};
use lutra_text::{Edit, Position};
use serde_json::{Value, json};
const FAKE: &str = env!("CARGO_BIN_EXE_lutra-lsp-fake");
/// How long a test waits for an event. Generous: on a loaded Windows machine
/// starting a fresh executable can stall for many seconds (virus scan).
const WAIT: Duration = Duration::from_secs(60);
/// Serializes the tests: each starts server processes, and many parallel
/// process starts make the scanner stalls above worse.
static SERIAL: Mutex<()> = Mutex::new(());
fn serial() -> MutexGuard<'static, ()> {
SERIAL
.lock()
.unwrap_or_else(std::sync::PoisonError::into_inner)
}
fn options() -> ServerOptions {
ServerOptions {
request_timeout: Duration::from_secs(5),
initialize_timeout: Duration::from_secs(5),
restart: RestartPolicy {
first_delay: Duration::from_millis(20),
max_delay: Duration::from_millis(100),
max_crashes: 5,
window: Duration::from_secs(120),
},
..ServerOptions::default()
}
}
fn spawn(args: &[&str], root: &Path) -> (Server, Receiver<ServerEvent>) {
Server::spawn(FAKE, args, root, options()).unwrap()
}
/// Waits for the first event matching `pred`, returning it and every
/// event seen before it.
fn wait_for(
events: &Receiver<ServerEvent>,
mut pred: impl FnMut(&ServerEvent) -> bool,
) -> (ServerEvent, Vec<ServerEvent>) {
let deadline = Instant::now() + WAIT;
let mut seen = Vec::new();
loop {
let left = deadline.saturating_duration_since(Instant::now());
match events.recv_timeout(left) {
Ok(event) if pred(&event) => return (event, seen),
Ok(event) => seen.push(event),
Err(_) => panic!("event not seen; got {seen:#?}"),
}
}
}
fn wait_ready(events: &Receiver<ServerEvent>) -> Vec<ServerEvent> {
wait_for(events, |e| *e == ServerEvent::Status(Status::Ready)).1
}
/// Waits for diagnostics of `path` and returns (version, message).
fn wait_diagnostics(events: &Receiver<ServerEvent>, path: &Path) -> (Option<i64>, String) {
let (event, _) = wait_for(
events,
|e| matches!(e, ServerEvent::Diagnostics(d) if d.path.as_deref() == Some(path)),
);
let ServerEvent::Diagnostics(d) = event else {
unreachable!()
};
let message = d
.diagnostics
.first()
.map(|d| d.message.clone())
.unwrap_or_default();
(d.version, message)
}
fn notification(events: &Receiver<ServerEvent>, name: &str) -> Value {
let (event, _) = wait_for(
events,
|e| matches!(e, ServerEvent::Notification { method, .. } if method == name),
);
let ServerEvent::Notification { params, .. } = event else {
unreachable!()
};
params
}
fn php_file(root: &Path, name: &str) -> PathBuf {
root.join(name)
}
#[test]
fn initializes_and_answers_server_requests() {
let _serial = serial();
let root = tempfile::tempdir().unwrap();
let (server, events) = spawn(&[], root.path());
assert_eq!(server.status(), Status::Starting);
let before = wait_ready(&events);
assert!(before.contains(&ServerEvent::Status(Status::Starting)));
let caps = server.capabilities().unwrap();
assert!(caps.supports("hoverProvider"));
assert!(!caps.supports("renameProvider"));
let params = notification(&events, "fake/serverResponses");
let responses = params["responses"].as_array().unwrap();
let answer = |id: Value| {
responses
.iter()
.find(|r| r["id"] == id)
.map(|r| r["answer"].clone())
.unwrap()
};
assert_eq!(answer(json!("c1")), json!({"result": [null, null]}));
assert_eq!(answer(json!(2)), json!({"error": -32601}));
assert_eq!(answer(json!(3)), json!({"result": null}));
server.shutdown();
}
#[test]
fn delivers_log_and_stderr() {
let _serial = serial();
let root = tempfile::tempdir().unwrap();
let (server, events) = spawn(&[], root.path());
let mut log = false;
let mut stderr = false;
wait_for(&events, |e| {
log |= *e
== ServerEvent::LogMessage {
level: MessageLevel::Info,
message: "hello".into(),
};
stderr |= matches!(e, ServerEvent::Stderr(line) if line.contains("fake server started"));
log && stderr
});
server.shutdown();
}
#[test]
fn typed_requests_and_errors() {
let _serial = serial();
let root = tempfile::tempdir().unwrap();
let (server, events) = spawn(&[], root.path());
let path = php_file(root.path(), "a.php");
let hover = server.hover(&path, Position::new(1, 2)).unwrap();
wait_ready(&events);
assert_eq!(
hover.wait().unwrap()["contents"]["value"],
json!("hover 1:2")
);
let definition = server
.definition(&path, Position::new(3, 4))
.unwrap()
.wait()
.unwrap();
let locations = Location::list_from_json(&definition);
assert_eq!(locations.len(), 1);
assert_eq!(locations[0].path.as_deref(), Some(path.as_path()));
assert_eq!(locations[0].range.start, Position::new(3, 4));
let error = server.request("fake/error", Value::Null).unwrap().wait();
assert!(matches!(
error,
Err(LspError::Response { code: -32001, .. })
));
let unknown = server.request("fake/nothing", Value::Null).unwrap().wait();
assert!(matches!(
unknown,
Err(LspError::Response { code: -32601, .. })
));
let (sender, outcome) = mpsc::channel();
server
.request_with(
"fake/echo",
json!({"x": 1}),
Duration::from_secs(5),
Box::new(move |result| sender.send(result).unwrap()),
)
.unwrap();
assert_eq!(
outcome.recv_timeout(WAIT).unwrap().unwrap(),
json!({"x": 1})
);
server.shutdown();
}
#[test]
fn timeout_sends_cancel() {
let _serial = serial();
let root = tempfile::tempdir().unwrap();
let (server, events) = spawn(&[], root.path());
wait_ready(&events);
let started = Instant::now();
let handle = server
.request_timeout("fake/sleep", Value::Null, Duration::from_millis(200))
.unwrap();
let id = handle.id().0;
assert!(matches!(
handle.wait(),
Err(LspError::Timeout { method }) if method == "fake/sleep"
));
assert!(started.elapsed() >= Duration::from_millis(200));
assert_eq!(notification(&events, "fake/cancelled")["id"], json!(id));
server.shutdown();
}
#[test]
fn cancel_resolves_and_notifies() {
let _serial = serial();
let root = tempfile::tempdir().unwrap();
let (server, events) = spawn(&[], root.path());
wait_ready(&events);
let handle = server.request("fake/sleep", Value::Null).unwrap();
assert!(handle.wait_timeout(Duration::from_millis(50)).is_none());
assert!(handle.cancel());
assert_eq!(handle.wait(), Err(LspError::Cancelled));
assert_eq!(
notification(&events, "fake/cancelled")["id"],
json!(handle.id().0)
);
assert!(!handle.cancel());
server.shutdown();
}
#[test]
fn incremental_sync_matches_client_copy() {
let _serial = serial();
let root = tempfile::tempdir().unwrap();
let (server, events) = spawn(&[], root.path());
let path = php_file(root.path(), "a.php");
assert_eq!(
server.did_open(&path, "php", "<?php\r\necho 1;\n").unwrap(),
1
);
assert!(matches!(
server.did_open(&path, "php", ""),
Err(LspError::AlreadyOpen { .. })
));
wait_ready(&events);
assert_eq!(
wait_diagnostics(&events, &path),
(Some(1), "<?php\r\necho 1;\n".to_string())
);
let version = server
.did_change(
&path,
&[
Edit::insert(0, "😀"),
Edit::replace(12..13, "2"),
Edit::insert(15, "$x = '€';\n"),
],
)
.unwrap();
assert_eq!(version, 2);
let text = server.document_text(&path).unwrap();
assert_eq!(text, "😀<?php\r\necho 2;\n$x = '€';\n");
assert_eq!(wait_diagnostics(&events, &path), (Some(2), text.clone()));
assert!(matches!(
server.did_change(&path, &[Edit::insert(1, "x")]),
Err(LspError::Text(_))
));
assert_eq!(server.document_version(&path), Some(2));
assert_eq!(server.did_change_full(&path, "<?php\n").unwrap(), 3);
assert_eq!(
wait_diagnostics(&events, &path),
(Some(3), "<?php\n".to_string())
);
server.did_save(&path).unwrap();
assert_eq!(
notification(&events, "fake/saved")["text"],
json!("<?php\n")
);
server.did_close(&path).unwrap();
let (event, _) = wait_for(&events, |e| matches!(e, ServerEvent::Diagnostics(_)));
let ServerEvent::Diagnostics(d) = event else {
unreachable!()
};
assert!(d.diagnostics.is_empty());
assert!(matches!(
server.did_close(&path),
Err(LspError::NotOpen { .. })
));
server.shutdown();
}
#[test]
fn full_sync_sends_whole_text() {
let _serial = serial();
let root = tempfile::tempdir().unwrap();
let (server, events) = spawn(&["--sync-full"], root.path());
wait_ready(&events);
let path = php_file(root.path(), "b.php");
server.did_open(&path, "php", "ab").unwrap();
wait_diagnostics(&events, &path);
server.did_change(&path, &[Edit::insert(1, "X")]).unwrap();
assert_eq!(
wait_diagnostics(&events, &path),
(Some(2), "aXb".to_string())
);
server.shutdown();
}
#[test]
fn malformed_output_is_dropped_and_logged() {
let _serial = serial();
let root = tempfile::tempdir().unwrap();
let (server, events) = spawn(&[], root.path());
wait_ready(&events);
let result = server.request("fake/garbage", Value::Null).unwrap().wait();
assert_eq!(result.unwrap(), json!("after garbage"));
let errors = || {
let mut count = 0;
while let Ok(event) = events.recv_timeout(Duration::from_millis(200)) {
if matches!(event, ServerEvent::ProtocolError(_)) {
count += 1;
}
}
count
};
assert!(errors() >= 3);
assert_eq!(server.status(), Status::Ready);
server.shutdown();
}
#[test]
fn crash_restarts_and_reopens_documents() {
let _serial = serial();
let root = tempfile::tempdir().unwrap();
let mut slow = options();
slow.restart.first_delay = Duration::from_millis(300);
slow.restart.max_delay = Duration::from_secs(1);
let (server, events) = Server::spawn(FAKE, Vec::<String>::new(), root.path(), slow).unwrap();
let path = php_file(root.path(), "c.php");
server.did_open(&path, "php", "one").unwrap();
wait_ready(&events);
wait_diagnostics(&events, &path);
server
.did_change(&path, &[Edit::replace(0..3, "two")])
.unwrap();
wait_diagnostics(&events, &path);
let sleeper = server.request("fake/sleep", Value::Null).unwrap();
let crash = server.request("fake/crash", Value::Null).unwrap();
assert_eq!(crash.wait(), Err(LspError::ServerCrashed));
assert_eq!(sleeper.wait(), Err(LspError::ServerCrashed));
let (event, _) = wait_for(&events, |e| {
matches!(e, ServerEvent::Status(Status::Restarting { .. }))
});
let ServerEvent::Status(Status::Restarting { crashes, delay, .. }) = event else {
unreachable!()
};
assert_eq!(crashes, 1);
assert_eq!(delay, Duration::from_millis(300));
server.did_change(&path, &[Edit::insert(3, "!")]).unwrap();
wait_ready(&events);
assert_eq!(
wait_diagnostics(&events, &path),
(Some(3), "two!".to_string())
);
let echo = server.request("fake/echo", json!(5)).unwrap().wait();
assert_eq!(echo.unwrap(), json!(5));
server.shutdown();
}
#[test]
fn initialize_error_counts_as_crash() {
let _serial = serial();
let root = tempfile::tempdir().unwrap();
let (server, events) = spawn(&["--init-error"], root.path());
let (event, _) = wait_for(&events, |e| {
matches!(e, ServerEvent::Status(Status::Restarting { .. }))
});
let ServerEvent::Status(Status::Restarting { reason, .. }) = event else {
unreachable!()
};
assert!(reason.contains("initialize failed"), "{reason}");
server.shutdown();
}
#[test]
fn gives_up_after_too_many_crashes() {
let _serial = serial();
let root = tempfile::tempdir().unwrap();
let (server, events) = spawn(&["--exit-immediately"], root.path());
let queued = server.request("fake/echo", Value::Null).unwrap();
let (event, seen) = wait_for(&events, |e| {
matches!(e, ServerEvent::Status(Status::Failed { .. }))
});
assert!(matches!(event, ServerEvent::Status(Status::Failed { .. })));
let delays: Vec<Duration> = seen
.iter()
.filter_map(|e| match e {
ServerEvent::Status(Status::Restarting { delay, .. }) => Some(*delay),
_ => None,
})
.collect();
assert_eq!(
delays,
[20, 40, 80, 100].map(Duration::from_millis).to_vec()
);
assert_eq!(queued.wait(), Err(LspError::Stopped));
assert!(matches!(
server.request("fake/echo", Value::Null),
Err(LspError::Stopped)
));
assert!(matches!(server.status(), Status::Failed { .. }));
server.shutdown();
}
#[test]
fn shutdown_stops_and_fails_pending() {
let _serial = serial();
let root = tempfile::tempdir().unwrap();
let (server, events) = spawn(&[], root.path());
wait_ready(&events);
let sleeper = server.request("fake/sleep", Value::Null).unwrap();
let started = Instant::now();
server.shutdown();
assert!(started.elapsed() < Duration::from_secs(4));
assert_eq!(sleeper.wait(), Err(LspError::Stopped));
wait_for(&events, |e| *e == ServerEvent::Status(Status::Stopped));
}
#[test]
fn spawn_errors() {
let _serial = serial();
let root = tempfile::tempdir().unwrap();
let missing = Server::spawn(
root.path().join("no-such-server"),
Vec::<String>::new(),
root.path(),
options(),
);
assert!(matches!(missing, Err(LspError::Spawn { .. })));
let relative = Server::spawn(FAKE, Vec::<String>::new(), Path::new("rel"), options());
assert!(matches!(relative, Err(LspError::InvalidPath { .. })));
}
/// Runs against a real Phpactor: `LUTRA_PHPACTOR` is the path to
/// `phpactor.phar` (or an executable `phpactor`), `LUTRA_PHP` the PHP
/// executable (default `php`).
#[test]
#[ignore = "needs a Phpactor install (LUTRA_PHPACTOR)"]
fn real_phpactor() {
let _serial = serial();
let phpactor = std::env::var("LUTRA_PHPACTOR").expect("LUTRA_PHPACTOR");
let root = tempfile::tempdir().unwrap();
let file = root.path().join("a.php");
let text =
"<?php\nclass Foo { public function bar(): int { return 1; } }\n(new Foo())->bar();\n";
std::fs::write(&file, text).unwrap();
let (command, args) = if phpactor.ends_with(".phar") {
(
std::env::var("LUTRA_PHP").unwrap_or_else(|_| "php".into()),
vec![phpactor.clone(), "language-server".into()],
)
} else {
(phpactor.clone(), vec!["language-server".into()])
};
let started = Instant::now();
let (server, events) = Server::spawn(
command,
args,
root.path(),
ServerOptions {
initialize_timeout: Duration::from_secs(30),
..ServerOptions::default()
},
)
.unwrap();
server.did_open(&file, "php", text).unwrap();
wait_ready(&events);
println!("phpactor ready after {:?}", started.elapsed());
let started = Instant::now();
let definition = server
.definition(&file, Position::new(2, 14))
.unwrap()
.wait()
.unwrap();
println!("definition after {:?}: {definition}", started.elapsed());
assert!(!Location::list_from_json(&definition).is_empty());
let started = Instant::now();
let hover = server.hover(&file, Position::new(2, 14)).unwrap().wait();
println!("hover after {:?}: {hover:?}", started.elapsed());
server.shutdown();
}