Initial public release
Luxe 0.1.0: a coding agent harness for the terminal. See README.md to get started and CHANGELOG.md for releases.
This commit is contained in:
137
crates/luxe-lsp/tests/integration_client/failures.rs
Normal file
137
crates/luxe-lsp/tests/integration_client/failures.rs
Normal file
@@ -0,0 +1,137 @@
|
||||
//! Failures — a server that dies at startup, exits silently or dies mid-request.
|
||||
|
||||
use super::*;
|
||||
|
||||
/// A server that starts, complains on stderr, and stops.
|
||||
///
|
||||
/// The commonest real shape of a broken language server, and the one Luxe reported worst: a
|
||||
/// version-manager shim that resolves on `PATH` and then refuses to run. `mise ERROR No version is
|
||||
/// set for shim: pyright-langserver` and rustup's `error: infinite recursion detected` are both
|
||||
/// this, and both were reported as `initialize timed out after 30s` — after waiting the full 30
|
||||
/// seconds for a process that had been dead since millisecond ten.
|
||||
#[tokio::test]
|
||||
async fn a_server_that_dies_at_startup_says_so_at_once_and_in_its_own_words() {
|
||||
let mut client = LspClient::new(LspConfig {
|
||||
command: vec![
|
||||
"sh".to_string(),
|
||||
"-c".to_string(),
|
||||
"echo 'No version is set for shim' >&2; exit 3".to_string(),
|
||||
],
|
||||
server_id: "broken-shim".to_string(),
|
||||
// Long enough that waiting it out would be unmistakable in the elapsed time below.
|
||||
init_timeout: Duration::from_secs(30),
|
||||
root_path: PathBuf::from("/tmp"),
|
||||
});
|
||||
|
||||
let started = std::time::Instant::now();
|
||||
let error = client.initialize().await.expect_err("a server that exits cannot initialize");
|
||||
let elapsed = started.elapsed();
|
||||
|
||||
match error {
|
||||
luxe_lsp::client::LspError::ServerExited { server, status, stderr } => {
|
||||
assert_eq!(server, "broken-shim");
|
||||
assert!(status.contains('3'), "the exit status is part of the answer: {status}");
|
||||
assert!(
|
||||
stderr.contains("No version is set"),
|
||||
"the server's own complaint is the whole point: {stderr:?}"
|
||||
);
|
||||
}
|
||||
other => panic!("expected ServerExited, got: {other:?}"),
|
||||
}
|
||||
assert!(
|
||||
elapsed < Duration::from_secs(5),
|
||||
"a dead server is knowable immediately; this waited {elapsed:?} of a 30s timeout"
|
||||
);
|
||||
}
|
||||
|
||||
/// A server with nothing to say still reports the exit rather than a timeout.
|
||||
///
|
||||
/// Both orderings, because they reach the answer down different paths and only one of them used to
|
||||
/// be covered. A server that is already gone breaks the pipe, so the handshake *write* fails and
|
||||
/// the exit has to be recognized after the fact; one that lingers a moment accepts the write and
|
||||
/// then dies, so the exit wins the race outright. The first is the one that flaked: the exit status
|
||||
/// only becomes collectible once this process is notified, which under load lands after the
|
||||
/// `EPIPE`, and a client that checked once was told "still running" about a process that was
|
||||
/// already gone — reporting a broken pipe instead of an exit.
|
||||
#[tokio::test]
|
||||
async fn a_silent_exit_is_still_an_exit_not_a_timeout() {
|
||||
for (label, script) in
|
||||
[("gone before the write", "exit 0"), ("gone after the write", "sleep 0.2; exit 3")]
|
||||
{
|
||||
let mut client = LspClient::new(LspConfig {
|
||||
command: vec!["sh".to_string(), "-c".to_string(), script.to_string()],
|
||||
server_id: "quiet".to_string(),
|
||||
init_timeout: Duration::from_secs(30),
|
||||
root_path: PathBuf::from("/tmp"),
|
||||
});
|
||||
let error = client.initialize().await.expect_err("an exited server cannot initialize");
|
||||
assert!(
|
||||
matches!(error, luxe_lsp::client::LspError::ServerExited { .. }),
|
||||
"{label}: got {error:?}"
|
||||
);
|
||||
}
|
||||
}
|
||||
|
||||
/// A stub that answers `initialize` and then dies on the next request, mid-handshake-free session.
|
||||
fn write_dying_stub(path: &std::path::Path) {
|
||||
let script = r#"
|
||||
import json, sys
|
||||
|
||||
def read_msg():
|
||||
header = b""
|
||||
while b"\r\n\r\n" not in header:
|
||||
b = sys.stdin.buffer.read(1)
|
||||
if not b: return None
|
||||
header += b
|
||||
for line in header.split(b"\r\n"):
|
||||
if line.lower().startswith(b"content-length:"):
|
||||
n = int(line.split(b":")[1].strip())
|
||||
return json.loads(sys.stdin.buffer.read(n))
|
||||
|
||||
def write_msg(obj):
|
||||
data = json.dumps(obj).encode()
|
||||
sys.stdout.buffer.write(b"Content-Length: %d\r\n\r\n" % len(data))
|
||||
sys.stdout.buffer.write(data)
|
||||
sys.stdout.buffer.flush()
|
||||
|
||||
while True:
|
||||
msg = read_msg()
|
||||
if msg is None: break
|
||||
if msg.get("method") == "initialize":
|
||||
write_msg({"jsonrpc":"2.0","id":msg.get("id"),"result":{"capabilities":{}}})
|
||||
else:
|
||||
# Whatever it was, die without answering — a crash under a real request.
|
||||
sys.exit(9)
|
||||
"#;
|
||||
std::fs::write(path, script).expect("write stub");
|
||||
}
|
||||
|
||||
/// A request in flight when the server dies comes back as an error, rather than never coming back.
|
||||
///
|
||||
/// The reader is the only thing that can answer a request, so when it stops nothing is coming. A
|
||||
/// waiter left in the pending map never resolves: a server that crashed mid-session would become a
|
||||
/// turn that hangs, with no error and nothing in the log. The bound here is the assertion — a
|
||||
/// client that forgets the waiter sits here until the test harness kills it.
|
||||
#[tokio::test]
|
||||
async fn a_request_in_flight_when_the_server_dies_returns_rather_than_hanging() {
|
||||
let scratch = tempfile::tempdir().expect("temp dir");
|
||||
let stub = scratch.path().join("stub_dying.py");
|
||||
write_dying_stub(&stub);
|
||||
|
||||
let mut client = LspClient::new(LspConfig {
|
||||
command: vec!["python3".to_string(), stub.to_string_lossy().to_string()],
|
||||
server_id: "dying".to_string(),
|
||||
init_timeout: Duration::from_secs(10),
|
||||
root_path: PathBuf::from("/tmp"),
|
||||
});
|
||||
client.initialize().await.expect("the stub completes a handshake");
|
||||
|
||||
let answered = timeout(
|
||||
Duration::from_secs(5),
|
||||
client.send_request("textDocument/hover", serde_json::json!({})),
|
||||
)
|
||||
.await;
|
||||
|
||||
assert!(answered.is_ok(), "a dead server's request must resolve, not hang forever");
|
||||
assert!(answered.expect("resolved").is_err(), "and it must resolve as a failure");
|
||||
}
|
||||
Reference in New Issue
Block a user