test(maestro): rework e2e harness for a single daemon
Drops the registry subprocess and the T2 broker scenarios; the harness spawns one daemon and the client talks straight to its /api/* surface.
This commit is contained in:
@@ -1,15 +1,13 @@
|
||||
//! Thin HTTP+WS client used by tests to drive the registry.
|
||||
//!
|
||||
//! Cookies are managed automatically by `reqwest`'s built-in cookie store.
|
||||
//! Thin HTTP+WS client used by tests to drive a daemon's `/api/*` surface.
|
||||
|
||||
#![allow(clippy::result_large_err)]
|
||||
|
||||
use std::sync::Arc;
|
||||
use std::time::Duration;
|
||||
|
||||
use futures_util::{SinkExt, StreamExt};
|
||||
use maestro_protocol::{ConnectInfo, CreateSessionRequest, DaemonInfo, RegistryEvent, Session};
|
||||
use maestro_protocol::{CatalogEvent, CreateSessionRequest, Session};
|
||||
use reqwest::Client as HttpClient;
|
||||
use std::sync::Arc;
|
||||
use tokio_tungstenite::tungstenite::client::IntoClientRequest;
|
||||
use tokio_tungstenite::tungstenite::Message as WsMessage;
|
||||
use tokio_tungstenite::{connect_async, MaybeTlsStream, WebSocketStream};
|
||||
@@ -28,7 +26,7 @@ pub enum ClientError {
|
||||
Status { status: u16, body: String },
|
||||
}
|
||||
|
||||
/// Sticky-cookie HTTP client + a few WS-aware helpers.
|
||||
/// HTTP client plus a few WS-aware helpers, bound to one daemon.
|
||||
#[derive(Debug, Clone)]
|
||||
pub struct TestClient {
|
||||
http_base: String,
|
||||
@@ -39,7 +37,6 @@ pub struct TestClient {
|
||||
impl TestClient {
|
||||
pub fn new(http_base: &str, ws_base: &str) -> Self {
|
||||
let http = HttpClient::builder()
|
||||
.cookie_store(true)
|
||||
.timeout(Duration::from_secs(5))
|
||||
.build()
|
||||
.expect("reqwest client");
|
||||
@@ -50,23 +47,6 @@ impl TestClient {
|
||||
}
|
||||
}
|
||||
|
||||
/// Hit any GET endpoint so the registry issues the auth cookie that all
|
||||
/// subsequent calls reuse.
|
||||
pub async fn bootstrap(&self) -> Result<(), ClientError> {
|
||||
let _ = self.list_daemons().await?;
|
||||
Ok(())
|
||||
}
|
||||
|
||||
pub async fn list_daemons(&self) -> Result<Vec<DaemonInfo>, ClientError> {
|
||||
let r = self
|
||||
.http
|
||||
.get(format!("{}/api/daemons", self.http_base))
|
||||
.send()
|
||||
.await?;
|
||||
check_ok(&r)?;
|
||||
Ok(r.json().await?)
|
||||
}
|
||||
|
||||
pub async fn list_sessions(&self) -> Result<Vec<Session>, ClientError> {
|
||||
let r = self
|
||||
.http
|
||||
@@ -105,50 +85,23 @@ impl TestClient {
|
||||
Ok(())
|
||||
}
|
||||
|
||||
pub async fn connect_info(&self, id: Uuid) -> Result<ConnectInfo, ClientError> {
|
||||
let r = self
|
||||
.http
|
||||
.get(format!("{}/api/sessions/{id}/connect-info", self.http_base))
|
||||
.send()
|
||||
.await?;
|
||||
check_ok(&r)?;
|
||||
Ok(r.json().await?)
|
||||
}
|
||||
|
||||
/// Connect to the daemon's per-session WS and return the stream. The
|
||||
/// caller drives the conversation.
|
||||
pub async fn attach(
|
||||
&self,
|
||||
info: &ConnectInfo,
|
||||
id: Uuid,
|
||||
) -> Result<WebSocketStream<MaybeTlsStream<tokio::net::TcpStream>>, ClientError> {
|
||||
let url = format!(
|
||||
"{}/sessions/{id}/stream?token={}",
|
||||
info.daemon_url.trim_end_matches('/'),
|
||||
info.jwt
|
||||
);
|
||||
let url = format!("{}/api/attach/{id}", self.ws_base);
|
||||
let request = url.into_client_request()?;
|
||||
let (ws, _resp) = connect_async(request).await?;
|
||||
Ok(ws)
|
||||
}
|
||||
|
||||
/// Subscribe to the registry's `/api/events` WS. Returns a tokio task
|
||||
/// handle that drives the WS and pushes parsed events into an Arc<Mutex<Vec>>.
|
||||
/// Subscribe to the daemon's `/api/events` WS. Returns a handle whose
|
||||
/// background task pushes parsed events into a shared vector.
|
||||
pub async fn subscribe_events(&self) -> EventStream {
|
||||
// Forward the latest cookie value with the upgrade — `reqwest` and
|
||||
// `tungstenite` don't share cookie jars, so we copy the cookie out by
|
||||
// hand. The registry will accept us either way (missing cookie just
|
||||
// gets a fresh one), but reusing the same identity keeps log noise
|
||||
// down.
|
||||
let cookie_header = self.grab_cookie().await.unwrap_or_default();
|
||||
let url = format!("{}/api/events", self.ws_base);
|
||||
let mut request = url.into_client_request().expect("ws req");
|
||||
if !cookie_header.is_empty() {
|
||||
request.headers_mut().insert(
|
||||
reqwest::header::COOKIE,
|
||||
cookie_header.parse().expect("cookie hv"),
|
||||
);
|
||||
}
|
||||
let request = url.into_client_request().expect("ws req");
|
||||
let (ws, _resp) = connect_async(request).await.expect("events ws");
|
||||
|
||||
let events = Arc::new(tokio::sync::Mutex::new(Vec::new()));
|
||||
@@ -158,7 +111,7 @@ impl TestClient {
|
||||
while let Some(msg) = stream.next().await {
|
||||
match msg {
|
||||
Ok(WsMessage::Text(t)) => {
|
||||
if let Ok(ev) = serde_json::from_str::<RegistryEvent>(&t) {
|
||||
if let Ok(ev) = serde_json::from_str::<CatalogEvent>(&t) {
|
||||
stream_events.lock().await.push(ev);
|
||||
}
|
||||
}
|
||||
@@ -170,34 +123,6 @@ impl TestClient {
|
||||
});
|
||||
EventStream { events, task }
|
||||
}
|
||||
|
||||
async fn grab_cookie(&self) -> Option<String> {
|
||||
// Force a request to make sure the jar has a cookie, then read it back
|
||||
// via a debug header roundtrip. reqwest's CookieStore isn't directly
|
||||
// exposed; the simplest path is to ask the registry for an auth
|
||||
// cookie and capture the Set-Cookie from the response.
|
||||
let r = self
|
||||
.http
|
||||
.get(format!("{}/api/daemons", self.http_base))
|
||||
.send()
|
||||
.await
|
||||
.ok()?;
|
||||
// The cookie store has the cookie now, but reqwest doesn't surface
|
||||
// it. We rebuild from Set-Cookie if present.
|
||||
r.headers()
|
||||
.get_all(reqwest::header::SET_COOKIE)
|
||||
.iter()
|
||||
.find_map(|hv| hv.to_str().ok().and_then(extract_cookie_pair))
|
||||
}
|
||||
}
|
||||
|
||||
fn extract_cookie_pair(set_cookie: &str) -> Option<String> {
|
||||
// Take everything before the first ';', which is `name=value`.
|
||||
set_cookie
|
||||
.split(';')
|
||||
.next()
|
||||
.map(str::trim)
|
||||
.map(String::from)
|
||||
}
|
||||
|
||||
fn check_ok(r: &reqwest::Response) -> Result<(), ClientError> {
|
||||
@@ -214,12 +139,12 @@ fn check_ok(r: &reqwest::Response) -> Result<(), ClientError> {
|
||||
/// Handle to a background task draining the events WS into a vector.
|
||||
#[derive(Debug)]
|
||||
pub struct EventStream {
|
||||
events: Arc<tokio::sync::Mutex<Vec<RegistryEvent>>>,
|
||||
events: Arc<tokio::sync::Mutex<Vec<CatalogEvent>>>,
|
||||
task: tokio::task::JoinHandle<()>,
|
||||
}
|
||||
|
||||
impl EventStream {
|
||||
pub async fn snapshot(&self) -> Vec<RegistryEvent> {
|
||||
pub async fn snapshot(&self) -> Vec<CatalogEvent> {
|
||||
self.events.lock().await.clone()
|
||||
}
|
||||
}
|
||||
|
||||
@@ -1,4 +1,4 @@
|
||||
//! Subprocess wrapper around `maestrod`.
|
||||
//! Subprocess wrapper around `maestro daemon`.
|
||||
|
||||
use std::net::{Ipv4Addr, SocketAddr};
|
||||
use std::path::PathBuf;
|
||||
@@ -10,68 +10,49 @@ use tempfile::TempDir;
|
||||
use crate::build::workspace_target_bin;
|
||||
use crate::util::{free_port, wait_for_async};
|
||||
|
||||
/// A live `maestrod` running in a child process. Kill the child on drop.
|
||||
/// A live daemon running in a child process. Kill the child on drop.
|
||||
///
|
||||
/// `state_dir`, `home`, and `tmux_tmpdir` are kept as `TempDir`s so they
|
||||
/// outlive the process and get cleaned up automatically.
|
||||
/// `home` and `tmux_tmpdir` are kept as `TempDir`s so they outlive the process
|
||||
/// and get cleaned up automatically. State lives under `home` via
|
||||
/// `XDG_STATE_HOME`.
|
||||
#[derive(Debug)]
|
||||
pub struct Daemon {
|
||||
pub daemon_id: String,
|
||||
pub bind_addr: SocketAddr,
|
||||
pub daemon_url: String,
|
||||
child: Option<Child>,
|
||||
home: TempDir,
|
||||
state: TempDir,
|
||||
tmux: TempDir,
|
||||
registry_url: String,
|
||||
token: String,
|
||||
}
|
||||
|
||||
/// Optional knobs for `Daemon::spawn_with` — perimeter advertisement for
|
||||
/// NAP-247 broker tests.
|
||||
#[derive(Debug, Default, Clone)]
|
||||
pub struct DaemonOptions {
|
||||
pub perimeter_id: Option<String>,
|
||||
pub private_addr: Option<String>,
|
||||
}
|
||||
|
||||
impl Daemon {
|
||||
/// Spawn a fresh daemon pointing at `registry_base_url` (the registry's
|
||||
/// HTTP base, e.g. `http://127.0.0.1:1234`). The daemon derives its WS
|
||||
/// endpoint internally via `derive_daemon_ws_url`.
|
||||
pub async fn spawn(daemon_id: &str, registry_base_url: &str, token: &str) -> Self {
|
||||
Self::spawn_with(
|
||||
daemon_id,
|
||||
registry_base_url,
|
||||
token,
|
||||
DaemonOptions::default(),
|
||||
)
|
||||
.await
|
||||
/// Spawn a fresh daemon on a free localhost port.
|
||||
pub async fn spawn() -> Self {
|
||||
Self::spawn_at(SocketAddr::from((Ipv4Addr::LOCALHOST, free_port()))).await
|
||||
}
|
||||
|
||||
/// Spawn with NAP-247 options (perimeter advertisement).
|
||||
pub async fn spawn_with(
|
||||
daemon_id: &str,
|
||||
registry_base_url: &str,
|
||||
token: &str,
|
||||
opts: DaemonOptions,
|
||||
) -> Self {
|
||||
let port = free_port();
|
||||
let bind = SocketAddr::from((Ipv4Addr::LOCALHOST, port));
|
||||
Self::spawn_with_port_and_opts(daemon_id, registry_base_url, token, bind, opts).await
|
||||
/// Spawn on a caller-supplied bind address.
|
||||
pub async fn spawn_at(bind: SocketAddr) -> Self {
|
||||
let home = TempDir::new().expect("home tmpdir");
|
||||
let tmux = TempDir::new().expect("tmux tmpdir");
|
||||
|
||||
let child = launch(bind, home.path(), tmux.path());
|
||||
let me = Self {
|
||||
bind_addr: bind,
|
||||
child: Some(child),
|
||||
home,
|
||||
tmux,
|
||||
};
|
||||
me.wait_until_ready().await;
|
||||
me
|
||||
}
|
||||
|
||||
/// Spawn on a caller-supplied bind address. Used by NAP-247 broker tests
|
||||
/// where the daemon's advertised `private_addr` must equal the actual
|
||||
/// bind address so the broker can dial it back.
|
||||
pub async fn spawn_at(
|
||||
daemon_id: &str,
|
||||
registry_base_url: &str,
|
||||
token: &str,
|
||||
bind: SocketAddr,
|
||||
opts: DaemonOptions,
|
||||
) -> Self {
|
||||
Self::spawn_with_port_and_opts(daemon_id, registry_base_url, token, bind, opts).await
|
||||
/// HTTP base URL of this daemon's API.
|
||||
pub fn http_base(&self) -> String {
|
||||
format!("http://{}", self.bind_addr)
|
||||
}
|
||||
|
||||
/// WS base URL of this daemon's API.
|
||||
pub fn ws_base(&self) -> String {
|
||||
format!("ws://{}", self.bind_addr)
|
||||
}
|
||||
|
||||
/// Stop the underlying process, but keep its state dirs around so we can
|
||||
@@ -85,70 +66,18 @@ impl Daemon {
|
||||
|
||||
/// Re-spawn the daemon on the same port + state. The previous tmux
|
||||
/// server (under `TMUX_TMPDIR`) is left running so `recover()` can adopt
|
||||
/// its sessions. Restarts inherit the original options via the on-disk
|
||||
/// config file written at `spawn_with_port_and_opts` time.
|
||||
/// its sessions.
|
||||
pub async fn restart(&mut self) {
|
||||
self.stop();
|
||||
let child = launch(
|
||||
&self.daemon_id,
|
||||
self.bind_addr,
|
||||
&self.daemon_url,
|
||||
&self.registry_url,
|
||||
&self.token,
|
||||
self.home.path(),
|
||||
self.state.path(),
|
||||
self.tmux.path(),
|
||||
&DaemonOptions::default(),
|
||||
);
|
||||
self.child = Some(child);
|
||||
self.wait_until_attach_ready().await;
|
||||
self.child = Some(launch(self.bind_addr, self.home.path(), self.tmux.path()));
|
||||
self.wait_until_ready().await;
|
||||
}
|
||||
|
||||
async fn spawn_with_port_and_opts(
|
||||
daemon_id: &str,
|
||||
registry_url: &str,
|
||||
token: &str,
|
||||
bind: SocketAddr,
|
||||
opts: DaemonOptions,
|
||||
) -> Self {
|
||||
let home = TempDir::new().expect("home tmpdir");
|
||||
let state = TempDir::new().expect("state tmpdir");
|
||||
let tmux = TempDir::new().expect("tmux tmpdir");
|
||||
|
||||
let daemon_url = format!("ws://{bind}");
|
||||
let child = launch(
|
||||
daemon_id,
|
||||
bind,
|
||||
&daemon_url,
|
||||
registry_url,
|
||||
token,
|
||||
home.path(),
|
||||
state.path(),
|
||||
tmux.path(),
|
||||
&opts,
|
||||
);
|
||||
let me = Self {
|
||||
daemon_id: daemon_id.to_string(),
|
||||
bind_addr: bind,
|
||||
daemon_url,
|
||||
child: Some(child),
|
||||
home,
|
||||
state,
|
||||
tmux,
|
||||
registry_url: registry_url.to_string(),
|
||||
token: token.to_string(),
|
||||
};
|
||||
me.wait_until_attach_ready().await;
|
||||
me
|
||||
}
|
||||
|
||||
async fn wait_until_attach_ready(&self) {
|
||||
async fn wait_until_ready(&self) {
|
||||
let addr = self.bind_addr;
|
||||
wait_for_async(
|
||||
"daemon attach port",
|
||||
Duration::from_secs(5),
|
||||
|| async move { tokio::net::TcpStream::connect(addr).await.is_ok() },
|
||||
)
|
||||
wait_for_async("daemon api port", Duration::from_secs(5), || async move {
|
||||
tokio::net::TcpStream::connect(addr).await.is_ok()
|
||||
})
|
||||
.await;
|
||||
}
|
||||
|
||||
@@ -158,7 +87,7 @@ impl Daemon {
|
||||
|
||||
pub fn state_dir(&self) -> PathBuf {
|
||||
// Matches maestro_daemon::default_state_dir which uses XDG_STATE_HOME.
|
||||
self.home.path().join(".local/state/maestrod")
|
||||
self.home.path().join(".local/state/maestro")
|
||||
}
|
||||
}
|
||||
|
||||
@@ -171,18 +100,7 @@ impl Drop for Daemon {
|
||||
}
|
||||
}
|
||||
|
||||
#[allow(clippy::too_many_arguments)]
|
||||
fn launch(
|
||||
daemon_id: &str,
|
||||
bind: SocketAddr,
|
||||
daemon_url: &str,
|
||||
registry_url: &str,
|
||||
token: &str,
|
||||
home: &std::path::Path,
|
||||
_state: &std::path::Path,
|
||||
tmux_tmpdir: &std::path::Path,
|
||||
opts: &DaemonOptions,
|
||||
) -> Child {
|
||||
fn launch(bind: SocketAddr, home: &std::path::Path, tmux_tmpdir: &std::path::Path) -> Child {
|
||||
let bin = workspace_target_bin("maestro", "maestro");
|
||||
let mut cmd = Command::new(&bin);
|
||||
cmd.arg("daemon");
|
||||
@@ -195,21 +113,11 @@ fn launch(
|
||||
.env("XDG_CONFIG_HOME", home.join(".config"))
|
||||
.env("XDG_STATE_HOME", home.join(".local/state"))
|
||||
.env("TMUX_TMPDIR", tmux_tmpdir)
|
||||
.env("MAESTRO_TOKEN", token)
|
||||
.env("MAESTRO_DAEMON_ID", daemon_id)
|
||||
.env("MAESTRO_REGISTRY_URL", registry_url)
|
||||
.env("MAESTRO_DAEMON_BIND_ADDR", bind.to_string())
|
||||
.env("MAESTRO_DAEMON_URL", daemon_url)
|
||||
.env("RUST_LOG", "warn")
|
||||
.stdout(Stdio::null())
|
||||
.stderr(Stdio::inherit())
|
||||
.arg("run");
|
||||
if let Some(p) = &opts.perimeter_id {
|
||||
cmd.env("MAESTRO_DAEMON_PERIMETER_ID", p);
|
||||
}
|
||||
if let Some(a) = &opts.private_addr {
|
||||
cmd.env("MAESTRO_DAEMON_PRIVATE_ADDR", a);
|
||||
}
|
||||
cmd.spawn()
|
||||
.unwrap_or_else(|e| panic!("spawn {} failed: {e}", bin.display()))
|
||||
}
|
||||
|
||||
@@ -1,8 +1,8 @@
|
||||
//! Cross-process integration test harness for Maestro.
|
||||
//!
|
||||
//! Each test spawns a real `maestro-registry` and one or more `maestrod`
|
||||
//! subprocesses, isolates them in temp dirs (`$HOME`, `TMUX_TMPDIR`, state
|
||||
//! dir), and drives them through their public HTTP/WS APIs.
|
||||
//! Each test spawns a real `maestro daemon` subprocess, isolates it in temp
|
||||
//! dirs (`$HOME`, `TMUX_TMPDIR`, state dir), and drives it through its public
|
||||
//! HTTP/WS API.
|
||||
//!
|
||||
//! See `tests/` for the actual scenarios.
|
||||
|
||||
@@ -11,10 +11,8 @@
|
||||
pub mod build;
|
||||
pub mod client;
|
||||
pub mod daemon;
|
||||
pub mod registry;
|
||||
pub mod util;
|
||||
|
||||
pub use build::workspace_target_bin;
|
||||
pub use client::TestClient;
|
||||
pub use daemon::{Daemon, DaemonOptions};
|
||||
pub use registry::Registry;
|
||||
pub use daemon::Daemon;
|
||||
|
||||
Reference in New Issue
Block a user