Miguel Palhas
cfebfd441b
Dead status can be observed before the settle step's store write lands, so the test's store read raced the write under parallel load. Wait for the store to have the entry before asserting on it, same as the settle-state wait a few lines below. Fixes #111
1056 lines
36 KiB
Rust
1056 lines
36 KiB
Rust
//! End-to-end tests for the SessionManager: create, kill, recover, broadcast.
|
|
|
|
mod common;
|
|
|
|
use std::collections::HashMap;
|
|
use std::path::PathBuf;
|
|
use std::process::Command;
|
|
use std::sync::Arc;
|
|
use std::time::Duration;
|
|
|
|
use common::{
|
|
init_bare_repo, init_repo, push_all_to_origin, wait_for_async, DaemonFixture, TmuxFixture,
|
|
};
|
|
use maestro_daemon::SessionError;
|
|
use maestro_protocol::CreateSessionRequest;
|
|
use maestro_protocol::{CatalogEvent, SessionStatus, WorktreeSpec};
|
|
use tempfile::TempDir;
|
|
|
|
#[tokio::test]
|
|
async fn create_then_kill_round_trip() {
|
|
let fx = DaemonFixture::new();
|
|
let cwd = TempDir::new().unwrap();
|
|
|
|
let session = fx
|
|
.manager
|
|
.create(CreateSessionRequest {
|
|
cwd: cwd.path().to_path_buf(),
|
|
command: "sleep 30".into(),
|
|
env: HashMap::new(),
|
|
metadata: HashMap::new(),
|
|
worktree: None,
|
|
})
|
|
.await
|
|
.expect("create");
|
|
|
|
assert!(fx.manager.has(session.id).await);
|
|
let snap = fx.manager.snapshot().await;
|
|
assert_eq!(snap.len(), 1);
|
|
assert_eq!(snap[0].id, session.id);
|
|
|
|
// sidecar should be on disk
|
|
assert!(fx
|
|
.sidecar_dir()
|
|
.join(format!("{}.json", session.id))
|
|
.exists());
|
|
// FIFO should also exist
|
|
assert!(fx.fifo_dir().join(format!("{}.fifo", session.id)).exists());
|
|
|
|
fx.manager.kill(session.id, false).await.expect("kill");
|
|
assert!(!fx.manager.has(session.id).await);
|
|
assert!(!fx
|
|
.sidecar_dir()
|
|
.join(format!("{}.json", session.id))
|
|
.exists());
|
|
}
|
|
|
|
// #24: a successful spawn appends a record to the durable history, which
|
|
// `recent_dirs()` then surfaces — proving the create→append→read path end to
|
|
// end against a real tmux + on-disk JSONL log.
|
|
#[tokio::test]
|
|
async fn create_appends_to_spawn_history() {
|
|
let fx = DaemonFixture::new_with_history(30);
|
|
let cwd = TempDir::new().unwrap();
|
|
|
|
let session = fx
|
|
.manager
|
|
.create(CreateSessionRequest {
|
|
cwd: cwd.path().to_path_buf(),
|
|
command: "sleep 30".into(),
|
|
env: HashMap::new(),
|
|
metadata: HashMap::from([("name".into(), serde_json::json!("neon-drifter"))]),
|
|
worktree: None,
|
|
})
|
|
.await
|
|
.expect("create");
|
|
|
|
// The JSONL log exists and the recents query surfaces the chosen dir.
|
|
assert!(fx.spawn_history_path().exists());
|
|
let recents = fx.manager.recent_dirs();
|
|
assert_eq!(recents.len(), 1);
|
|
assert_eq!(recents[0].cwd, cwd.path());
|
|
assert_eq!(recents[0].last_command, "sleep 30");
|
|
|
|
fx.manager.kill(session.id, false).await.expect("kill");
|
|
// History is durable — it survives the kill that deletes the sidecar.
|
|
assert_eq!(fx.manager.recent_dirs().len(), 1);
|
|
}
|
|
|
|
// With history disabled (`0` days) or unwired, a spawn logs nothing and the
|
|
// recents query is empty — the spawn itself still succeeds.
|
|
#[tokio::test]
|
|
async fn create_without_history_logs_nothing() {
|
|
let fx = DaemonFixture::new();
|
|
let cwd = TempDir::new().unwrap();
|
|
fx.manager
|
|
.create(CreateSessionRequest {
|
|
cwd: cwd.path().to_path_buf(),
|
|
command: "sleep 30".into(),
|
|
env: HashMap::new(),
|
|
metadata: HashMap::new(),
|
|
worktree: None,
|
|
})
|
|
.await
|
|
.expect("create");
|
|
assert!(fx.manager.recent_dirs().is_empty());
|
|
assert!(!fx.spawn_history_path().exists());
|
|
}
|
|
|
|
#[tokio::test]
|
|
async fn recover_adopts_existing_tmux_sessions() {
|
|
let fx = DaemonFixture::new();
|
|
let cwd = TempDir::new().unwrap();
|
|
|
|
// create a session, then "throw away" the SessionManager (the tmux session
|
|
// and sidecar persist) and build a fresh manager that recovers them.
|
|
let s = fx
|
|
.manager
|
|
.create(CreateSessionRequest {
|
|
cwd: cwd.path().to_path_buf(),
|
|
command: "sleep 30".into(),
|
|
env: HashMap::new(),
|
|
metadata: HashMap::new(),
|
|
worktree: None,
|
|
})
|
|
.await
|
|
.expect("create");
|
|
|
|
// build a parallel manager pointing at the same dirs + same tmux server
|
|
let sidecar = maestro_daemon::sidecar::SidecarStore::new(fx.sidecar_dir());
|
|
let worktree_mgr = maestro_daemon::worktree::WorktreeManager::new(None);
|
|
let revived = maestro_daemon::SessionManager::new(
|
|
Arc::new(fx.tmux.tmux.clone()),
|
|
sidecar,
|
|
worktree_mgr,
|
|
fx.fifo_dir(),
|
|
);
|
|
let adopted = revived.recover().await.expect("recover");
|
|
assert_eq!(adopted, 1);
|
|
assert!(revived.has(s.id).await);
|
|
let snap = revived.snapshot().await;
|
|
assert_eq!(snap[0].id, s.id);
|
|
assert_eq!(snap[0].command, "sleep 30");
|
|
}
|
|
|
|
/// Regression for NAP-253: the very first bytes a freshly-spawned command
|
|
/// writes must reach the replay buffer. Before the fix, `pipe-pane` was a
|
|
/// separate tmux invocation that ran after `new-session` + an async FIFO
|
|
/// setup, so the child's first output was buffered by tmux but never tee'd
|
|
/// into the FIFO.
|
|
#[tokio::test]
|
|
async fn create_captures_initial_output_in_replay_buffer() {
|
|
let fx = DaemonFixture::new();
|
|
let cwd = TempDir::new().unwrap();
|
|
|
|
let s = fx
|
|
.manager
|
|
.create(CreateSessionRequest {
|
|
cwd: cwd.path().to_path_buf(),
|
|
// The shell prints the marker before doing anything else and
|
|
// then sleeps so the session stays alive. Before NAP-253 this
|
|
// marker was the canonical case that got swallowed.
|
|
command: "sh -c 'echo NAP_253_FIRST_LINE_MARKER; exec sleep 30'".into(),
|
|
env: HashMap::new(),
|
|
metadata: HashMap::new(),
|
|
worktree: None,
|
|
})
|
|
.await
|
|
.expect("create");
|
|
|
|
let want = b"NAP_253_FIRST_LINE_MARKER";
|
|
let deadline = std::time::Instant::now() + Duration::from_secs(5);
|
|
let mut found = false;
|
|
while std::time::Instant::now() < deadline {
|
|
let (replay, _rx) = fx
|
|
.manager
|
|
.subscribe_pty_with_replay(s.id)
|
|
.await
|
|
.expect("subscribe");
|
|
if replay.windows(want.len()).any(|w| w == want) {
|
|
found = true;
|
|
break;
|
|
}
|
|
tokio::time::sleep(Duration::from_millis(50)).await;
|
|
}
|
|
assert!(
|
|
found,
|
|
"first-line marker never reached the replay buffer — pipe-pane raced past the child's initial output",
|
|
);
|
|
|
|
fx.manager.kill(s.id, false).await.unwrap();
|
|
}
|
|
|
|
/// Regression for NAP-228: after `recover`, PTY output must reach new
|
|
/// subscribers. Before the fix tmux's stale `pipe-pane` (with `-o`) silently
|
|
/// kept feeding the old FIFO and the revived manager's subscribers saw
|
|
/// nothing.
|
|
#[tokio::test]
|
|
async fn recover_re_pipes_pane_so_output_reaches_subscribers() {
|
|
let fx = DaemonFixture::new();
|
|
let cwd = TempDir::new().unwrap();
|
|
|
|
let s = fx
|
|
.manager
|
|
.create(CreateSessionRequest {
|
|
cwd: cwd.path().to_path_buf(),
|
|
command: "bash --noprofile --norc".into(),
|
|
env: HashMap::new(),
|
|
metadata: HashMap::new(),
|
|
worktree: None,
|
|
})
|
|
.await
|
|
.expect("create");
|
|
|
|
// Capture paths + tmux handle before dropping the original manager —
|
|
// `drop(fx.manager)` partially moves `fx` so we can't call its helpers
|
|
// afterwards.
|
|
let sidecar_dir = fx.sidecar_dir();
|
|
let fifo_dir = fx.fifo_dir();
|
|
let tmux = fx.tmux.tmux.clone();
|
|
|
|
// Drop the original manager. Its PtyBridge closes the FIFO's only
|
|
// reader, so tmux's `cat >> fifo` writer hits SIGPIPE and exits — but
|
|
// tmux's pipe-pane bookkeeping still thinks the pane is piped. That's
|
|
// exactly the stale state recover() has to overwrite.
|
|
drop(fx.manager);
|
|
|
|
let sidecar = maestro_daemon::sidecar::SidecarStore::new(sidecar_dir);
|
|
let worktree_mgr = maestro_daemon::worktree::WorktreeManager::new(None);
|
|
let revived =
|
|
maestro_daemon::SessionManager::new(Arc::new(tmux), sidecar, worktree_mgr, fifo_dir);
|
|
assert_eq!(revived.recover().await.expect("recover"), 1);
|
|
|
|
let mut rx = revived.subscribe_pty(s.id).await.expect("subscribe");
|
|
revived
|
|
.send_keys(s.id, b"echo NAP_228_RECOVERED\n")
|
|
.await
|
|
.unwrap();
|
|
|
|
let want = b"NAP_228_RECOVERED";
|
|
let mut buf: Vec<u8> = Vec::new();
|
|
let deadline = std::time::Instant::now() + Duration::from_secs(5);
|
|
while std::time::Instant::now() < deadline {
|
|
if let Ok(Ok(bytes)) = tokio::time::timeout(Duration::from_millis(50), rx.recv()).await {
|
|
buf.extend_from_slice(&bytes);
|
|
if buf.windows(want.len()).any(|w| w == want) {
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
assert!(
|
|
buf.windows(want.len()).any(|w| w == want),
|
|
"recover() did not restore pty output flow; buf={:?}",
|
|
String::from_utf8_lossy(&buf),
|
|
);
|
|
|
|
revived.kill(s.id, false).await.unwrap();
|
|
}
|
|
|
|
#[tokio::test]
|
|
async fn pty_broadcast_delivers_bytes_to_subscribers() {
|
|
let fx = DaemonFixture::new();
|
|
let cwd = TempDir::new().unwrap();
|
|
|
|
let s = fx
|
|
.manager
|
|
.create(CreateSessionRequest {
|
|
cwd: cwd.path().to_path_buf(),
|
|
command: "bash --noprofile --norc".into(),
|
|
env: HashMap::new(),
|
|
metadata: HashMap::new(),
|
|
worktree: None,
|
|
})
|
|
.await
|
|
.unwrap();
|
|
|
|
let mut a = fx.manager.subscribe_pty(s.id).await.unwrap();
|
|
let mut b = fx.manager.subscribe_pty(s.id).await.unwrap();
|
|
|
|
fx.manager
|
|
.send_keys(s.id, b"echo MAESTRO_BROADCAST_OK\n")
|
|
.await
|
|
.unwrap();
|
|
|
|
let want = b"MAESTRO_BROADCAST_OK";
|
|
let mut buf_a: Vec<u8> = Vec::new();
|
|
let mut buf_b: Vec<u8> = Vec::new();
|
|
|
|
let deadline = std::time::Instant::now() + Duration::from_secs(5);
|
|
while std::time::Instant::now() < deadline {
|
|
if let Ok(Ok(bytes)) = tokio::time::timeout(Duration::from_millis(50), a.recv()).await {
|
|
buf_a.extend_from_slice(&bytes);
|
|
}
|
|
if let Ok(Ok(bytes)) = tokio::time::timeout(Duration::from_millis(50), b.recv()).await {
|
|
buf_b.extend_from_slice(&bytes);
|
|
}
|
|
if buf_a.windows(want.len()).any(|w| w == want)
|
|
&& buf_b.windows(want.len()).any(|w| w == want)
|
|
{
|
|
break;
|
|
}
|
|
}
|
|
assert!(buf_a.windows(want.len()).any(|w| w == want), "A missed");
|
|
assert!(buf_b.windows(want.len()).any(|w| w == want), "B missed");
|
|
|
|
fx.manager.kill(s.id, false).await.unwrap();
|
|
let _ = (cwd, PathBuf::from("/"));
|
|
}
|
|
|
|
#[tokio::test]
|
|
async fn liveness_watcher_marks_dead_sessions_and_keeps_them_until_dismissed() {
|
|
let fx = DaemonFixture::new();
|
|
let cwd = TempDir::new().unwrap();
|
|
|
|
let s = fx
|
|
.manager
|
|
.create(CreateSessionRequest {
|
|
cwd: cwd.path().to_path_buf(),
|
|
command: "sleep 30".into(),
|
|
env: HashMap::new(),
|
|
metadata: HashMap::new(),
|
|
worktree: None,
|
|
})
|
|
.await
|
|
.expect("create");
|
|
|
|
// Subscribe *after* the create so we don't have to filter the Added event.
|
|
let mut events = fx.manager.events();
|
|
fx.manager.start_liveness_watcher(Duration::from_millis(50));
|
|
|
|
// Kill the tmux session out from under the daemon. This is the scenario
|
|
// the watcher exists for: command exits, tmux destroys the session, the
|
|
// daemon never finds out through its normal channels.
|
|
fx.tmux.tmux.kill_session(s.id).expect("kill tmux directly");
|
|
|
|
wait_for_async(Duration::from_secs(3), || async {
|
|
fx.manager.status(s.id).await == Some(SessionStatus::Dead)
|
|
})
|
|
.await;
|
|
|
|
// Marked, not removed — the operator still sees it exited, and its
|
|
// artifacts stay so the output can be replayed.
|
|
assert!(fx.manager.has(s.id).await);
|
|
assert!(fx.sidecar_dir().join(format!("{}.json", s.id)).exists());
|
|
|
|
let mut saw_dead = false;
|
|
let deadline = std::time::Instant::now() + Duration::from_secs(1);
|
|
while std::time::Instant::now() < deadline && !saw_dead {
|
|
match tokio::time::timeout(Duration::from_millis(50), events.recv()).await {
|
|
Ok(Ok(CatalogEvent::SessionUpdated { session }))
|
|
if session.id == s.id && session.status == SessionStatus::Dead =>
|
|
{
|
|
saw_dead = true
|
|
}
|
|
Ok(Ok(_)) => continue,
|
|
_ => break,
|
|
}
|
|
}
|
|
assert!(
|
|
saw_dead,
|
|
"expected a SessionUpdated marking the session dead"
|
|
);
|
|
|
|
// Dismissing it is what finally releases the artifacts.
|
|
fx.manager.kill(s.id, false).await.expect("dismiss");
|
|
assert!(!fx.manager.has(s.id).await);
|
|
assert!(!fx.sidecar_dir().join(format!("{}.json", s.id)).exists());
|
|
assert!(!fx.fifo_dir().join(format!("{}.fifo", s.id)).exists());
|
|
}
|
|
|
|
/// #83: the watcher refreshes `Session.blocked_work` on its own cadence —
|
|
/// first "nothing blocks" for a pristine tree, then the breakdown once the
|
|
/// tree picks up unsaved work, so clients can warn before the kill attempt.
|
|
#[tokio::test]
|
|
async fn watcher_refreshes_the_blocked_work_indicator() {
|
|
let fx = DaemonFixture::new();
|
|
let repo = TempDir::new().unwrap();
|
|
init_repo(repo.path());
|
|
let wt_path = repo.path().join("worktrees").join("feat").join("indicator");
|
|
|
|
fx.manager
|
|
.create(CreateSessionRequest {
|
|
cwd: repo.path().to_path_buf(),
|
|
command: "sleep 30".into(),
|
|
env: HashMap::new(),
|
|
metadata: HashMap::new(),
|
|
worktree: Some(WorktreeSpec {
|
|
base_repo: repo.path().to_path_buf(),
|
|
branch: "feat/indicator".into(),
|
|
create_branch: true,
|
|
}),
|
|
})
|
|
.await
|
|
.expect("create");
|
|
|
|
// Pushed and clean: nothing in the way, and the indicator must say so.
|
|
let origin = TempDir::new().unwrap();
|
|
init_bare_repo(origin.path());
|
|
push_all_to_origin(repo.path(), origin.path());
|
|
|
|
fx.manager.start_liveness_watcher_with_blocked_work(
|
|
Duration::from_millis(50),
|
|
Duration::from_millis(100),
|
|
);
|
|
|
|
wait_for_async(Duration::from_secs(5), || async {
|
|
fx.manager.snapshot().await[0].blocked_work == Some(maestro_protocol::InTheWay::default())
|
|
})
|
|
.await;
|
|
|
|
// Unsaved work appears; the next pass must surface it.
|
|
std::fs::write(wt_path.join("README"), b"unsaved edits\n").unwrap();
|
|
std::fs::write(wt_path.join("notes.txt"), b"untracked\n").unwrap();
|
|
wait_for_async(Duration::from_secs(5), || async {
|
|
matches!(
|
|
&fx.manager.snapshot().await[0].blocked_work,
|
|
Some(b) if b.uncommitted_files >= 1 && b.untracked_files >= 1
|
|
)
|
|
})
|
|
.await;
|
|
|
|
// A steady state must not re-emit every tick (#83 change-detection).
|
|
let mut events = fx.manager.events();
|
|
while events.try_recv().is_ok() {}
|
|
tokio::time::sleep(Duration::from_millis(400)).await;
|
|
assert!(
|
|
!matches!(events.try_recv(), Ok(CatalogEvent::SessionUpdated { .. })),
|
|
"an unchanged worktree must not re-emit SessionUpdated"
|
|
);
|
|
}
|
|
|
|
/// Cleanup on kill is unconditional once the guard passes (#79): even a spec
|
|
/// that says "don't clean up" loses its worktree — the branch was pushed, so
|
|
/// nothing in the tree is unique and removal goes ahead.
|
|
#[tokio::test]
|
|
async fn kill_removes_worktree_even_when_spec_says_keep() {
|
|
let fx = DaemonFixture::new();
|
|
let repo = TempDir::new().unwrap();
|
|
init_repo(repo.path());
|
|
let wt_path = repo.path().join("worktrees").join("feat").join("keep");
|
|
|
|
let s = fx
|
|
.manager
|
|
.create(CreateSessionRequest {
|
|
cwd: repo.path().to_path_buf(),
|
|
command: "sleep 30".into(),
|
|
env: HashMap::new(),
|
|
metadata: HashMap::new(),
|
|
worktree: Some(WorktreeSpec {
|
|
base_repo: repo.path().to_path_buf(),
|
|
branch: "feat/keep".into(),
|
|
create_branch: true,
|
|
}),
|
|
})
|
|
.await
|
|
.expect("create");
|
|
assert!(wt_path.exists());
|
|
|
|
// Push the branch so its commits are reachable from a remote-tracking ref.
|
|
let origin = TempDir::new().unwrap();
|
|
init_bare_repo(origin.path());
|
|
push_all_to_origin(repo.path(), origin.path());
|
|
|
|
fx.manager.kill(s.id, false).await.expect("kill");
|
|
assert!(!wt_path.exists(), "worktree must be removed on kill");
|
|
}
|
|
|
|
/// The kill guard (#79): a worktree holding uncommitted changes refuses the
|
|
/// kill outright. Nothing happens — the session keeps running as the
|
|
/// operator's handle on their unfinished work, and the tree is untouched.
|
|
/// The refusal names what blocked it and how much of it there is.
|
|
#[tokio::test]
|
|
async fn killing_refuses_a_worktree_with_unsaved_work_and_keeps_the_session() {
|
|
let fx = DaemonFixture::new();
|
|
let repo = TempDir::new().unwrap();
|
|
init_repo(repo.path());
|
|
let wt_path = repo.path().join("worktrees").join("feat").join("guarded");
|
|
|
|
let s = fx
|
|
.manager
|
|
.create(CreateSessionRequest {
|
|
cwd: repo.path().to_path_buf(),
|
|
command: "sleep 30".into(),
|
|
env: HashMap::new(),
|
|
metadata: HashMap::new(),
|
|
worktree: Some(WorktreeSpec {
|
|
base_repo: repo.path().to_path_buf(),
|
|
branch: "feat/guarded".into(),
|
|
create_branch: true,
|
|
}),
|
|
})
|
|
.await
|
|
.expect("create");
|
|
std::fs::write(wt_path.join("README"), b"unsaved edits\n").unwrap();
|
|
std::fs::write(wt_path.join("notes.txt"), b"untracked\n").unwrap();
|
|
|
|
let err = fx
|
|
.manager
|
|
.kill(s.id, false)
|
|
.await
|
|
.expect_err("kill must refuse");
|
|
let SessionError::KillGuarded(breakdown) = err else {
|
|
panic!("expected KillGuarded, got {err:?}");
|
|
};
|
|
assert_eq!(breakdown.uncommitted_files, 1);
|
|
assert_eq!(breakdown.untracked_files, 1);
|
|
assert!(
|
|
breakdown.unpushed_commits >= 1,
|
|
"a fresh branch has no remote-tracking ref"
|
|
);
|
|
let message = breakdown.to_string();
|
|
assert!(message.contains("1 uncommitted file"), "{message}");
|
|
assert!(message.contains("1 untracked file"), "{message}");
|
|
|
|
// Nothing happened: the session survives and so does the tree.
|
|
assert!(fx.manager.has(s.id).await, "the session must keep running");
|
|
assert!(wt_path.exists(), "the worktree must be untouched");
|
|
|
|
// A second kill after the work is saved goes through.
|
|
run_git_in(&wt_path, &["add", "."]);
|
|
run_git_in(&wt_path, &["commit", "-q", "-m", "saved"]);
|
|
let origin = TempDir::new().unwrap();
|
|
init_bare_repo(origin.path());
|
|
push_all_to_origin(repo.path(), origin.path());
|
|
fx.manager
|
|
.kill(s.id, false)
|
|
.await
|
|
.expect("kill after saving");
|
|
assert!(!fx.manager.has(s.id).await);
|
|
}
|
|
|
|
/// Unpushed commits alone block the kill (#79): a feature branch almost
|
|
/// always has them, which is why `--force` (which retains) is the ordinary
|
|
/// way to end such a session.
|
|
#[tokio::test]
|
|
async fn killing_refuses_until_the_branch_is_pushed() {
|
|
let fx = DaemonFixture::new();
|
|
let repo = TempDir::new().unwrap();
|
|
init_repo(repo.path());
|
|
let wt_path = repo.path().join("worktrees").join("feat").join("pushed");
|
|
|
|
let s = fx
|
|
.manager
|
|
.create(CreateSessionRequest {
|
|
cwd: repo.path().to_path_buf(),
|
|
command: "sleep 30".into(),
|
|
env: HashMap::new(),
|
|
metadata: HashMap::new(),
|
|
worktree: Some(WorktreeSpec {
|
|
base_repo: repo.path().to_path_buf(),
|
|
branch: "feat/pushed".into(),
|
|
create_branch: true,
|
|
}),
|
|
})
|
|
.await
|
|
.expect("create");
|
|
|
|
let err = fx
|
|
.manager
|
|
.kill(s.id, false)
|
|
.await
|
|
.expect_err("unpushed blocks");
|
|
let SessionError::KillGuarded(breakdown) = err else {
|
|
panic!("expected KillGuarded, got {err:?}");
|
|
};
|
|
assert_eq!(breakdown.uncommitted_files, 0);
|
|
assert_eq!(breakdown.untracked_files, 0);
|
|
assert!(breakdown.unpushed_commits >= 1);
|
|
|
|
let origin = TempDir::new().unwrap();
|
|
init_bare_repo(origin.path());
|
|
push_all_to_origin(repo.path(), origin.path());
|
|
|
|
fx.manager
|
|
.kill(s.id, false)
|
|
.await
|
|
.expect("pushed branch kills");
|
|
assert!(!wt_path.exists());
|
|
assert!(!fx.manager.has(s.id).await);
|
|
}
|
|
|
|
/// `--force` overrides the refusal and nothing else (#81): the session ends,
|
|
/// but the guarded worktree is RETAINED — never removed — and enters the
|
|
/// retained store with reason `force-killed`. The outcome names what was
|
|
/// kept, so a client can say where the work went.
|
|
#[tokio::test]
|
|
async fn force_killing_a_guarded_worktree_retains_it_in_the_store() {
|
|
let fx = DaemonFixture::new();
|
|
let repo = TempDir::new().unwrap();
|
|
init_repo(repo.path());
|
|
let wt_path = repo.path().join("worktrees").join("feat").join("forced");
|
|
|
|
let s = fx
|
|
.manager
|
|
.create(CreateSessionRequest {
|
|
cwd: repo.path().to_path_buf(),
|
|
command: "sleep 30".into(),
|
|
env: HashMap::new(),
|
|
metadata: HashMap::new(),
|
|
worktree: Some(WorktreeSpec {
|
|
base_repo: repo.path().to_path_buf(),
|
|
branch: "feat/forced".into(),
|
|
create_branch: true,
|
|
}),
|
|
})
|
|
.await
|
|
.expect("create");
|
|
std::fs::write(wt_path.join("README"), b"unsaved edits\n").unwrap();
|
|
|
|
// Without force the same kill is refused (#79).
|
|
assert!(fx.manager.kill(s.id, false).await.is_err());
|
|
|
|
let outcome = fx
|
|
.manager
|
|
.kill(s.id, true)
|
|
.await
|
|
.expect("force overrides the refusal");
|
|
|
|
// The tree would have blocked, so force must NOT have removed it...
|
|
assert!(
|
|
wt_path.exists(),
|
|
"a forced kill never removes a tree that would have blocked"
|
|
);
|
|
// ...but the session itself still ends.
|
|
assert!(!fx.manager.has(s.id).await);
|
|
assert!(!fx.sidecar_dir().join(format!("{}.json", s.id)).exists());
|
|
|
|
let retained = outcome.retained.expect("the outcome names what was kept");
|
|
assert_eq!(retained.path, wt_path);
|
|
assert_eq!(retained.branch, "feat/forced");
|
|
assert_eq!(
|
|
retained.reason,
|
|
maestro_protocol::RetainedReason::ForceKilled
|
|
);
|
|
assert!(
|
|
retained.in_the_way.uncommitted_files >= 1,
|
|
"the outcome carries what blocked the unforced kill"
|
|
);
|
|
|
|
// The store holds the same entry, so reclaim can find it later (#80).
|
|
let all = fx.retained_store().load_all().expect("load_all");
|
|
assert_eq!(all.len(), 1);
|
|
assert_eq!(all[0].id, retained.id);
|
|
assert_eq!(all[0].path, wt_path);
|
|
assert_eq!(all[0].branch, "feat/forced");
|
|
}
|
|
|
|
/// Force overrides the *refusal*, not ordinary cleanup (#81): a tree whose
|
|
/// guard is clear never needed the override, so a forced kill removes it as
|
|
/// usual and retains nothing.
|
|
#[tokio::test]
|
|
async fn force_on_a_clear_worktree_removes_it_as_usual() {
|
|
let fx = DaemonFixture::new();
|
|
let repo = TempDir::new().unwrap();
|
|
init_repo(repo.path());
|
|
let wt_path = repo.path().join("worktrees").join("feat").join("clear");
|
|
|
|
let s = fx
|
|
.manager
|
|
.create(CreateSessionRequest {
|
|
cwd: repo.path().to_path_buf(),
|
|
command: "sleep 30".into(),
|
|
env: HashMap::new(),
|
|
metadata: HashMap::new(),
|
|
worktree: Some(WorktreeSpec {
|
|
base_repo: repo.path().to_path_buf(),
|
|
branch: "feat/clear".into(),
|
|
create_branch: true,
|
|
}),
|
|
})
|
|
.await
|
|
.expect("create");
|
|
|
|
let origin = TempDir::new().unwrap();
|
|
init_bare_repo(origin.path());
|
|
push_all_to_origin(repo.path(), origin.path());
|
|
|
|
let outcome = fx.manager.kill(s.id, true).await.expect("kill");
|
|
assert!(!wt_path.exists(), "a clear tree needs no override");
|
|
assert_eq!(outcome.retained, None);
|
|
assert!(fx.retained_store().load_all().unwrap().is_empty());
|
|
}
|
|
|
|
/// Ignored files NEVER block (#79): build output like `target/` exists in
|
|
/// every Rust checkout, and an ignored-only worktree stays killable.
|
|
#[tokio::test]
|
|
async fn killing_an_ignored_only_worktree_succeeds() {
|
|
let fx = DaemonFixture::new();
|
|
let repo = TempDir::new().unwrap();
|
|
init_repo(repo.path());
|
|
// .gitignore must be committed before the worktree branches off, or it
|
|
// would itself read as an untracked file.
|
|
std::fs::write(repo.path().join(".gitignore"), b"/target\n").unwrap();
|
|
run_git_in(repo.path(), &["add", ".gitignore"]);
|
|
run_git_in(repo.path(), &["commit", "-q", "-m", "ignore target"]);
|
|
let origin = TempDir::new().unwrap();
|
|
init_bare_repo(origin.path());
|
|
|
|
let wt_path = repo.path().join("worktrees").join("feat").join("rusty");
|
|
let s = fx
|
|
.manager
|
|
.create(CreateSessionRequest {
|
|
cwd: repo.path().to_path_buf(),
|
|
command: "sleep 30".into(),
|
|
env: HashMap::new(),
|
|
metadata: HashMap::new(),
|
|
worktree: Some(WorktreeSpec {
|
|
base_repo: repo.path().to_path_buf(),
|
|
branch: "feat/rusty".into(),
|
|
create_branch: true,
|
|
}),
|
|
})
|
|
.await
|
|
.expect("create");
|
|
std::fs::create_dir_all(wt_path.join("target")).unwrap();
|
|
std::fs::write(wt_path.join("target").join("app.o"), b"binary\n").unwrap();
|
|
|
|
// Branch pushed; the only dirt is ignored output.
|
|
push_all_to_origin(repo.path(), origin.path());
|
|
|
|
fx.manager
|
|
.kill(s.id, false)
|
|
.await
|
|
.expect("ignored files never block");
|
|
assert!(!wt_path.exists());
|
|
assert!(!fx.manager.has(s.id).await);
|
|
}
|
|
|
|
/// Natural exit (#82): a session that ends on its own never reaches the kill
|
|
/// path, so the watcher applies the kill's rule itself. A worktree holding
|
|
/// unsaved work is RETAINED into the store with reason
|
|
/// `exited-with-unsaved-work`; the session stays in the catalog marked dead
|
|
/// until dismissed — and dismissing it afterwards neither refuses nor
|
|
/// retains a second time.
|
|
#[tokio::test]
|
|
async fn natural_exit_of_a_guarded_worktree_retains_it_in_the_store() {
|
|
let fx = DaemonFixture::new();
|
|
let repo = TempDir::new().unwrap();
|
|
init_repo(repo.path());
|
|
let wt_path = repo.path().join("worktrees").join("feat").join("exited");
|
|
|
|
let s = fx
|
|
.manager
|
|
.create(CreateSessionRequest {
|
|
cwd: repo.path().to_path_buf(),
|
|
command: "sleep 30".into(),
|
|
env: HashMap::new(),
|
|
metadata: HashMap::new(),
|
|
worktree: Some(WorktreeSpec {
|
|
base_repo: repo.path().to_path_buf(),
|
|
branch: "feat/exited".into(),
|
|
create_branch: true,
|
|
}),
|
|
})
|
|
.await
|
|
.expect("create");
|
|
std::fs::write(wt_path.join("README"), b"unsaved edits\n").unwrap();
|
|
|
|
// The command finishes / the operator types exit: tmux loses the session.
|
|
fx.tmux.tmux.kill_session(s.id).expect("kill tmux directly");
|
|
fx.manager.start_liveness_watcher(Duration::from_millis(50));
|
|
wait_for_async(Duration::from_secs(3), || async {
|
|
fx.manager.status(s.id).await == Some(SessionStatus::Dead)
|
|
})
|
|
.await;
|
|
|
|
// The tree would have blocked a kill, so the exit kept it...
|
|
assert!(
|
|
wt_path.exists(),
|
|
"a dirty worktree must be retained on natural exit"
|
|
);
|
|
// ...in the store, under the exit reason.
|
|
// (`Dead` is observable a moment before the settle step's store write lands.)
|
|
wait_for_async(Duration::from_secs(3), || async {
|
|
fx.retained_store()
|
|
.load_all()
|
|
.map(|all| all.len() == 1)
|
|
.unwrap_or(false)
|
|
})
|
|
.await;
|
|
let all = fx.retained_store().load_all().expect("load_all");
|
|
assert_eq!(all.len(), 1);
|
|
assert_eq!(all[0].path, wt_path);
|
|
assert_eq!(all[0].branch, "feat/exited");
|
|
assert_eq!(
|
|
all[0].reason,
|
|
maestro_protocol::RetainedReason::ExitedWithUnsavedWork
|
|
);
|
|
|
|
// The session itself stays until dismissed; its worktree reference is
|
|
// settled, so dismissal is neither refused nor retained twice.
|
|
// (`Dead` is observable a moment before the settle step finishes.)
|
|
wait_for_async(Duration::from_secs(3), || async {
|
|
let s = &fx.manager.snapshot().await[0];
|
|
s.worktree.is_none() && s.blocked_work.is_none()
|
|
})
|
|
.await;
|
|
let snap = fx.manager.snapshot().await;
|
|
assert_eq!(snap.len(), 1);
|
|
assert_eq!(snap[0].worktree, None);
|
|
|
|
fx.manager.kill(s.id, false).await.expect("dismiss");
|
|
assert!(!fx.manager.has(s.id).await);
|
|
assert!(
|
|
wt_path.exists(),
|
|
"dismissal must not remove what was retained"
|
|
);
|
|
assert_eq!(
|
|
fx.retained_store().load_all().unwrap().len(),
|
|
1,
|
|
"dismissal must not record a second entry for the same tree"
|
|
);
|
|
}
|
|
|
|
/// Natural exit (#82), pristine side of the same rule: nothing in the tree,
|
|
/// nothing to keep — the worktree is removed and no store entry appears.
|
|
#[tokio::test]
|
|
async fn natural_exit_of_a_pristine_worktree_removes_it() {
|
|
let fx = DaemonFixture::new();
|
|
let repo = TempDir::new().unwrap();
|
|
init_repo(repo.path());
|
|
let wt_path = repo.path().join("worktrees").join("feat").join("clean");
|
|
|
|
let s = fx
|
|
.manager
|
|
.create(CreateSessionRequest {
|
|
cwd: repo.path().to_path_buf(),
|
|
command: "sleep 30".into(),
|
|
env: HashMap::new(),
|
|
metadata: HashMap::new(),
|
|
worktree: Some(WorktreeSpec {
|
|
base_repo: repo.path().to_path_buf(),
|
|
branch: "feat/clean".into(),
|
|
create_branch: true,
|
|
}),
|
|
})
|
|
.await
|
|
.expect("create");
|
|
|
|
// Push everything so the branch has no unpushed commits: fully pristine.
|
|
let origin = TempDir::new().unwrap();
|
|
init_bare_repo(origin.path());
|
|
push_all_to_origin(repo.path(), origin.path());
|
|
|
|
fx.tmux.tmux.kill_session(s.id).expect("kill tmux directly");
|
|
fx.manager.start_liveness_watcher(Duration::from_millis(50));
|
|
wait_for_async(Duration::from_secs(3), || async {
|
|
fx.manager.status(s.id).await == Some(SessionStatus::Dead)
|
|
})
|
|
.await;
|
|
|
|
assert!(
|
|
!wt_path.exists(),
|
|
"a pristine worktree leaves nothing behind"
|
|
);
|
|
assert!(
|
|
fx.retained_store().load_all().unwrap().is_empty(),
|
|
"nothing was retained"
|
|
);
|
|
assert!(
|
|
fx.manager.has(s.id).await,
|
|
"the session stays until dismissed"
|
|
);
|
|
}
|
|
|
|
/// When nothing can be recorded — here: no retained store wired — the exit
|
|
/// destroys nothing. The tree stays on disk AND stays attached to the dead
|
|
/// record, where dismissing it later still goes through #81's forced-kill
|
|
/// retention. Losing the store must not lose the work.
|
|
#[tokio::test]
|
|
async fn natural_exit_without_a_retained_store_destroys_nothing() {
|
|
let tmux = TmuxFixture::new();
|
|
let state_dir = TempDir::new().unwrap();
|
|
let manager = maestro_daemon::SessionManager::new(
|
|
Arc::new(tmux.tmux.clone()),
|
|
maestro_daemon::sidecar::SidecarStore::new(state_dir.path().join("sessions")),
|
|
maestro_daemon::worktree::WorktreeManager::new(None),
|
|
state_dir.path().join("fifos"),
|
|
);
|
|
// Deliberately NO with_retained_store.
|
|
|
|
let repo = TempDir::new().unwrap();
|
|
init_repo(repo.path());
|
|
let wt_path = repo.path().join("worktrees").join("feat").join("nostore");
|
|
|
|
let s = manager
|
|
.create(CreateSessionRequest {
|
|
cwd: repo.path().to_path_buf(),
|
|
command: "sleep 30".into(),
|
|
env: HashMap::new(),
|
|
metadata: HashMap::new(),
|
|
worktree: Some(WorktreeSpec {
|
|
base_repo: repo.path().to_path_buf(),
|
|
branch: "feat/nostore".into(),
|
|
create_branch: true,
|
|
}),
|
|
})
|
|
.await
|
|
.expect("create");
|
|
std::fs::write(wt_path.join("README"), b"unsaved edits\n").unwrap();
|
|
|
|
tmux.tmux.kill_session(s.id).expect("kill tmux directly");
|
|
manager.start_liveness_watcher(Duration::from_millis(50));
|
|
wait_for_async(Duration::from_secs(3), || async {
|
|
manager.status(s.id).await == Some(SessionStatus::Dead)
|
|
})
|
|
.await;
|
|
|
|
assert!(
|
|
wt_path.exists(),
|
|
"nothing may be destroyed when it cannot be recorded"
|
|
);
|
|
let snap = manager.snapshot().await;
|
|
assert!(
|
|
snap[0].worktree.is_some(),
|
|
"the tree must stay attached to the record so a later forced kill can retain it"
|
|
);
|
|
}
|
|
|
|
fn run_git_in(dir: &std::path::Path, args: &[&str]) {
|
|
let out = Command::new("git")
|
|
.arg("-C")
|
|
.arg(dir)
|
|
.args(args)
|
|
.output()
|
|
.expect("git spawn");
|
|
assert!(
|
|
out.status.success(),
|
|
"git {args:?} failed: {}",
|
|
String::from_utf8_lossy(&out.stderr)
|
|
);
|
|
}
|
|
|
|
#[tokio::test]
|
|
async fn liveness_watcher_leaves_running_sessions_alone() {
|
|
let fx = DaemonFixture::new();
|
|
let cwd = TempDir::new().unwrap();
|
|
|
|
let s = fx
|
|
.manager
|
|
.create(CreateSessionRequest {
|
|
cwd: cwd.path().to_path_buf(),
|
|
command: "sleep 30".into(),
|
|
env: HashMap::new(),
|
|
metadata: HashMap::new(),
|
|
worktree: None,
|
|
})
|
|
.await
|
|
.expect("create");
|
|
|
|
fx.manager.start_liveness_watcher(Duration::from_millis(50));
|
|
|
|
// Give the watcher enough time to run a handful of ticks.
|
|
tokio::time::sleep(Duration::from_millis(400)).await;
|
|
assert!(fx.manager.has(s.id).await, "live session got reaped");
|
|
|
|
fx.manager.kill(s.id, false).await.unwrap();
|
|
}
|
|
|
|
/// #99: clients group a session under `worktree.base_repo`, so that field has
|
|
/// to name the repository even when the spawn request pointed at a linked
|
|
/// worktree. Recording the request verbatim put the session in a folder of its
|
|
/// own — `<repo>/worktrees/<branch>` — instead of under the repo.
|
|
#[tokio::test]
|
|
async fn worktree_base_repo_records_the_main_checkout_not_the_request() {
|
|
let fx = DaemonFixture::new();
|
|
let repo = TempDir::new().unwrap();
|
|
init_repo(repo.path());
|
|
|
|
// A linked worktree of that repo, then a spawn whose `base_repo` names it
|
|
// rather than the main checkout — what happens when the operator spawns
|
|
// from inside a worktree.
|
|
let first = fx
|
|
.manager
|
|
.create(CreateSessionRequest {
|
|
cwd: repo.path().to_path_buf(),
|
|
command: "sleep 30".into(),
|
|
env: HashMap::new(),
|
|
metadata: HashMap::new(),
|
|
worktree: Some(WorktreeSpec {
|
|
base_repo: repo.path().to_path_buf(),
|
|
branch: "feat/one".into(),
|
|
create_branch: true,
|
|
}),
|
|
})
|
|
.await
|
|
.expect("create first");
|
|
let inner_worktree = first.worktree.expect("first has a worktree").path;
|
|
|
|
let second = fx
|
|
.manager
|
|
.create(CreateSessionRequest {
|
|
cwd: inner_worktree.clone(),
|
|
command: "sleep 30".into(),
|
|
env: HashMap::new(),
|
|
metadata: HashMap::new(),
|
|
worktree: Some(WorktreeSpec {
|
|
base_repo: inner_worktree.clone(),
|
|
branch: "feat/two".into(),
|
|
create_branch: true,
|
|
}),
|
|
})
|
|
.await
|
|
.expect("create second");
|
|
|
|
let wt = second.worktree.expect("second has a worktree");
|
|
assert_eq!(
|
|
wt.base_repo,
|
|
repo.path()
|
|
.canonicalize()
|
|
.unwrap_or_else(|_| repo.path().to_path_buf()),
|
|
"base_repo must be the repository, not the worktree the request named",
|
|
);
|
|
assert_ne!(wt.base_repo, inner_worktree, "the worktree is not the repo");
|
|
}
|
|
|
|
/// #103: every tmux-spawned session carries the daemon's identity variables in
|
|
/// its environment — its UUID under `MAESTRO_SESSION_ID` and the daemon's base
|
|
/// URL under `MAESTRO_URL` — so the in-session reporting hook (#106) can find
|
|
/// both without any out-of-band channel.
|
|
#[tokio::test]
|
|
async fn spawned_sessions_export_maestro_session_id_and_url() {
|
|
let fx = DaemonFixture::new();
|
|
fx.manager
|
|
.set_daemon_url("http://127.0.0.1:7071".to_string());
|
|
let cwd = TempDir::new().unwrap();
|
|
|
|
let s = fx
|
|
.manager
|
|
.create(CreateSessionRequest {
|
|
cwd: cwd.path().to_path_buf(),
|
|
command: "sleep 30".into(),
|
|
env: HashMap::new(),
|
|
metadata: HashMap::new(),
|
|
worktree: None,
|
|
})
|
|
.await
|
|
.expect("create");
|
|
|
|
let env = fx
|
|
.tmux
|
|
.tmux
|
|
.show_environment(s.id)
|
|
.expect("show-environment");
|
|
assert_eq!(
|
|
env.get("MAESTRO_SESSION_ID"),
|
|
Some(&s.id.to_string()),
|
|
"session env: {env:?}"
|
|
);
|
|
assert_eq!(
|
|
env.get("MAESTRO_URL"),
|
|
Some(&"http://127.0.0.1:7071".to_string())
|
|
);
|
|
|
|
fx.manager.kill(s.id, false).await.expect("kill");
|
|
}
|