Christian Nennemann
8eba12170e
- Add meshservice to workspace members - Fix quicprochat-client: add MeshTrace/MeshStats slash commands - Add integration test: meshservice_tcp_transport - Document integration points in README and docs/status.md - Verify shared identity (IdentityKeypair → MeshAddress)
873 lines
30 KiB
Rust
873 lines
30 KiB
Rust
//! YAML playbook parser and executor.
|
|
//!
|
|
//! Playbooks describe a sequence of client commands in YAML format.
|
|
//! They support variable substitution, assertions, loops, and per-step
|
|
//! error handling policies.
|
|
//!
|
|
//! ```yaml
|
|
//! name: "smoke test"
|
|
//! steps:
|
|
//! - command: dm
|
|
//! args: { username: "bob" }
|
|
//! - command: send
|
|
//! args: { text: "Hello from playbook" }
|
|
//! - command: assert
|
|
//! condition: message_count
|
|
//! op: gte
|
|
//! value: 1
|
|
//! ```
|
|
//!
|
|
//! Requires the `playbook` cargo feature.
|
|
|
|
use std::collections::HashMap;
|
|
use std::path::Path;
|
|
use std::time::{Duration, Instant};
|
|
|
|
use anyhow::{Context, bail};
|
|
use quicprochat_proto::node_capnp::node_service;
|
|
use serde::{Deserialize, Serialize};
|
|
|
|
use super::command_engine::{AssertCondition, CmpOp, Command, CommandRegistry};
|
|
use super::session::SessionState;
|
|
|
|
// ── Playbook structs ────────────────────────────────────────────────────────
|
|
|
|
/// A parsed YAML playbook.
|
|
#[derive(Debug, Clone, Serialize, Deserialize)]
|
|
pub struct Playbook {
|
|
pub name: String,
|
|
#[serde(default)]
|
|
pub description: Option<String>,
|
|
#[serde(default)]
|
|
pub variables: HashMap<String, String>,
|
|
pub steps: Vec<PlaybookStep>,
|
|
}
|
|
|
|
/// A single step in a playbook.
|
|
#[derive(Debug, Clone, Serialize, Deserialize)]
|
|
pub struct PlaybookStep {
|
|
pub command: String,
|
|
#[serde(default)]
|
|
pub args: HashMap<String, serde_yaml::Value>,
|
|
/// For assert steps: the condition name.
|
|
#[serde(default)]
|
|
pub condition: Option<String>,
|
|
/// For assert steps: comparison operator.
|
|
#[serde(default)]
|
|
pub op: Option<String>,
|
|
/// For assert steps: expected value.
|
|
#[serde(default)]
|
|
pub value: Option<serde_yaml::Value>,
|
|
/// Capture the command output into this variable name.
|
|
#[serde(default)]
|
|
pub capture: Option<String>,
|
|
/// Error handling policy for this step.
|
|
#[serde(default)]
|
|
pub on_error: OnError,
|
|
/// Optional loop specification.
|
|
#[serde(rename = "loop", default)]
|
|
pub loop_spec: Option<LoopSpec>,
|
|
}
|
|
|
|
/// What to do when a step fails.
|
|
#[derive(Debug, Clone, Serialize, Deserialize, Default, PartialEq)]
|
|
#[serde(rename_all = "lowercase")]
|
|
pub enum OnError {
|
|
#[default]
|
|
Fail,
|
|
Skip,
|
|
Continue,
|
|
}
|
|
|
|
/// Loop specification for repeating a step.
|
|
#[derive(Debug, Clone, Serialize, Deserialize)]
|
|
pub struct LoopSpec {
|
|
pub var: String,
|
|
pub from: usize,
|
|
pub to: usize,
|
|
}
|
|
|
|
// ── Report structs ──────────────────────────────────────────────────────────
|
|
|
|
/// Summary of a playbook execution.
|
|
#[derive(Debug, Clone, Serialize, Deserialize)]
|
|
pub struct PlaybookReport {
|
|
pub name: String,
|
|
pub total_steps: usize,
|
|
pub passed: usize,
|
|
pub failed: usize,
|
|
pub skipped: usize,
|
|
pub duration: Duration,
|
|
pub step_results: Vec<StepResult>,
|
|
}
|
|
|
|
impl PlaybookReport {
|
|
/// True if all steps passed (no failures).
|
|
pub fn all_passed(&self) -> bool {
|
|
self.failed == 0
|
|
}
|
|
}
|
|
|
|
impl std::fmt::Display for PlaybookReport {
|
|
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
|
|
writeln!(f, "Playbook: {}", self.name)?;
|
|
writeln!(
|
|
f,
|
|
"Result: {} passed, {} failed, {} skipped ({} total)",
|
|
self.passed, self.failed, self.skipped, self.total_steps,
|
|
)?;
|
|
writeln!(f, "Duration: {:.2}s", self.duration.as_secs_f64())?;
|
|
for sr in &self.step_results {
|
|
let status = if sr.success { "OK" } else { "FAIL" };
|
|
write!(
|
|
f,
|
|
" [{}/{}] {} ... {} ({:.1}ms)",
|
|
sr.step_index + 1,
|
|
self.total_steps,
|
|
sr.command,
|
|
status,
|
|
sr.duration.as_secs_f64() * 1000.0,
|
|
)?;
|
|
if let Some(ref e) = sr.error {
|
|
write!(f, " — {e}")?;
|
|
}
|
|
writeln!(f)?;
|
|
}
|
|
Ok(())
|
|
}
|
|
}
|
|
|
|
/// Result of a single step execution.
|
|
#[derive(Debug, Clone, Serialize, Deserialize)]
|
|
pub struct StepResult {
|
|
pub step_index: usize,
|
|
pub command: String,
|
|
pub success: bool,
|
|
pub duration: Duration,
|
|
pub output: Option<String>,
|
|
pub error: Option<String>,
|
|
}
|
|
|
|
// ── PlaybookRunner ──────────────────────────────────────────────────────────
|
|
|
|
/// Executes a parsed `Playbook` step-by-step.
|
|
pub struct PlaybookRunner {
|
|
playbook: Playbook,
|
|
vars: HashMap<String, String>,
|
|
}
|
|
|
|
impl PlaybookRunner {
|
|
/// Load a playbook from a YAML file.
|
|
pub fn from_file(path: &Path) -> anyhow::Result<Self> {
|
|
let content =
|
|
std::fs::read_to_string(path).with_context(|| format!("read {}", path.display()))?;
|
|
Self::from_str(&content)
|
|
}
|
|
|
|
/// Parse a playbook from a YAML string.
|
|
pub fn from_str(yaml: &str) -> anyhow::Result<Self> {
|
|
let playbook: Playbook =
|
|
serde_yaml::from_str(yaml).context("parse playbook YAML")?;
|
|
let vars = playbook.variables.clone();
|
|
Ok(Self { playbook, vars })
|
|
}
|
|
|
|
/// Override or add variables before execution.
|
|
pub fn set_var(&mut self, name: impl Into<String>, value: impl Into<String>) {
|
|
self.vars.insert(name.into(), value.into());
|
|
}
|
|
|
|
/// Execute all steps, returning a report.
|
|
pub async fn run(
|
|
&mut self,
|
|
session: &mut SessionState,
|
|
client: &node_service::Client,
|
|
) -> PlaybookReport {
|
|
let start = Instant::now();
|
|
let total = self.expanded_step_count();
|
|
let mut results = Vec::new();
|
|
let mut passed = 0usize;
|
|
let mut failed = 0usize;
|
|
let mut skipped = 0usize;
|
|
let mut step_idx = 0usize;
|
|
let mut abort = false;
|
|
|
|
for step in &self.playbook.steps.clone() {
|
|
if abort {
|
|
skipped += 1;
|
|
results.push(StepResult {
|
|
step_index: step_idx,
|
|
command: step.command.clone(),
|
|
success: false,
|
|
duration: Duration::ZERO,
|
|
output: None,
|
|
error: Some("skipped (prior failure)".into()),
|
|
});
|
|
step_idx += 1;
|
|
continue;
|
|
}
|
|
|
|
if let Some(ref ls) = step.loop_spec {
|
|
for i in ls.from..=ls.to {
|
|
self.vars.insert(ls.var.clone(), i.to_string());
|
|
let sr = self.execute_step(step, step_idx, total, session, client).await;
|
|
if sr.success {
|
|
passed += 1;
|
|
} else {
|
|
failed += 1;
|
|
if step.on_error == OnError::Fail {
|
|
abort = true;
|
|
}
|
|
}
|
|
results.push(sr);
|
|
step_idx += 1;
|
|
if abort {
|
|
break;
|
|
}
|
|
}
|
|
} else {
|
|
let sr = self.execute_step(step, step_idx, total, session, client).await;
|
|
if sr.success {
|
|
passed += 1;
|
|
} else {
|
|
match step.on_error {
|
|
OnError::Fail => {
|
|
failed += 1;
|
|
abort = true;
|
|
}
|
|
OnError::Skip => skipped += 1,
|
|
OnError::Continue => failed += 1,
|
|
}
|
|
}
|
|
results.push(sr);
|
|
step_idx += 1;
|
|
}
|
|
}
|
|
|
|
PlaybookReport {
|
|
name: self.playbook.name.clone(),
|
|
total_steps: step_idx,
|
|
passed,
|
|
failed,
|
|
skipped,
|
|
duration: start.elapsed(),
|
|
step_results: results,
|
|
}
|
|
}
|
|
|
|
/// Execute a single step.
|
|
async fn execute_step(
|
|
&mut self,
|
|
step: &PlaybookStep,
|
|
index: usize,
|
|
total: usize,
|
|
session: &mut SessionState,
|
|
client: &node_service::Client,
|
|
) -> StepResult {
|
|
let t = Instant::now();
|
|
let cmd = match self.step_to_command(step) {
|
|
Ok(c) => c,
|
|
Err(e) => {
|
|
return StepResult {
|
|
step_index: index,
|
|
command: step.command.clone(),
|
|
success: false,
|
|
duration: t.elapsed(),
|
|
output: None,
|
|
error: Some(format!("{e:#}")),
|
|
};
|
|
}
|
|
};
|
|
|
|
eprintln!(
|
|
"[{}/{}] {} ...",
|
|
index + 1,
|
|
total,
|
|
step.command,
|
|
);
|
|
|
|
let cr = CommandRegistry::execute(&cmd, session, client).await;
|
|
|
|
// Capture output into variable if requested.
|
|
if let Some(ref var_name) = step.capture {
|
|
if let Some(ref out) = cr.output {
|
|
self.vars.insert(var_name.clone(), out.clone());
|
|
}
|
|
for (k, v) in &cr.data {
|
|
self.vars.insert(format!("{var_name}.{k}"), v.clone());
|
|
}
|
|
}
|
|
|
|
StepResult {
|
|
step_index: index,
|
|
command: step.command.clone(),
|
|
success: cr.success,
|
|
duration: t.elapsed(),
|
|
output: cr.output,
|
|
error: cr.error,
|
|
}
|
|
}
|
|
|
|
/// Convert a YAML step into a typed `Command`.
|
|
fn step_to_command(&self, step: &PlaybookStep) -> anyhow::Result<Command> {
|
|
let cmd_name = step.command.as_str();
|
|
match cmd_name {
|
|
// ── Lifecycle commands ────────────────────────────────────────
|
|
"connect" => Ok(Command::Connect {
|
|
server: self.resolve_str(&step.args, "server")?,
|
|
ca_cert: self.opt_str(&step.args, "ca_cert"),
|
|
insecure: self.opt_bool(&step.args, "insecure"),
|
|
}),
|
|
"login" => Ok(Command::Login {
|
|
username: self.resolve_str(&step.args, "username")?,
|
|
password: self.resolve_str(&step.args, "password")?,
|
|
}),
|
|
"register" => Ok(Command::Register {
|
|
username: self.resolve_str(&step.args, "username")?,
|
|
password: self.resolve_str(&step.args, "password")?,
|
|
}),
|
|
"send" | "send-message" => Ok(Command::SendMessage {
|
|
text: self.resolve_str(&step.args, "text")?,
|
|
}),
|
|
"wait" => Ok(Command::Wait {
|
|
duration_ms: self.resolve_u64(&step.args, "duration_ms")?,
|
|
}),
|
|
"set-var" | "setvar" => Ok(Command::SetVar {
|
|
name: self.resolve_str(&step.args, "name")?,
|
|
value: self.resolve_str(&step.args, "value")?,
|
|
}),
|
|
"assert" => {
|
|
let condition = self.build_assert_condition(step)?;
|
|
Ok(Command::Assert { condition })
|
|
}
|
|
|
|
// ── Session / identity ───────────────────────────────────────
|
|
"help" => Ok(Command::Help),
|
|
"quit" | "exit" => Ok(Command::Quit),
|
|
"whoami" => Ok(Command::Whoami),
|
|
"list" | "ls" => Ok(Command::List),
|
|
"switch" | "sw" => Ok(Command::Switch {
|
|
target: self.resolve_str(&step.args, "target")?,
|
|
}),
|
|
"dm" => Ok(Command::Dm {
|
|
username: self.resolve_str(&step.args, "username")?,
|
|
}),
|
|
"create-group" | "cg" => Ok(Command::CreateGroup {
|
|
name: self.resolve_str(&step.args, "name")?,
|
|
}),
|
|
"invite" => Ok(Command::Invite {
|
|
target: self.resolve_str(&step.args, "target")?,
|
|
}),
|
|
"remove" | "kick" => Ok(Command::Remove {
|
|
target: self.resolve_str(&step.args, "target")?,
|
|
}),
|
|
"leave" => Ok(Command::Leave),
|
|
"join" => Ok(Command::Join),
|
|
"members" => Ok(Command::Members),
|
|
"group-info" | "gi" => Ok(Command::GroupInfo),
|
|
"rename" => Ok(Command::Rename {
|
|
name: self.resolve_str(&step.args, "name")?,
|
|
}),
|
|
"history" | "hist" => Ok(Command::History {
|
|
count: self.opt_usize(&step.args, "count").unwrap_or(20),
|
|
}),
|
|
|
|
// ── Security / crypto ────────────────────────────────────────
|
|
"verify" => Ok(Command::Verify {
|
|
username: self.resolve_str(&step.args, "username")?,
|
|
}),
|
|
"update-key" | "rotate-key" => Ok(Command::UpdateKey),
|
|
"typing" => Ok(Command::Typing),
|
|
"typing-notify" => Ok(Command::TypingNotify {
|
|
enabled: self.opt_bool(&step.args, "enabled"),
|
|
}),
|
|
"react" => Ok(Command::React {
|
|
emoji: self.resolve_str(&step.args, "emoji")?,
|
|
index: self.opt_usize(&step.args, "index"),
|
|
}),
|
|
"edit" => Ok(Command::Edit {
|
|
index: self.resolve_usize(&step.args, "index")?,
|
|
new_text: self.resolve_str(&step.args, "new_text")?,
|
|
}),
|
|
"delete" | "del" => Ok(Command::Delete {
|
|
index: self.resolve_usize(&step.args, "index")?,
|
|
}),
|
|
"send-file" | "sf" => Ok(Command::SendFile {
|
|
path: self.resolve_str(&step.args, "path")?,
|
|
}),
|
|
"download" | "dl" => Ok(Command::Download {
|
|
index: self.resolve_usize(&step.args, "index")?,
|
|
}),
|
|
"delete-account" => Ok(Command::DeleteAccount),
|
|
"disappear" => Ok(Command::Disappear {
|
|
arg: self.opt_str(&step.args, "duration"),
|
|
}),
|
|
"privacy" => Ok(Command::Privacy {
|
|
arg: self.opt_str(&step.args, "setting"),
|
|
}),
|
|
"verify-fs" => Ok(Command::VerifyFs),
|
|
"rotate-all-keys" => Ok(Command::RotateAllKeys),
|
|
"devices" => Ok(Command::Devices),
|
|
"register-device" => Ok(Command::RegisterDevice {
|
|
name: self.resolve_str(&step.args, "name")?,
|
|
}),
|
|
"revoke-device" => Ok(Command::RevokeDevice {
|
|
id_prefix: self.resolve_str(&step.args, "id_prefix")?,
|
|
}),
|
|
|
|
// ── Mesh ─────────────────────────────────────────────────────
|
|
"mesh-peers" => Ok(Command::MeshPeers),
|
|
"mesh-server" => Ok(Command::MeshServer {
|
|
addr: self.resolve_str(&step.args, "addr")?,
|
|
}),
|
|
"mesh-send" => Ok(Command::MeshSend {
|
|
peer_id: self.resolve_str(&step.args, "peer_id")?,
|
|
message: self.resolve_str(&step.args, "message")?,
|
|
}),
|
|
"mesh-broadcast" => Ok(Command::MeshBroadcast {
|
|
topic: self.resolve_str(&step.args, "topic")?,
|
|
message: self.resolve_str(&step.args, "message")?,
|
|
}),
|
|
"mesh-subscribe" => Ok(Command::MeshSubscribe {
|
|
topic: self.resolve_str(&step.args, "topic")?,
|
|
}),
|
|
"mesh-route" => Ok(Command::MeshRoute),
|
|
"mesh-identity" | "mesh-id" => Ok(Command::MeshIdentity),
|
|
"mesh-store" => Ok(Command::MeshStore),
|
|
"mesh-trace" => Ok(Command::MeshTrace {
|
|
address: self.resolve_str(&step.args, "address")?,
|
|
}),
|
|
"mesh-stats" => Ok(Command::MeshStats),
|
|
|
|
other => bail!("unknown command: {other}"),
|
|
}
|
|
}
|
|
|
|
/// Build an `AssertCondition` from a playbook step.
|
|
fn build_assert_condition(&self, step: &PlaybookStep) -> anyhow::Result<AssertCondition> {
|
|
let cond = step
|
|
.condition
|
|
.as_deref()
|
|
.context("assert step requires 'condition' field")?;
|
|
match cond {
|
|
"connected" => Ok(AssertCondition::Connected),
|
|
"logged_in" => Ok(AssertCondition::LoggedIn),
|
|
"in_conversation" => {
|
|
let name = self.resolve_str(&step.args, "name")
|
|
.or_else(|_| step.value.as_ref()
|
|
.and_then(|v| v.as_str())
|
|
.map(|s| self.substitute(s))
|
|
.context("assert in_conversation requires 'name' arg or 'value'"))?;
|
|
Ok(AssertCondition::InConversation { name })
|
|
}
|
|
"message_count" => {
|
|
let op = self.parse_cmp_op(step.op.as_deref().unwrap_or("gte"))?;
|
|
let count = step
|
|
.value
|
|
.as_ref()
|
|
.and_then(|v| v.as_u64())
|
|
.context("message_count assert requires numeric 'value'")?
|
|
as usize;
|
|
Ok(AssertCondition::MessageCount { op, count })
|
|
}
|
|
"member_count" => {
|
|
let op = self.parse_cmp_op(step.op.as_deref().unwrap_or("gte"))?;
|
|
let count = step
|
|
.value
|
|
.as_ref()
|
|
.and_then(|v| v.as_u64())
|
|
.context("member_count assert requires numeric 'value'")?
|
|
as usize;
|
|
Ok(AssertCondition::MemberCount { op, count })
|
|
}
|
|
other => Ok(AssertCondition::Custom {
|
|
expression: other.to_string(),
|
|
}),
|
|
}
|
|
}
|
|
|
|
fn parse_cmp_op(&self, s: &str) -> anyhow::Result<CmpOp> {
|
|
match s {
|
|
"eq" | "==" => Ok(CmpOp::Eq),
|
|
"ne" | "!=" => Ok(CmpOp::Ne),
|
|
"gt" | ">" => Ok(CmpOp::Gt),
|
|
"lt" | "<" => Ok(CmpOp::Lt),
|
|
"gte" | ">=" => Ok(CmpOp::Gte),
|
|
"lte" | "<=" => Ok(CmpOp::Lte),
|
|
other => bail!("unknown comparison operator: {other}"),
|
|
}
|
|
}
|
|
|
|
// ── Variable substitution helpers ────────────────────────────────────
|
|
|
|
/// Substitute `$varname` and `${VAR:-default}` in a string.
|
|
fn substitute(&self, s: &str) -> String {
|
|
let mut result = String::with_capacity(s.len());
|
|
let mut chars = s.chars().peekable();
|
|
while let Some(c) = chars.next() {
|
|
if c == '$' {
|
|
if chars.peek() == Some(&'{') {
|
|
chars.next(); // consume '{'
|
|
let mut key = String::new();
|
|
let mut default = None;
|
|
while let Some(&ch) = chars.peek() {
|
|
if ch == '}' {
|
|
chars.next();
|
|
break;
|
|
}
|
|
if ch == ':' && chars.clone().nth(1) == Some('-') {
|
|
chars.next(); // consume ':'
|
|
chars.next(); // consume '-'
|
|
let mut def = String::new();
|
|
while let Some(&dch) = chars.peek() {
|
|
if dch == '}' {
|
|
chars.next();
|
|
break;
|
|
}
|
|
def.push(dch);
|
|
chars.next();
|
|
}
|
|
default = Some(def);
|
|
break;
|
|
}
|
|
key.push(ch);
|
|
chars.next();
|
|
}
|
|
if let Some(val) = self.vars.get(&key) {
|
|
result.push_str(val);
|
|
} else if let Ok(val) = std::env::var(&key) {
|
|
result.push_str(&val);
|
|
} else if let Some(def) = default {
|
|
result.push_str(&def);
|
|
}
|
|
} else {
|
|
let mut key = String::new();
|
|
while let Some(&ch) = chars.peek() {
|
|
if ch.is_alphanumeric() || ch == '_' {
|
|
key.push(ch);
|
|
chars.next();
|
|
} else {
|
|
break;
|
|
}
|
|
}
|
|
if let Some(val) = self.vars.get(&key) {
|
|
result.push_str(val);
|
|
} else {
|
|
result.push('$');
|
|
result.push_str(&key);
|
|
}
|
|
}
|
|
} else {
|
|
result.push(c);
|
|
}
|
|
}
|
|
result
|
|
}
|
|
|
|
/// Resolve a required string argument with variable substitution.
|
|
fn resolve_str(
|
|
&self,
|
|
args: &HashMap<String, serde_yaml::Value>,
|
|
key: &str,
|
|
) -> anyhow::Result<String> {
|
|
let val = args
|
|
.get(key)
|
|
.with_context(|| format!("missing required argument: {key}"))?;
|
|
match val {
|
|
serde_yaml::Value::String(s) => Ok(self.substitute(s)),
|
|
serde_yaml::Value::Number(n) => Ok(n.to_string()),
|
|
serde_yaml::Value::Bool(b) => Ok(b.to_string()),
|
|
other => Ok(format!("{other:?}")),
|
|
}
|
|
}
|
|
|
|
/// Resolve an optional string argument.
|
|
fn opt_str(
|
|
&self,
|
|
args: &HashMap<String, serde_yaml::Value>,
|
|
key: &str,
|
|
) -> Option<String> {
|
|
args.get(key).map(|v| match v {
|
|
serde_yaml::Value::String(s) => self.substitute(s),
|
|
serde_yaml::Value::Number(n) => n.to_string(),
|
|
serde_yaml::Value::Bool(b) => b.to_string(),
|
|
other => format!("{other:?}"),
|
|
})
|
|
}
|
|
|
|
/// Resolve an optional bool argument (defaults to false).
|
|
fn opt_bool(
|
|
&self,
|
|
args: &HashMap<String, serde_yaml::Value>,
|
|
key: &str,
|
|
) -> bool {
|
|
args.get(key)
|
|
.and_then(|v| v.as_bool())
|
|
.unwrap_or(false)
|
|
}
|
|
|
|
/// Resolve a required usize argument.
|
|
fn resolve_usize(
|
|
&self,
|
|
args: &HashMap<String, serde_yaml::Value>,
|
|
key: &str,
|
|
) -> anyhow::Result<usize> {
|
|
let val = args
|
|
.get(key)
|
|
.with_context(|| format!("missing required argument: {key}"))?;
|
|
val.as_u64()
|
|
.map(|n| n as usize)
|
|
.with_context(|| format!("argument '{key}' must be a positive integer"))
|
|
}
|
|
|
|
/// Resolve a required u64 argument.
|
|
fn resolve_u64(
|
|
&self,
|
|
args: &HashMap<String, serde_yaml::Value>,
|
|
key: &str,
|
|
) -> anyhow::Result<u64> {
|
|
let val = args
|
|
.get(key)
|
|
.with_context(|| format!("missing required argument: {key}"))?;
|
|
val.as_u64()
|
|
.with_context(|| format!("argument '{key}' must be a positive integer"))
|
|
}
|
|
|
|
/// Resolve an optional usize argument.
|
|
fn opt_usize(
|
|
&self,
|
|
args: &HashMap<String, serde_yaml::Value>,
|
|
key: &str,
|
|
) -> Option<usize> {
|
|
args.get(key).and_then(|v| v.as_u64()).map(|n| n as usize)
|
|
}
|
|
|
|
/// Count total expanded steps (including loop iterations).
|
|
fn expanded_step_count(&self) -> usize {
|
|
self.playbook
|
|
.steps
|
|
.iter()
|
|
.map(|s| {
|
|
if let Some(ref ls) = s.loop_spec {
|
|
if ls.to >= ls.from {
|
|
ls.to - ls.from + 1
|
|
} else {
|
|
0
|
|
}
|
|
} else {
|
|
1
|
|
}
|
|
})
|
|
.sum()
|
|
}
|
|
}
|
|
|
|
// ── Tests ───────────────────────────────────────────────────────────────────
|
|
|
|
#[cfg(test)]
|
|
mod tests {
|
|
use super::*;
|
|
|
|
#[test]
|
|
fn parse_minimal_playbook() {
|
|
let yaml = r#"
|
|
name: "test"
|
|
steps:
|
|
- command: whoami
|
|
- command: list
|
|
"#;
|
|
let runner = PlaybookRunner::from_str(yaml).unwrap();
|
|
assert_eq!(runner.playbook.name, "test");
|
|
assert_eq!(runner.playbook.steps.len(), 2);
|
|
assert_eq!(runner.playbook.steps[0].command, "whoami");
|
|
}
|
|
|
|
#[test]
|
|
fn parse_playbook_with_variables() {
|
|
let yaml = r#"
|
|
name: "var test"
|
|
variables:
|
|
user: alice
|
|
server: "127.0.0.1:5001"
|
|
steps:
|
|
- command: dm
|
|
args:
|
|
username: "$user"
|
|
"#;
|
|
let runner = PlaybookRunner::from_str(yaml).unwrap();
|
|
assert_eq!(runner.vars["user"], "alice");
|
|
assert_eq!(runner.vars["server"], "127.0.0.1:5001");
|
|
}
|
|
|
|
#[test]
|
|
fn variable_substitution() {
|
|
let mut vars = HashMap::new();
|
|
vars.insert("name".to_string(), "alice".to_string());
|
|
vars.insert("port".to_string(), "5001".to_string());
|
|
let runner = PlaybookRunner {
|
|
playbook: Playbook {
|
|
name: "test".into(),
|
|
description: None,
|
|
variables: HashMap::new(),
|
|
steps: vec![],
|
|
},
|
|
vars,
|
|
};
|
|
assert_eq!(runner.substitute("hello $name"), "hello alice");
|
|
assert_eq!(runner.substitute("port=$port!"), "port=5001!");
|
|
assert_eq!(runner.substitute("${name}@server"), "alice@server");
|
|
assert_eq!(
|
|
runner.substitute("${missing:-default}"),
|
|
"default"
|
|
);
|
|
assert_eq!(runner.substitute("no vars here"), "no vars here");
|
|
}
|
|
|
|
#[test]
|
|
fn step_to_command_mapping() {
|
|
let yaml = r#"
|
|
name: "mapping test"
|
|
variables:
|
|
user: bob
|
|
steps:
|
|
- command: dm
|
|
args:
|
|
username: "$user"
|
|
- command: send
|
|
args:
|
|
text: "hello"
|
|
- command: history
|
|
args:
|
|
count: 10
|
|
- command: wait
|
|
args:
|
|
duration_ms: 500
|
|
"#;
|
|
let runner = PlaybookRunner::from_str(yaml).unwrap();
|
|
let cmd0 = runner.step_to_command(&runner.playbook.steps[0]).unwrap();
|
|
assert!(matches!(cmd0, Command::Dm { username } if username == "bob"));
|
|
|
|
let cmd1 = runner.step_to_command(&runner.playbook.steps[1]).unwrap();
|
|
assert!(matches!(cmd1, Command::SendMessage { text } if text == "hello"));
|
|
|
|
let cmd2 = runner.step_to_command(&runner.playbook.steps[2]).unwrap();
|
|
assert!(matches!(cmd2, Command::History { count: 10 }));
|
|
|
|
let cmd3 = runner.step_to_command(&runner.playbook.steps[3]).unwrap();
|
|
assert!(matches!(cmd3, Command::Wait { duration_ms: 500 }));
|
|
}
|
|
|
|
#[test]
|
|
fn parse_assert_step() {
|
|
let yaml = r#"
|
|
name: "assert test"
|
|
steps:
|
|
- command: assert
|
|
condition: message_count
|
|
op: gte
|
|
value: 5
|
|
"#;
|
|
let runner = PlaybookRunner::from_str(yaml).unwrap();
|
|
let cmd = runner.step_to_command(&runner.playbook.steps[0]).unwrap();
|
|
match cmd {
|
|
Command::Assert {
|
|
condition: AssertCondition::MessageCount { op, count },
|
|
} => {
|
|
assert_eq!(op, CmpOp::Gte);
|
|
assert_eq!(count, 5);
|
|
}
|
|
other => panic!("expected Assert MessageCount, got {other:?}"),
|
|
}
|
|
}
|
|
|
|
#[test]
|
|
fn parse_loop_spec() {
|
|
let yaml = r#"
|
|
name: "loop test"
|
|
steps:
|
|
- command: send
|
|
args:
|
|
text: "msg $i"
|
|
loop:
|
|
var: i
|
|
from: 1
|
|
to: 5
|
|
"#;
|
|
let runner = PlaybookRunner::from_str(yaml).unwrap();
|
|
assert_eq!(runner.expanded_step_count(), 5);
|
|
let ls = runner.playbook.steps[0].loop_spec.as_ref().unwrap();
|
|
assert_eq!(ls.var, "i");
|
|
assert_eq!(ls.from, 1);
|
|
assert_eq!(ls.to, 5);
|
|
}
|
|
|
|
#[test]
|
|
fn on_error_defaults_to_fail() {
|
|
let yaml = r#"
|
|
name: "error test"
|
|
steps:
|
|
- command: whoami
|
|
- command: list
|
|
on_error: continue
|
|
- command: quit
|
|
on_error: skip
|
|
"#;
|
|
let runner = PlaybookRunner::from_str(yaml).unwrap();
|
|
assert_eq!(runner.playbook.steps[0].on_error, OnError::Fail);
|
|
assert_eq!(runner.playbook.steps[1].on_error, OnError::Continue);
|
|
assert_eq!(runner.playbook.steps[2].on_error, OnError::Skip);
|
|
}
|
|
|
|
#[test]
|
|
fn cmp_op_parsing() {
|
|
let runner = PlaybookRunner::from_str("name: t\nsteps: []").unwrap();
|
|
assert!(matches!(runner.parse_cmp_op("eq"), Ok(CmpOp::Eq)));
|
|
assert!(matches!(runner.parse_cmp_op("=="), Ok(CmpOp::Eq)));
|
|
assert!(matches!(runner.parse_cmp_op("gte"), Ok(CmpOp::Gte)));
|
|
assert!(matches!(runner.parse_cmp_op(">="), Ok(CmpOp::Gte)));
|
|
assert!(matches!(runner.parse_cmp_op("<"), Ok(CmpOp::Lt)));
|
|
assert!(runner.parse_cmp_op("invalid").is_err());
|
|
}
|
|
|
|
#[test]
|
|
fn report_display() {
|
|
let report = PlaybookReport {
|
|
name: "test".into(),
|
|
total_steps: 3,
|
|
passed: 2,
|
|
failed: 1,
|
|
skipped: 0,
|
|
duration: Duration::from_millis(150),
|
|
step_results: vec![
|
|
StepResult {
|
|
step_index: 0,
|
|
command: "whoami".into(),
|
|
success: true,
|
|
duration: Duration::from_millis(10),
|
|
output: None,
|
|
error: None,
|
|
},
|
|
StepResult {
|
|
step_index: 1,
|
|
command: "dm".into(),
|
|
success: true,
|
|
duration: Duration::from_millis(50),
|
|
output: None,
|
|
error: None,
|
|
},
|
|
StepResult {
|
|
step_index: 2,
|
|
command: "assert".into(),
|
|
success: false,
|
|
duration: Duration::from_millis(1),
|
|
output: None,
|
|
error: Some("message count 0 < 1".into()),
|
|
},
|
|
],
|
|
};
|
|
let s = format!("{report}");
|
|
assert!(s.contains("2 passed, 1 failed"));
|
|
assert!(s.contains("[3/3] assert ... FAIL"));
|
|
}
|
|
}
|