This repository has been archived on 2026-10-08. You can view files and clone it. You cannot open issues or pull requests or push a commit.
Files
maestro/crates/maestro-daemon/tests/common/mod.rs
T
Miguel Palhas d006f4a7bd refactor(maestro): drop registry, p2p, and auth from daemon core
Maestro is now single-host: one daemon owns the machine's sessions and
clients talk to it directly. Removes the registry crate, the daemon's
registry client/broker/catalog mirror, JWT attach auth, cookie auth, and
the perimeter (T2) transport config.

The daemon API is now unauthenticated on its bind address, same trust
model as tmux. Session and CreateSessionRequest lose daemon_id;
RegistryEvent becomes CatalogEvent with no daemon variants; attach moves
to WS /api/attach/:id with no token.
2026-08-22 10:00:24 +01:00

171 lines
5.0 KiB
Rust

//! Shared helpers for the maestro-daemon integration tests.
//!
//! Each integration test file compiles as its own binary and only uses a
//! subset of these helpers, so `dead_code` warnings are spurious here.
#![allow(dead_code)]
use std::future::Future;
use std::path::{Path, PathBuf};
use std::process::Command;
use std::thread;
use std::time::{Duration, Instant};
use maestro_daemon::sidecar::SidecarStore;
use maestro_daemon::spawn_history::SpawnHistory;
use maestro_daemon::tmux::Tmux;
use maestro_daemon::worktree::WorktreeManager;
use maestro_daemon::SessionManager;
use tempfile::TempDir;
use uuid::Uuid;
/// An isolated tmux instance scoped to a temp `TMUX_TMPDIR` and unique socket
/// name. Drops kill the server so leftover sockets don't accumulate.
pub struct TmuxFixture {
pub tmux: Tmux,
_home: TempDir,
_tmpdir: TempDir,
}
impl TmuxFixture {
pub fn new() -> Self {
let home = TempDir::new().expect("tempdir HOME");
let tmpdir = TempDir::new().expect("tempdir TMUX_TMPDIR");
let socket = format!("maestro-test-{}", Uuid::new_v4().simple());
let tmux = Tmux::new()
.with_socket(socket)
.with_tmpdir(tmpdir.path().to_path_buf());
Self {
tmux,
_home: home,
_tmpdir: tmpdir,
}
}
}
impl Drop for TmuxFixture {
fn drop(&mut self) {
let _ = self.tmux.kill_server();
}
}
/// Wait until `cond` returns `true`, polling every 25ms. Panics on timeout.
pub fn wait_for(timeout: Duration, mut cond: impl FnMut() -> bool) {
let deadline = Instant::now() + timeout;
while Instant::now() < deadline {
if cond() {
return;
}
thread::sleep(Duration::from_millis(25));
}
panic!("timed out after {timeout:?} waiting for condition");
}
/// `git init` a fresh repo in `dir` with one commit so it can host worktrees.
pub fn init_repo(dir: &Path) {
run(Command::new("git")
.arg("-C")
.arg(dir)
.args(["init", "-q", "-b", "main"]));
run(Command::new("git")
.arg("-C")
.arg(dir)
.args(["config", "user.email", "test@example.com"]));
run(Command::new("git")
.arg("-C")
.arg(dir)
.args(["config", "user.name", "Test"]));
std::fs::write(dir.join("README"), b"hello\n").unwrap();
run(Command::new("git").arg("-C").arg(dir).args(["add", "."]));
run(Command::new("git")
.arg("-C")
.arg(dir)
.args(["commit", "-q", "-m", "initial"]));
}
fn run(cmd: &mut Command) {
let out = cmd.output().expect("git spawn");
assert!(
out.status.success(),
"git command failed: {} stderr={}",
out.status,
String::from_utf8_lossy(&out.stderr)
);
}
/// Async polling sibling of [`wait_for`] for tokio tests.
pub async fn wait_for_async<F, Fut>(timeout: Duration, mut cond: F)
where
F: FnMut() -> Fut,
Fut: Future<Output = bool>,
{
let deadline = Instant::now() + timeout;
while Instant::now() < deadline {
if cond().await {
return;
}
tokio::time::sleep(Duration::from_millis(25)).await;
}
panic!("timed out after {timeout:?} waiting for condition");
}
/// Bundle of dirs + a SessionManager hooked to an isolated tmux instance.
/// Holds the `TempDir`s so they survive the test lifetime.
pub struct DaemonFixture {
pub tmux: TmuxFixture,
pub manager: SessionManager,
pub state_dir: TempDir,
pub worktree_root: TempDir,
}
impl DaemonFixture {
pub fn new() -> Self {
Self::build(None)
}
/// Variant whose manager has a durable spawn history (#24) attached, with
/// `retention_days` recency cap, logging to `<state_dir>/spawn-history.jsonl`.
pub fn new_with_history(retention_days: u32) -> Self {
Self::build(Some(retention_days))
}
fn build(history_days: Option<u32>) -> Self {
let tmux = TmuxFixture::new();
let state_dir = TempDir::new().unwrap();
let worktree_root = TempDir::new().unwrap();
let sidecar = SidecarStore::new(state_dir.path().join("sessions"));
let worktree_mgr = WorktreeManager::new(worktree_root.path().to_path_buf());
let mut manager = SessionManager::new(
tmux.tmux.clone(),
sidecar,
worktree_mgr,
state_dir.path().join("fifos"),
);
if let Some(days) = history_days {
manager =
manager.with_spawn_history(SpawnHistory::new(Self::history_path(&state_dir), days));
}
Self {
tmux,
manager,
state_dir,
worktree_root,
}
}
fn history_path(state_dir: &TempDir) -> PathBuf {
state_dir.path().join("spawn-history.jsonl")
}
pub fn spawn_history_path(&self) -> PathBuf {
Self::history_path(&self.state_dir)
}
pub fn sidecar_dir(&self) -> PathBuf {
self.state_dir.path().join("sessions")
}
pub fn fifo_dir(&self) -> PathBuf {
self.state_dir.path().join("fifos")
}
}