Lutra/crates/lsp/tests/fake_server.rs
danny 6a844489e8 M3.2: deterministic supervision tests
The give-up test raced its queued request's 5 s timeout against five
restarts under load. Test options now use request and initialize
timeouts far beyond any restart sequence and the 60 s event wait, the
queued request gets an explicit long timeout, the crash test waits for
the reopened text instead of assuming no live change slips in before the
restart, and the echo callback and shutdown bounds get margin.
Five runs in a row with 16 busy loops in parallel: all green.

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

513 lines
17 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)
}
/// Fast restarts, but request and initialize timeouts far beyond any
/// restart sequence and beyond [`WAIT`], so under load a test fails on the
/// event it waits for and never because a timeout raced the supervisor.
fn options() -> ServerOptions {
ServerOptions {
request_timeout: Duration::from_secs(600),
initialize_timeout: Duration::from_secs(600),
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(600),
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);
let deadline = Instant::now() + WAIT;
loop {
let (version, text) = wait_diagnostics(&events, &path);
if text == "two!" {
assert_eq!(version, Some(3));
break;
}
assert_eq!((version, text.as_str()), (Some(2), "two"));
assert!(Instant::now() < deadline, "reopened text never arrived");
}
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_timeout("fake/echo", Value::Null, Duration::from_secs(3600))
.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(10));
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();
}