Merge branch 'test/binary-smoke' into integration/phase2
This commit is contained in:
commit
31c44c74d5
3 files changed
+361
No files matched your search
@@ -166,6 +166,14 @@ Metrics are polled every `metrics_interval_secs` (systemd unit active/failed/res
|
||||
ldd /usr/local/bin/slinuxm # libc, libm, libgcc_s, libsystemd and its dependencies only
|
||||
```
|
||||
|
||||
## Testing
|
||||
|
||||
```sh
|
||||
devenv shell -- smoke # same as: cargo test --test binary_smoke -- --nocapture
|
||||
```
|
||||
|
||||
The smoke test runs the real built `slinuxm` binary against a throwaway SQLite database in a temp directory: it creates a token with the CLI, starts `serve` on a free loopback port, exercises `/healthz`, REST and MCP with and without the token, revokes the token, and checks a clean SIGTERM exit and a 0600 database. It needs no root and no network. Checks that depend on host data (systemd over D-Bus, the journal) are skipped with a printed reason when the source is unavailable; Docker is never required.
|
||||
|
||||
## Development
|
||||
|
||||
```sh
|
||||
|
||||
@@ -18,6 +18,7 @@
|
||||
|
||||
scripts.build.exec = ''cargo build "$@"'';
|
||||
scripts.run.exec = ''cargo run -- "$@"'';
|
||||
scripts.smoke.exec = "cargo test --test binary_smoke -- --nocapture";
|
||||
scripts.token.exec = ''cargo run -- token "$@"'';
|
||||
|
||||
enterShell = ''
|
||||
|
||||
@@ -0,0 +1,352 @@
|
||||
//! End-to-end smoke test of the real `slinuxm` binary against a temp-dir
|
||||
//! SQLite database: token CLI, `serve`, REST, MCP, revocation, SIGTERM.
|
||||
//!
|
||||
//! Run with `devenv shell -- smoke` or `cargo test --test binary_smoke -- --nocapture`.
|
||||
//! Needs no root and no network (loopback only). Assertions that depend on
|
||||
//! host data sources (D-Bus, journal) are skipped with a printed reason when
|
||||
//! the source is unavailable; Docker is never required.
|
||||
|
||||
use std::io::{Read, Write};
|
||||
use std::net::TcpStream;
|
||||
use std::os::unix::fs::PermissionsExt;
|
||||
use std::path::{Path, PathBuf};
|
||||
use std::process::{Child, Command, Stdio};
|
||||
use std::time::{Duration, Instant};
|
||||
|
||||
mod common;
|
||||
|
||||
const BIN: &str = env!("CARGO_BIN_EXE_slinuxm");
|
||||
|
||||
/// Owns the temp dir and the server child; both are cleaned up on drop,
|
||||
/// including when an assertion panics.
|
||||
struct Smoke {
|
||||
dir: PathBuf,
|
||||
child: Option<Child>,
|
||||
port: u16,
|
||||
}
|
||||
|
||||
impl Drop for Smoke {
|
||||
fn drop(&mut self) {
|
||||
if let Some(mut c) = self.child.take() {
|
||||
let _ = c.kill();
|
||||
let _ = c.wait();
|
||||
}
|
||||
let _ = std::fs::remove_dir_all(&self.dir);
|
||||
}
|
||||
}
|
||||
|
||||
impl Smoke {
|
||||
fn new() -> Self {
|
||||
let nanos = std::time::SystemTime::now()
|
||||
.duration_since(std::time::UNIX_EPOCH)
|
||||
.unwrap()
|
||||
.subsec_nanos();
|
||||
let dir =
|
||||
std::env::temp_dir().join(format!("slinuxm-smoke-{}-{nanos}", std::process::id()));
|
||||
std::fs::create_dir(&dir).unwrap();
|
||||
std::fs::set_permissions(&dir, std::fs::Permissions::from_mode(0o700)).unwrap();
|
||||
Smoke {
|
||||
dir,
|
||||
child: None,
|
||||
port: 0,
|
||||
}
|
||||
}
|
||||
|
||||
fn db(&self) -> PathBuf {
|
||||
self.dir.join("db.sqlite")
|
||||
}
|
||||
|
||||
fn write_config(&self) {
|
||||
let cfg = format!(
|
||||
"[server]\nbind = \"127.0.0.1\"\nport = {}\n\n[server.tls]\nenabled = false\n\n\
|
||||
[auth]\nenabled = true\ndb_path = \"{}\"\n\n[otel]\nenabled = false\n",
|
||||
self.port,
|
||||
self.db().display()
|
||||
);
|
||||
std::fs::write(self.dir.join("config.toml"), cfg).unwrap();
|
||||
}
|
||||
|
||||
/// Run the binary with a clean environment (only PATH) and our config.
|
||||
fn command(&self, args: &[&str]) -> Command {
|
||||
let mut c = Command::new(BIN);
|
||||
c.arg("--config")
|
||||
.arg(self.dir.join("config.toml"))
|
||||
.args(args)
|
||||
.env_clear()
|
||||
.env("PATH", std::env::var_os("PATH").unwrap_or_default());
|
||||
c
|
||||
}
|
||||
|
||||
fn cli(&self, args: &[&str]) -> String {
|
||||
let out = self.command(args).output().unwrap();
|
||||
assert!(
|
||||
out.status.success(),
|
||||
"slinuxm {args:?} failed: {}",
|
||||
String::from_utf8_lossy(&out.stderr)
|
||||
);
|
||||
String::from_utf8(out.stdout).unwrap()
|
||||
}
|
||||
|
||||
/// Start `serve` on a fresh loopback port. A port picked by bind-then-drop
|
||||
/// can be taken before the server binds it, so retry with a new port when
|
||||
/// the child exits early or never answers.
|
||||
fn start_server(&mut self) {
|
||||
for attempt in 1..=5 {
|
||||
self.port = std::net::TcpListener::bind("127.0.0.1:0")
|
||||
.unwrap()
|
||||
.local_addr()
|
||||
.unwrap()
|
||||
.port();
|
||||
self.write_config();
|
||||
let mut child = self
|
||||
.command(&["serve"])
|
||||
.stdin(Stdio::null())
|
||||
.stdout(Stdio::null())
|
||||
.stderr(Stdio::null())
|
||||
.spawn()
|
||||
.unwrap();
|
||||
let deadline = Instant::now() + Duration::from_secs(15);
|
||||
while Instant::now() < deadline {
|
||||
if child.try_wait().unwrap().is_some() {
|
||||
break;
|
||||
}
|
||||
if let Some((200, ..)) = try_get(self.port, "/healthz", &[]) {
|
||||
self.child = Some(child);
|
||||
return;
|
||||
}
|
||||
std::thread::sleep(Duration::from_millis(50));
|
||||
}
|
||||
let _ = child.kill();
|
||||
let _ = child.wait();
|
||||
eprintln!(
|
||||
"smoke: server start attempt {attempt} failed (port {}), retrying",
|
||||
self.port
|
||||
);
|
||||
}
|
||||
panic!("server did not become healthy after 5 attempts");
|
||||
}
|
||||
}
|
||||
|
||||
fn exchange(port: u16, req: &str, timeout: Duration) -> Option<(u16, String, String)> {
|
||||
let mut s = TcpStream::connect(("127.0.0.1", port)).ok()?;
|
||||
s.set_read_timeout(Some(Duration::from_millis(300))).ok()?;
|
||||
s.write_all(req.as_bytes()).ok()?;
|
||||
let mut buf = Vec::new();
|
||||
let mut chunk = [0u8; 4096];
|
||||
let deadline = Instant::now() + timeout;
|
||||
while Instant::now() < deadline {
|
||||
match s.read(&mut chunk) {
|
||||
Ok(0) => break,
|
||||
Ok(n) => {
|
||||
buf.extend_from_slice(&chunk[..n]);
|
||||
// SSE responses may stay open; stop once a JSON-RPC payload arrived.
|
||||
if rpc_result(&String::from_utf8_lossy(&buf)).is_some() {
|
||||
break;
|
||||
}
|
||||
}
|
||||
Err(e)
|
||||
if matches!(
|
||||
e.kind(),
|
||||
std::io::ErrorKind::WouldBlock | std::io::ErrorKind::TimedOut
|
||||
) => {}
|
||||
Err(_) => break,
|
||||
}
|
||||
}
|
||||
if buf.is_empty() {
|
||||
return None;
|
||||
}
|
||||
Some(common::parse_response(&buf))
|
||||
}
|
||||
|
||||
fn try_get(port: u16, path: &str, headers: &[(&str, &str)]) -> Option<(u16, String, String)> {
|
||||
let req = common::request("GET", path, &format!("127.0.0.1:{port}"), headers, None);
|
||||
exchange(port, &req, Duration::from_secs(10))
|
||||
}
|
||||
|
||||
fn get(port: u16, path: &str, headers: &[(&str, &str)]) -> (u16, String, String) {
|
||||
try_get(port, path, headers).unwrap_or_else(|| panic!("no response for GET {path}"))
|
||||
}
|
||||
|
||||
/// First JSON value in `text` (a line, optionally `data:`-prefixed) that
|
||||
/// carries a JSON-RPC `result`.
|
||||
fn rpc_result(text: &str) -> Option<serde_json::Value> {
|
||||
text.lines().find_map(|l| {
|
||||
let l = l.trim().strip_prefix("data:").unwrap_or(l.trim()).trim();
|
||||
let v: serde_json::Value = serde_json::from_str(l).ok()?;
|
||||
v.get("result")?;
|
||||
Some(v)
|
||||
})
|
||||
}
|
||||
|
||||
fn mcp_post(port: u16, token: &str, session: Option<&str>, body: &str) -> (u16, String, String) {
|
||||
let auth = format!("Bearer {token}");
|
||||
let mut headers = vec![
|
||||
("Authorization", auth.as_str()),
|
||||
("Content-Type", "application/json"),
|
||||
("Accept", "application/json, text/event-stream"),
|
||||
];
|
||||
if let Some(s) = session {
|
||||
headers.push(("Mcp-Session-Id", s));
|
||||
}
|
||||
let req = common::request(
|
||||
"POST",
|
||||
"/mcp",
|
||||
&format!("127.0.0.1:{port}"),
|
||||
&headers,
|
||||
Some(body),
|
||||
);
|
||||
exchange(port, &req, Duration::from_secs(10)).expect("no response to POST /mcp")
|
||||
}
|
||||
|
||||
fn skip(what: &str, status: u16, body: &str) {
|
||||
println!(
|
||||
"SKIP: {what}: host source unavailable (HTTP {status}: {})",
|
||||
body.trim()
|
||||
);
|
||||
}
|
||||
|
||||
fn wait_exit(child: &mut Child, within: Duration) -> std::process::ExitStatus {
|
||||
let start = Instant::now();
|
||||
loop {
|
||||
if let Some(st) = child.try_wait().unwrap() {
|
||||
return st;
|
||||
}
|
||||
assert!(
|
||||
start.elapsed() < within,
|
||||
"no exit within {within:?} of SIGTERM"
|
||||
);
|
||||
std::thread::sleep(Duration::from_millis(50));
|
||||
}
|
||||
}
|
||||
|
||||
fn assert_mode(path: &Path, want: u32) {
|
||||
let mode = std::fs::metadata(path).unwrap().permissions().mode() & 0o777;
|
||||
assert_eq!(
|
||||
mode,
|
||||
want,
|
||||
"{} mode is {mode:o}, want {want:o}",
|
||||
path.display()
|
||||
);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn binary_end_to_end() {
|
||||
let mut smoke = Smoke::new();
|
||||
// The token CLI needs a config; the port is rewritten when serve starts.
|
||||
smoke.port = 1; // placeholder; start_server picks a real port
|
||||
smoke.write_config();
|
||||
|
||||
let out = smoke.cli(&["token", "create", "smoke"]);
|
||||
let token = out.trim().to_owned();
|
||||
assert!(
|
||||
!token.is_empty() && !token.contains(char::is_whitespace),
|
||||
"token: {out:?}"
|
||||
);
|
||||
assert!(
|
||||
smoke.db().exists(),
|
||||
"token create did not create the database"
|
||||
);
|
||||
assert!(smoke.cli(&["token", "list"]).contains("smoke"));
|
||||
|
||||
smoke.start_server();
|
||||
let port = smoke.port;
|
||||
println!("smoke: server healthy on 127.0.0.1:{port}");
|
||||
let auth = format!("Bearer {token}");
|
||||
let bearer = [("Authorization", auth.as_str())];
|
||||
|
||||
// Public health, protected API.
|
||||
let (s, ..) = get(port, "/healthz", &[]);
|
||||
assert_eq!(s, 200);
|
||||
let (s, head, _) = get(port, "/api/v1/systemd/units", &[]);
|
||||
assert_eq!(s, 401);
|
||||
assert!(head.contains("www-authenticate"), "head: {head}");
|
||||
let (s, ..) = get(
|
||||
port,
|
||||
"/api/v1/systemd/units",
|
||||
&[("Authorization", "Bearer slinuxm_bogus")],
|
||||
);
|
||||
assert_eq!(s, 401);
|
||||
|
||||
// Real host sources: tolerate absence of D-Bus / journal.
|
||||
let (s, _, body) = get(port, "/api/v1/systemd/units", &bearer);
|
||||
if s == 200 {
|
||||
assert!(
|
||||
serde_json::from_str::<serde_json::Value>(&body).is_ok(),
|
||||
"units body: {body}"
|
||||
);
|
||||
println!("ok: systemd units list");
|
||||
} else {
|
||||
skip("systemd units", s, &body);
|
||||
}
|
||||
let (s, _, body) = get(port, "/api/v1/journal?lines=5", &bearer);
|
||||
if s == 200 {
|
||||
assert!(
|
||||
serde_json::from_str::<serde_json::Value>(&body).is_ok(),
|
||||
"journal body: {body}"
|
||||
);
|
||||
println!("ok: journal query");
|
||||
} else {
|
||||
skip("journal query", s, &body);
|
||||
}
|
||||
|
||||
// MCP: initialize, initialized, tools/list.
|
||||
let init = r#"{"jsonrpc":"2.0","id":1,"method":"initialize","params":{"protocolVersion":"2025-03-26","capabilities":{},"clientInfo":{"name":"smoke","version":"0"}}}"#;
|
||||
let (s, head, body) = mcp_post(port, &token, None, init);
|
||||
assert_eq!(s, 200, "initialize: {head} {body}");
|
||||
assert!(rpc_result(&body).is_some(), "initialize body: {body}");
|
||||
let sid = head
|
||||
.lines()
|
||||
.find_map(|l| l.strip_prefix("mcp-session-id:"))
|
||||
.expect("mcp-session-id header")
|
||||
.trim()
|
||||
.to_owned();
|
||||
let (s, ..) = mcp_post(
|
||||
port,
|
||||
&token,
|
||||
Some(&sid),
|
||||
r#"{"jsonrpc":"2.0","method":"notifications/initialized"}"#,
|
||||
);
|
||||
assert_eq!(s, 202);
|
||||
let (s, _, body) = mcp_post(
|
||||
port,
|
||||
&token,
|
||||
Some(&sid),
|
||||
r#"{"jsonrpc":"2.0","id":2,"method":"tools/list"}"#,
|
||||
);
|
||||
assert_eq!(s, 200, "tools/list: {body}");
|
||||
let v = rpc_result(&body).expect("tools/list result");
|
||||
let tools = v["result"]["tools"].as_array().expect("tools array");
|
||||
assert_eq!(tools.len(), 8, "tools: {tools:?}");
|
||||
println!("ok: MCP initialize + tools/list ({} tools)", tools.len());
|
||||
|
||||
// MCP without a token is rejected.
|
||||
let req = common::request(
|
||||
"POST",
|
||||
"/mcp",
|
||||
&format!("127.0.0.1:{port}"),
|
||||
&[
|
||||
("Content-Type", "application/json"),
|
||||
("Accept", "application/json, text/event-stream"),
|
||||
],
|
||||
Some(init),
|
||||
);
|
||||
assert_eq!(exchange(port, &req, Duration::from_secs(5)).unwrap().0, 401);
|
||||
|
||||
assert_mode(&smoke.db(), 0o600);
|
||||
|
||||
// Revocation takes effect without a restart.
|
||||
smoke.cli(&["token", "revoke", "smoke"]);
|
||||
let (s, ..) = get(port, "/api/v1/systemd/units", &bearer);
|
||||
assert_eq!(s, 401, "revoked token still accepted");
|
||||
|
||||
// Clean shutdown on SIGTERM.
|
||||
let mut child = smoke.child.take().unwrap();
|
||||
assert!(Command::new("kill")
|
||||
.args(["-TERM", &child.id().to_string()])
|
||||
.status()
|
||||
.unwrap()
|
||||
.success());
|
||||
let st = wait_exit(&mut child, Duration::from_secs(5));
|
||||
assert!(st.success(), "exit status {st}");
|
||||
println!("ok: clean SIGTERM exit");
|
||||
}
|
||||
Reference in new issue
Block a user