//! 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) { 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, mut pred: impl FnMut(&ServerEvent) -> bool, ) -> (ServerEvent, Vec) { 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) -> Vec { wait_for(events, |e| *e == ServerEvent::Status(Status::Ready)).1 } /// Waits for diagnostics of `path` and returns (version, message). fn wait_diagnostics(events: &Receiver, path: &Path) -> (Option, 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, 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", "= 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::::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 = 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::::new(), root.path(), options(), ); assert!(matches!(missing, Err(LspError::Spawn { .. }))); let relative = Server::spawn(FAKE, Vec::::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 = "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(); }