131 lines
4.4 KiB
Rust
131 lines
4.4 KiB
Rust
//! Instrumentation: every real action appends one event to the journal;
|
|
//! dry runs write nothing. Uses the same isolated-App pattern as the other
|
|
//! integration tests (no user config or state leaks in).
|
|
|
|
mod common;
|
|
|
|
use agent_manager::app::App;
|
|
use agent_manager::cli::{Cli, StartArgs};
|
|
use agent_manager::commands::run_cmd;
|
|
use agent_manager::events::{self, Event, EventKind};
|
|
use agent_manager::state::InstalledEntry;
|
|
use clap::Parser;
|
|
use std::ffi::OsString;
|
|
use std::path::PathBuf;
|
|
use std::sync::atomic::{AtomicU32, Ordering};
|
|
|
|
static COUNTER: AtomicU32 = AtomicU32::new(0);
|
|
|
|
/// Build an isolated App whose catalog contains the given agent definition.
|
|
fn app_with_agent(tag: &str, args: &[&str], agent_yaml: &str) -> App {
|
|
let id = COUNTER.fetch_add(1, Ordering::SeqCst);
|
|
let dir = std::env::temp_dir().join(format!("am-instr-{tag}-{}-{id}", std::process::id()));
|
|
std::fs::create_dir_all(&dir).unwrap();
|
|
let cfg = common::write_config(&dir, agent_yaml);
|
|
let mut full = vec!["am".to_string(), "--config".to_string(), cfg.display().to_string()];
|
|
full.extend(args.iter().map(|s| s.to_string()));
|
|
let cli = Cli::parse_from(full);
|
|
let mut app = App::from_cli(cli).expect("app should build");
|
|
common::isolate(&mut app, &dir);
|
|
app
|
|
}
|
|
|
|
fn events(app: &App) -> Vec<Event> {
|
|
events::read_events(&app.events_dir(), 0)
|
|
}
|
|
|
|
const ECHO_AGENT: &str = r#"
|
|
agents:
|
|
- name: echo-agent
|
|
install: { type: binary, url: "https://example.com/echo.zip" }
|
|
run: sh
|
|
args: ["-c", "echo hi"]
|
|
"#;
|
|
|
|
#[test]
|
|
fn run_emits_one_run_event_with_exit_code() {
|
|
let app = app_with_agent("run", &["run", "echo-agent"], ECHO_AGENT);
|
|
let code = run_cmd::run(&app, "echo-agent", None, false, &[OsString::from("hello")]).unwrap();
|
|
assert_eq!(code, 0);
|
|
let evs = events(&app);
|
|
assert_eq!(evs.len(), 1, "exactly one event expected, got {:?}", evs);
|
|
assert_eq!(evs[0].kind, EventKind::Run);
|
|
assert_eq!(evs[0].agent.as_deref(), Some("echo-agent"));
|
|
assert_eq!(evs[0].exit_code, Some(0));
|
|
assert!(evs[0].duration_s.is_some());
|
|
}
|
|
|
|
#[test]
|
|
fn dry_run_writes_no_event() {
|
|
let app = app_with_agent("dry", &["run", "echo-agent", "--dry-run"], ECHO_AGENT);
|
|
let code = run_cmd::run(&app, "echo-agent", None, false, &[]).unwrap();
|
|
assert_eq!(code, 0);
|
|
assert!(events(&app).is_empty(), "dry-run must not append events");
|
|
assert!(events::journal_files(&app.events_dir()).is_empty());
|
|
}
|
|
|
|
fn sleeper_agent() -> String {
|
|
let (run, args) = if cfg!(windows) {
|
|
("ping", r#"["-n", "60", "127.0.0.1"]"#)
|
|
} else {
|
|
("sleep", r#"["60"]"#)
|
|
};
|
|
format!(
|
|
r#"
|
|
agents:
|
|
- name: sleeper
|
|
install: {{ type: binary, url: "https://example.com/sleeper.zip" }}
|
|
run: {run}
|
|
args: {args}
|
|
"#
|
|
)
|
|
}
|
|
|
|
#[test]
|
|
fn start_and_stop_emit_a_matching_pair() {
|
|
let app = app_with_agent("startstop", &["start", "sleeper", "--background"], &sleeper_agent());
|
|
// The agent must be "managed" for the PID to be recorded and stoppable.
|
|
let entry = InstalledEntry {
|
|
name: "sleeper".to_string(),
|
|
version: None,
|
|
method: "binary".to_string(),
|
|
install_dir: app.paths.install_dir.display().to_string(),
|
|
bins: vec![],
|
|
run: "sleeper".to_string(),
|
|
installed_at: "2026-01-01T00:00:00Z".to_string(),
|
|
updated_at: None,
|
|
pid: None,
|
|
started_at: None,
|
|
};
|
|
app.state.set(&entry).unwrap();
|
|
|
|
let opts = StartArgs {
|
|
agent: Some("sleeper".to_string()),
|
|
background: true,
|
|
..Default::default()
|
|
};
|
|
let code = run_cmd::start(&app, &opts).unwrap();
|
|
assert_eq!(code, 0);
|
|
|
|
let stop_code = run_cmd::stop(&app, "sleeper", false, None).unwrap();
|
|
assert_eq!(stop_code, 0);
|
|
|
|
let evs = events(&app);
|
|
assert_eq!(evs.len(), 2, "expected Start + Stop, got {:?}", evs);
|
|
assert_eq!(evs[0].kind, EventKind::Start);
|
|
assert_eq!(evs[0].agent.as_deref(), Some("sleeper"));
|
|
assert!(evs[0].pid.is_some());
|
|
assert!(evs[0].session.is_some(), "start events carry a session id");
|
|
assert_eq!(evs[1].kind, EventKind::Stop);
|
|
assert_eq!(evs[1].pid, evs[0].pid);
|
|
assert_eq!(evs[1].exit_code, Some(0));
|
|
assert!(evs[1].duration_s.is_some(), "stop events carry the duration");
|
|
}
|
|
|
|
#[test]
|
|
fn fixture_path_is_reachable() {
|
|
// Guard: the shared fixture used by events_test stays parsable here too.
|
|
let p = PathBuf::from(env!("CARGO_MANIFEST_DIR")).join("tests/fixtures/events-sample.jsonl");
|
|
assert_eq!(events::parse_file(&p).len(), 2);
|
|
}
|