build.rs builds the string (git, or SLINUXM_* env for builds without .git) and the lib exposes it as VERSION. --version, /healthz, /api/v1/ping, MCP server info and OTel service.version use it; OpenAPI info.version stays on the semver so docs/openapi.json does not change per commit. The flake passes the commit date and short rev to the package.
360 lines
12 KiB
Rust
360 lines
12 KiB
Rust
//! 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 version = smoke.cli(&["--version"]);
|
|
let stamped = version.trim().strip_prefix("slinuxm ").unwrap_or_default();
|
|
assert!(
|
|
skyg_linux_tracker::version::is_valid(stamped),
|
|
"--version printed {version:?}, want `slinuxm YYYY.MM.DD-<branch>-<sha>`"
|
|
);
|
|
|
|
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");
|
|
}
|