//! 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::sync::Arc; 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) ); } /// An empty bare repository at `dir`, usable as a push target (#79). pub fn init_bare_repo(dir: &Path) { run(Command::new("git") .arg("init") .arg("-q") .arg("--bare") .arg(dir.to_str().expect("non-utf8 bare repo path"))); } /// Push every branch of `repo` to `origin`, creating remote-tracking refs. /// /// The unsaved-work probe (#79) counts commits reachable from no /// remote-tracking ref as unpushed, so tests that want a killable worktree /// must give its branch one. Safe to call again: re-adding an existing /// remote is ignored. pub fn push_all_to_origin(repo: &Path, origin: &Path) { let _ = Command::new("git") .arg("-C") .arg(repo) .args([ "remote", "add", "origin", origin.to_str().expect("non-utf8 origin path"), ]) .status(); run(Command::new("git") .arg("-C") .arg(repo) .args(["push", "-q", "--all", "origin"])); } /// Async polling sibling of [`wait_for`] for tokio tests. pub async fn wait_for_async(timeout: Duration, mut cond: F) where F: FnMut() -> Fut, Fut: Future, { 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, } 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 `/spawn-history.jsonl`. pub fn new_with_history(retention_days: u32) -> Self { Self::build(Some(retention_days)) } fn build(history_days: Option) -> Self { let tmux = TmuxFixture::new(); let state_dir = TempDir::new().unwrap(); let sidecar = SidecarStore::new(state_dir.path().join("sessions")); // Default placement: worktrees land under their base repo (#56). let worktree_mgr = WorktreeManager::new(None); let mut manager = SessionManager::new( Arc::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, } } 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") } }