use std::time::Duration;
use serde_json::Value as JsonValue;
use crate::pyrepr::{repr_f64, repr_json, repr_str, repr_tuple, type_name};
use crate::result::StepResult;
use crate::terminal::Session;
fn display_name(step: &JsonValue, index: usize, action: &str) -> String {
step.get("name")
.and_then(|v| v.as_str())
.map(|s| s.to_string())
.unwrap_or_else(|| format!("{index}:{action}"))
}
fn coerce_float(field: &str, v: &JsonValue) -> Result<f64, String> {
let rejected = || format!("{field} must be a number, got {}", repr_json(v));
match v {
JsonValue::Number(n) => n.as_f64().ok_or_else(rejected),
JsonValue::Bool(b) => Ok(if *b { 1.0 } else { 0.0 }),
JsonValue::String(text) => text.trim().parse::<f64>().map_err(|_| rejected()),
_ => Err(rejected()),
}
}
const FAR_FUTURE: Duration = Duration::from_secs(100 * 365 * 24 * 60 * 60);
pub(crate) fn duration_from_secs(seconds: f64) -> Duration {
if seconds.is_nan() || seconds <= 0.0 {
Duration::ZERO
} else if seconds >= FAR_FUTURE.as_secs() as f64 {
FAR_FUTURE
} else {
Duration::from_secs_f64(seconds)
}
}
fn stable_window_from_secs(seconds: f64) -> Duration {
if seconds.is_finite() {
duration_from_secs(seconds)
} else {
Duration::ZERO
}
}
const MAX_SLEEP_SECONDS: f64 = i64::MAX as f64;
fn deadline_from(timeout: Duration) -> Option<std::time::Instant> {
std::time::Instant::now().checked_add(timeout)
}
fn deadline_passed(deadline: Option<std::time::Instant>) -> bool {
match deadline {
Some(d) => std::time::Instant::now() >= d,
None => false,
}
}
fn validate_regex_timeout(raw: &JsonValue, field: &str) -> Result<f64, String> {
let f = coerce_float(field, raw)?;
if !f.is_finite() {
return Err(format!("{field} must be finite, got {}", repr_f64(f)));
}
if f <= 0.0 {
return Err(format!("{field} must be > 0, got {}", repr_f64(f)));
}
Ok(f)
}
pub fn wait_for_text<S: Session + ?Sized>(
session: &mut S,
step: &JsonValue,
index: usize,
) -> StepResult {
let name = display_name(step, index, "wait_for_text");
let text = match step.get("text").and_then(|v| v.as_str()) {
Some(t) => t.to_string(),
None => {
return StepResult {
name,
passed: false,
detail: "wait_for_text 'text' must be a string".into(),
screen: session.screen().to_string(),
};
}
};
let timeout = match step.get("timeout_seconds") {
None => Duration::from_secs(10),
Some(v) => match coerce_float("timeout_seconds", v) {
Ok(f) => duration_from_secs(f),
Err(e) => {
return StepResult {
name,
passed: false,
detail: e,
screen: session.screen().to_string(),
};
}
},
};
let passed = match session.wait_for_text(&text, timeout) {
Ok(v) => v,
Err(e) => {
return StepResult {
name,
passed: false,
detail: format!("wait_for_text failed: {e}"),
screen: session.screen().to_string(),
};
}
};
let detail = if passed {
format!("found {}", repr_str(&text))
} else {
format!("timed out waiting for {}", repr_str(&text))
};
StepResult {
name,
passed,
detail,
screen: session.screen().to_string(),
}
}
pub fn wait_for_idle<S: Session + ?Sized>(
session: &mut S,
step: &JsonValue,
index: usize,
) -> StepResult {
let name = display_name(step, index, "wait_for_idle");
let secs = match step.get("stable_seconds") {
None => 0.5,
Some(v) => match coerce_float("stable_seconds", v) {
Ok(f) => f,
Err(e) => {
return StepResult {
name,
passed: false,
detail: e,
screen: session.screen().to_string(),
};
}
},
};
let stable = stable_window_from_secs(secs);
let timeout = match step.get("timeout_seconds") {
None => Duration::from_secs(10),
Some(v) => match coerce_float("timeout_seconds", v) {
Ok(f) => duration_from_secs(f),
Err(e) => {
return StepResult {
name,
passed: false,
detail: e,
screen: session.screen().to_string(),
};
}
},
};
let passed = match session.wait_for_idle(stable, timeout) {
Ok(v) => v,
Err(e) => {
return StepResult {
name,
passed: false,
detail: format!("wait_for_idle failed: {e}"),
screen: session.screen().to_string(),
};
}
};
let detail = if passed {
format!("stable for {}s", repr_f64(secs))
} else {
"timed out waiting for idle".into()
};
StepResult {
name,
passed,
detail,
screen: session.screen().to_string(),
}
}
pub fn send_text<S: Session + ?Sized>(
session: &mut S,
step: &JsonValue,
index: usize,
) -> StepResult {
let name = display_name(step, index, "send_text");
let text = match step.get("text").and_then(|v| v.as_str()) {
Some(t) => t.to_string(),
None => {
return StepResult {
name,
passed: false,
detail: "send_text 'text' must be a string".into(),
screen: session.screen().to_string(),
};
}
};
match session.send_text(&text) {
Ok(()) => StepResult {
name,
passed: true,
detail: "sent text".into(),
screen: session.screen().to_string(),
},
Err(e) => StepResult {
name,
passed: false,
detail: e.to_string(),
screen: session.screen().to_string(),
},
}
}
pub fn send_line<S: Session + ?Sized>(
session: &mut S,
step: &JsonValue,
index: usize,
) -> StepResult {
let name = display_name(step, index, "send_line");
let text = match step.get("text") {
None => String::new(),
Some(JsonValue::String(s)) => s.clone(),
Some(other) => {
return StepResult {
name,
passed: false,
detail: format!(
"send_line 'text' must be a string, got {}",
type_name(other)
),
screen: session.screen().to_string(),
};
}
};
match session.send_line(&text) {
Ok(()) => StepResult {
name,
passed: true,
detail: "sent line".into(),
screen: session.screen().to_string(),
},
Err(e) => StepResult {
name,
passed: false,
detail: e.to_string(),
screen: session.screen().to_string(),
},
}
}
pub fn press<S: Session + ?Sized>(session: &mut S, step: &JsonValue, index: usize) -> StepResult {
let name = display_name(step, index, "press");
let key = match step.get("key").and_then(|v| v.as_str()) {
Some(k) => k.to_string(),
None => {
return StepResult {
name,
passed: false,
detail: "press 'key' must be a string".into(),
screen: session.screen().to_string(),
};
}
};
match session.press(&key) {
Ok(()) => StepResult {
name,
passed: true,
detail: format!("pressed {key}"),
screen: session.screen().to_string(),
},
Err(e) => StepResult {
name,
passed: false,
detail: e.to_string(),
screen: session.screen().to_string(),
},
}
}
pub fn sleep<S: Session + ?Sized>(session: &mut S, step: &JsonValue, index: usize) -> StepResult {
let name = display_name(step, index, "sleep");
let seconds = match step.get("seconds") {
None => 1.0,
Some(v) => match coerce_float("seconds", v) {
Ok(f) => f,
Err(e) => {
return StepResult {
name,
passed: false,
detail: e,
screen: session.screen().to_string(),
};
}
},
};
if !seconds.is_finite() {
return StepResult {
name,
passed: false,
detail: format!("seconds must be finite, got {}", repr_f64(seconds)),
screen: session.screen().to_string(),
};
}
if seconds < 0.0 {
return StepResult {
name,
passed: false,
detail: format!("seconds must be >= 0, got {}", repr_f64(seconds)),
screen: session.screen().to_string(),
};
}
if seconds > MAX_SLEEP_SECONDS {
return StepResult {
name,
passed: false,
detail: format!(
"seconds is out of range for the platform sleep clock, got {}",
repr_f64(seconds)
),
screen: session.screen().to_string(),
};
}
std::thread::sleep(Duration::from_secs_f64(seconds));
let _ = session.read_available(Duration::ZERO);
StepResult {
name,
passed: true,
detail: "slept".into(),
screen: session.screen().to_string(),
}
}
pub fn wait_for_regex<S: Session + ?Sized>(
session: &mut S,
step: &JsonValue,
index: usize,
) -> StepResult {
let name = display_name(step, index, "wait_for_regex");
let pattern_str = match step.get("pattern").and_then(|v| v.as_str()) {
Some(s) => s.to_string(),
None => {
let got = type_name(step.get("pattern").unwrap_or(&JsonValue::Null));
return StepResult {
name,
passed: false,
detail: format!("wait_for_regex 'pattern' must be a string, got {got}"),
screen: session.screen().to_string(),
};
}
};
let re = match crate::pyregex::compile(&pattern_str) {
Ok(r) => r,
Err(e) => {
return StepResult {
name,
passed: false,
detail: format!("invalid regex {}: {e}", repr_str(&pattern_str)),
screen: session.screen().to_string(),
};
}
};
let timeout_secs = match step.get("timeout_seconds") {
None => 10.0,
Some(v) => match validate_regex_timeout(v, "wait_for_regex timeout_seconds") {
Ok(f) => f,
Err(e) => {
return StepResult {
name,
passed: false,
detail: e,
screen: session.screen().to_string(),
};
}
},
};
let timeout = duration_from_secs(timeout_secs);
let deadline = deadline_from(timeout);
loop {
let _ = session.read_available(Duration::from_millis(50));
let screen_text = session.screen().to_string();
let raw_text = session.raw_output().to_string();
if let Some(result) = try_match(&re, &pattern_str, &name, &screen_text, &raw_text) {
return result;
}
if deadline_passed(deadline) {
break;
}
if !session.is_alive() {
let _ = session.read_available(Duration::ZERO);
let screen_text2 = session.screen().to_string();
let raw_text2 = session.raw_output().to_string();
if let Some(result) = try_match(&re, &pattern_str, &name, &screen_text2, &raw_text2) {
return result;
}
break;
}
}
StepResult {
name,
passed: false,
detail: format!(
"timed out waiting for regex {} after {}s",
repr_str(&pattern_str),
repr_f64(timeout_secs)
),
screen: session.screen().to_string(),
}
}
fn try_match<'t>(
re: &crate::pyregex::PyRegex,
pattern_str: &str,
name: &str,
screen_text: &'t str,
raw_text: &'t str,
) -> Option<StepResult> {
let captures_in = |text: &'t str| -> Option<crate::pyregex::PyCaptures<'t>> {
if text.is_empty() {
return None;
}
re.captures(text).ok().flatten()
};
let caps = captures_in(screen_text).or_else(|| captures_in(raw_text))?;
let full = caps.get(0).map(|m| m.as_str()).unwrap_or("");
let named: Vec<String> = caps
.named()
.map(|(n, m)| match m {
Some(m) => format!("{n}={}", repr_str(m.as_str())),
None => format!("{n}=None"),
})
.collect();
let has_pos = caps.len() > 1;
let mut parts: Vec<String> = Vec::new();
if !named.is_empty() {
parts.push(named.join(", "));
}
if has_pos {
let groups: Vec<String> = (1..caps.len())
.map(|i| match caps.get(i) {
Some(m) => repr_str(m.as_str()),
None => "None".to_string(),
})
.collect();
parts.push(format!("groups={}", repr_tuple(&groups)));
}
let pattern = repr_str(pattern_str);
let detail = if parts.is_empty() {
format!("matched {pattern} -> match={}", repr_str(full))
} else {
format!(
"matched {pattern} -> {} (full: {})",
parts.join("; "),
repr_str(full)
)
};
Some(StepResult {
name: name.to_string(),
passed: true,
detail,
screen: screen_text.to_string(),
})
}
pub fn dispatch<S: Session + ?Sized>(
session: &mut S,
step: &JsonValue,
index: usize,
) -> StepResult {
let action = match step.get("action").and_then(|v| v.as_str()) {
Some(a) => a,
None => {
let display = display_name(step, index, "unknown");
return StepResult {
name: display,
passed: false,
detail: "step 'action' must be a string".into(),
screen: session.screen().to_string(),
};
}
};
let display = display_name(step, index, action);
match action {
"wait_for_text" => wait_for_text(session, step, index),
"wait_for_idle" => wait_for_idle(session, step, index),
"send_text" => send_text(session, step, index),
"send_line" => send_line(session, step, index),
"press" => press(session, step, index),
"sleep" => sleep(session, step, index),
"wait_for_regex" => wait_for_regex(session, step, index),
other => StepResult {
name: display,
passed: false,
detail: format!("unknown step action: {other}"),
screen: session.screen().to_string(),
},
}
}
pub fn run_steps<S: Session + ?Sized>(session: &mut S, steps: &[JsonValue]) -> Vec<StepResult> {
let mut out = Vec::with_capacity(steps.len());
for (idx, step) in steps.iter().enumerate() {
let r = dispatch(session, step, idx + 1);
let failed = !r.passed;
out.push(r);
if failed {
break;
}
}
out
}
#[cfg(test)]
mod tests {
use super::*;
use crate::terminal::InMemorySession;
use serde_json::json;
use std::path::PathBuf;
fn sess(screen: &str, raw: &str) -> InMemorySession {
let mut s = InMemorySession::new(vec!["sh".into()], PathBuf::from("/tmp/cast"), 80, 24);
if !screen.is_empty() || !raw.is_empty() {
s.set_screen(screen.to_string());
s.set_raw(raw.to_string());
}
s
}
#[test]
fn dispatch_unknown_action_fails() {
let mut s = sess("", "");
let r = dispatch(&mut s, &json!({"action": "nope"}), 1);
assert!(!r.passed);
assert!(r.detail.contains("unknown step action"));
}
#[test]
fn dispatch_missing_action_fails() {
let mut s = sess("", "");
let r = dispatch(&mut s, &json!({"text": "hi"}), 2);
assert!(!r.passed);
assert!(r.detail.contains("'action'"));
}
#[test]
fn run_steps_stops_on_failure() {
let mut s = sess("hello", "");
let steps = vec![
json!({"action": "wait_for_text", "text": "hello"}),
json!({"action": "wait_for_text", "text": "MISSING", "timeout_seconds": 0.05}),
json!({"action": "send_text", "text": "should not run"}),
];
let out = run_steps(&mut s, &steps);
assert_eq!(out.len(), 2);
assert!(out[0].passed);
assert!(!out[1].passed);
}
#[test]
fn wait_for_regex_captures_named_groups() {
let mut s = sess("user: alice id: 42", "");
let r = wait_for_regex(
&mut s,
&json!({"pattern": r"user: (?P<user>\w+) id: (?P<id>\d+)"}),
1,
);
assert!(r.passed, "detail={}", r.detail);
assert!(r.detail.contains("alice"));
assert!(r.detail.contains("42"));
}
#[test]
fn wait_for_regex_no_synthetic_boundary() {
let mut s = sess("FIRST", "SECOND");
let r = wait_for_regex(
&mut s,
&json!({"pattern": r"FIRST.SECOND", "timeout_seconds": 0.05}),
1,
);
assert!(
!r.passed,
"synthetic boundary must not create a match: {}",
r.detail
);
}
#[test]
fn wait_for_regex_invalid_pattern_fails() {
let mut s = sess("", "");
let r = wait_for_regex(&mut s, &json!({"pattern": "[bad"}), 1);
assert!(!r.passed);
assert!(r.detail.to_lowercase().contains("invalid"));
}
#[test]
fn wait_for_regex_non_string_pattern_fails() {
let mut s = sess("", "");
let r = wait_for_regex(&mut s, &json!({"pattern": 42}), 1);
assert!(!r.passed);
assert!(r.detail.contains("pattern"));
}
#[test]
fn wait_for_regex_zero_timeout_fails() {
let mut s = sess("", "");
let r = wait_for_regex(&mut s, &json!({"pattern": r"\d+", "timeout_seconds": 0}), 1);
assert!(!r.passed);
assert!(r.detail.to_lowercase().contains("timeout"));
}
#[test]
fn wait_for_regex_nan_timeout_fails() {
let mut s = sess("", "");
let mut step = json!({"pattern": r"\d+"});
step["timeout_seconds"] = serde_json::Value::Number(
serde_json::Number::from_f64(f64::NAN).unwrap_or(serde_json::Number::from(0)),
);
let r = wait_for_regex(&mut s, &step, 1);
assert!(!r.passed);
}
#[test]
fn sleep_zero_is_ok() {
let mut s = sess("hi", "");
let r = sleep(&mut s, &json!({"seconds": 0}), 1);
assert!(r.passed);
}
#[test]
fn sleep_negative_fails() {
let mut s = sess("", "");
let r = sleep(&mut s, &json!({"seconds": -1}), 1);
assert!(!r.passed);
}
#[test]
fn press_unknown_key_fails() {
let mut s = sess("", "");
let r = press(&mut s, &json!({"key": "f13"}), 1);
assert!(!r.passed);
}
#[test]
fn send_text_records_input() {
let mut s = sess("", "");
let r = send_text(&mut s, &json!({"text": "hi"}), 1);
assert!(r.passed);
assert!(s.log.iter().any(|e| e == "send_text:hi"));
}
#[test]
fn send_line_appends_cr() {
let mut s = sess("", "");
let r = send_line(&mut s, &json!({"text": "hi"}), 1);
assert!(r.passed);
assert!(s.log.iter().any(|e| e == "send_line:hi"));
}
}