//! Replay scripts: a bug or crash as a list of commands an agent (or a test) can run again. //! //! The session's command journal ([`Session::journal`]) becomes a JSON-lines script //! (`journal.export`, `help.exportRepro`, and automatically when the last-resort guard catches a //! panic, see [`after_command`]); `effectcraft-cli replay script.jsonl` runs one headless and //! `crates/host/tests/it/repros.rs` runs every `tests/repros/*.jsonl` as a regression test. //! //! Format (one JSON object per line; blank lines and lines starting with `//` or `#` are //! comments): //! //! ```text //! {"start": "new" | "demo" | {"project": "path.ecproj"}, "allow_errors"?: bool} optional, first //! {"command": "comp.new", "params": {...}, "expect_error"?: true | "substring"} //! {"expect": {"query": "prop.get", "params": {...}, "pointer"?: "/value", "equals"?: ...}} //! {"expect_no_error": true} //! ``` //! //! A command must succeed unless it says `expect_error` (then it must fail, with that text in //! the message when it is a string), or the start line says `allow_errors` (errors are reported //! but tolerated; crash repros say so, since after the fix the crashing step may fail cleanly). //! A panic always fails. `expect` runs a command (normally a query) and compares the value at //! the JSON `pointer` of its result with `equals` (numbers within 1e-6); `expect_no_error` //! checks that the previous command succeeded. Other keys (`version`, `app`, `note`, `crash`…) //! are information for people. Relative `project` paths are relative to the script. //! //! Privacy: a repro holds command ids and their parameters only, never project or media file //! contents. Parameters can include file paths, layer names and text typed into text layers. use std::cell::Cell; use std::path::{Path, PathBuf}; use serde::Serialize; use serde_json::{Map, Value, json}; use crate::{EngineError, Result, Session, guard}; /// The format version written into exported headers. pub const VERSION: u64 = 1; /// Largest script [`run`] accepts (bytes). pub const MAX_SCRIPT_BYTES: usize = 64 << 20; /// Most lines [`run`] reads. pub const MAX_LINES: usize = 100_000; /// Exported scripts stay below this size: the oldest steps are dropped (and counted). const MAX_EXPORT_BYTES: usize = 32 << 20; /// Folder of saved repros in the settings store (next to `Logs`). pub const REPRO_DIR: &str = "Repros"; /// Automatic crash repros kept (the oldest are removed). const KEEP_CRASH_REPROS: usize = 20; /// Commands that replace the whole project: an export starts at the last one. const PROJECT_STARTS: &[&str] = &["file.newProject", "file.open", "file.openDemoProject"]; /// Error and value texts in reports are cut to this many characters. const MAX_TEXT: usize = 600; // ---------- nesting and crash capture (Session::execute) ---------- thread_local! { /// Commands running on this thread: (all, journaled ones). static DEPTH: Cell<(u32, u32)> = const { Cell::new((0, 0)) }; /// A replay is running on this thread (its panics are reported, not saved as repros). static REPLAYING: Cell = const { Cell::new(false) }; } /// One running command (see [`Session::execute`]): commands it runs itself (a script's steps) /// aren't journaled again, and only the outermost command saves a crash repro. pub struct Nesting { outer: (u32, u32), } impl Nesting { /// Record nesting so commands dispatched by a script are not exported twice. pub fn enter(journaled: bool) -> Nesting { let outer = DEPTH.with(Cell::get); DEPTH.with(|d| d.set((outer.0.saturating_add(1), outer.1.saturating_add(u32::from(journaled))))); Nesting { outer } } /// Run by a journaled command (which replays it). pub fn inside_journaled(&self) -> bool { self.outer.1 > 0 } /// Whether this command is responsible for capturing a nested panic. pub fn outermost(&self) -> bool { self.outer.0 == 0 } } impl Drop for Nesting { fn drop(&mut self) { DEPTH.with(|d| d.set(self.outer)); } } /// After the outermost command: when the guard caught a panic while it ran (`caught` is /// [`guard::caught`] from before), save the journal plus this command as a crash repro in the /// settings store and name it in the error. pub fn after_command(s: &Session, id: &str, params: &Value, nesting: &Nesting, caught: u64, r: Result) -> Result { if !nesting.outermost() || guard::caught() == caught || REPLAYING.with(Cell::get) { return r; } let error = match &r { Err(e) => e.to_string(), Ok(_) => "a step it ran failed with an internal error".to_string(), }; let saved = save_crash_repro(s, id, params, &error); match (r, saved) { (Err(EngineError::Other(m)), Some(path)) => Err(EngineError::Other(format!("{m} (the steps that led here were saved to {path})"))), (r, _) => r, } } /// Wall-clock seconds used only to label exported repros. fn unix_secs() -> u64 { web_time::SystemTime::now().duration_since(web_time::UNIX_EPOCH).map(|d| d.as_secs()).unwrap_or(0) } /// `Repros/--.jsonl`. fn repro_name(prefix: &str, id: &str) -> String { let id: String = id.chars().map(|c| if c.is_ascii_alphanumeric() || c == '.' { c } else { '_' }).take(60).collect(); format!("{REPRO_DIR}/{prefix}-{:012}-{id}.jsonl", unix_secs()) } /// Where a store entry is on disk (or its name in stores without a folder). fn store_path(store: &dyn crate::config::ConfigStore, name: &str) -> String { store.dir().map(|d| d.join(name).display().to_string()).unwrap_or_else(|| name.to_string()) } /// Persist the failing command with its preceding journal and prune older crash repros. fn save_crash_repro(s: &Session, id: &str, params: &Value, error: &str) -> Option { let store = s.config.clone()?; let mut text = export(s, Some(json!({"command": id, "error": cut(error)}))); text.push_str(&command_line(id, params)); text.push('\n'); let name = repro_name("crash", id); if let Err(e) = store.write(&name, &text) { log::error!("cannot save the crash repro {name}: {e}"); return None; } // Keep the newest few (names sort by time). let mut old: Vec = store.list(REPRO_DIR).into_iter().filter(|n| n.starts_with("crash-")).collect(); old.sort(); let extra = old.len().saturating_sub(KEEP_CRASH_REPROS); for n in old.into_iter().take(extra) { let _ = store.remove(&format!("{REPRO_DIR}/{n}")); } let path = store_path(store.as_ref(), &name); log::error!("crash repro saved to {path}"); Some(path) } /// Save the journal as a repro: at `path` (through the session's file services), else in the /// settings store's `Repros` folder. Returns where it went and how many steps it holds. pub fn save_repro(s: &Session, path: Option<&str>) -> Result<(String, usize)> { let text = export(s, None); let steps = text.lines().count().saturating_sub(1); if let Some(path) = path { s.services.write_file(path, text.as_bytes()).map_err(|e| EngineError::Other(format!("cannot write {path}: {e}")))?; return Ok((path.to_string(), steps)); } let store = s.config.clone().ok_or_else(|| EngineError::Other("there is no settings folder to save the repro in; pass `path`".into()))?; let name = repro_name("repro", "session"); store.write(&name, &text).map_err(|e| EngineError::Other(format!("cannot save {name}: {e}")))?; Ok((store_path(store.as_ref(), &name), steps)) } // ---------- export ---------- /// Serialize one command without including an empty parameter object. fn command_line(id: &str, params: &Value) -> String { let mut o = Map::new(); o.insert("command".into(), json!(id)); if !(params.is_null() || params.as_object().is_some_and(Map::is_empty)) { o.insert("params".into(), params.clone()); } Value::Object(o).to_string() } /// Saving writes the user's files and doesn't change the project: left out of repros. fn skipped_in_export(id: &str) -> bool { id.starts_with("file.save") || id.starts_with("file.increment") } /// The journal as a replay script: a start line, then the steps since the project was last /// replaced (`file.newProject` / `file.open` / `file.openDemoProject`; successful Revert records a resolved `file.open`). `crash` (the failing /// command and its error) marks a crash repro, which tolerates errors on replay. pub fn export(s: &Session, crash: Option) -> String { let from = s.journal.iter().rposition(|(id, _)| PROJECT_STARTS.contains(&id.as_str())).unwrap_or(0); let mut lines: Vec = s.journal.get(from..).unwrap_or_default().iter().filter(|(id, _)| !skipped_in_export(id)).map(|(id, p)| command_line(id, p)).collect(); let mut size: usize = lines.iter().map(|l| l.len().saturating_add(1)).sum(); let mut dropped = 0usize; while size > MAX_EXPORT_BYTES && !lines.is_empty() { size = size.saturating_sub(lines.remove(0).len().saturating_add(1)); dropped += 1; } let mut head = Map::new(); head.insert("start".into(), json!("new")); head.insert("version".into(), json!(VERSION)); head.insert("app".into(), json!(format!("EffectCraft {}", env!("CARGO_PKG_VERSION")))); head.insert("os".into(), json!(std::env::consts::OS)); head.insert("exported".into(), json!(unix_secs())); if let Some(c) = crash { head.insert("allow_errors".into(), json!(true)); head.insert("crash".into(), c); } if dropped > 0 { head.insert("dropped".into(), json!(dropped)); } head.insert("note".into(), json!("commands and parameters only (no file contents); parameters can include file paths and text")); let mut out = Value::Object(head).to_string(); out.push('\n'); for l in lines { out.push_str(&l); out.push('\n'); } out } // ---------- parsing ---------- #[derive(Clone, Debug, PartialEq)] enum Start { New, Demo, Project(String), } #[derive(Clone, Debug)] enum Step { Start(Start), Command { id: String, params: Value, expect_error: Option>, }, Expect { query: String, params: Value, pointer: Option, equals: Option, }, ExpectNoError, /// A line that isn't a valid step (reported as a failure). Invalid(String), } fn params_of(v: Option<&Value>) -> std::result::Result { match v { None | Some(Value::Null) => Ok(json!({})), Some(p @ Value::Object(_)) => Ok(p.clone()), Some(_) => Err("`params` must be an object".into()), } } /// Decode the supported initial project states. fn parse_start(v: &Value) -> std::result::Result { match v { Value::String(s) if s == "new" => Ok(Start::New), Value::String(s) if s == "demo" => Ok(Start::Demo), Value::Object(o) => match o.get("project").and_then(Value::as_str) { Some(p) if !p.trim().is_empty() => Ok(Start::Project(p.to_string())), _ => Err("`start` object needs a `project` path".into()), }, _ => Err("`start` must be \"new\", \"demo\" or {\"project\": path}".into()), } } /// One line → a step (`None`: a blank or comment line). fn parse_line(text: &str, first: bool, allow_errors: &mut bool) -> Option { let t = text.trim(); if t.is_empty() || t.starts_with("//") || t.starts_with('#') { return None; } let v: Value = match serde_json::from_str(t) { Ok(v) => v, Err(e) => return Some(Step::Invalid(format!("not JSON: {e}"))), }; let Some(o) = v.as_object() else { return Some(Step::Invalid("a line must be a JSON object".into())) }; let step = if let Some(st) = o.get("start") { if !first { return Some(Step::Invalid("the `start` line must come first".into())); } *allow_errors = o.get("allow_errors").and_then(Value::as_bool).unwrap_or(false); parse_start(st).map(Step::Start) } else if let Some(c) = o.get("command") { parse_command(c, o) } else if let Some(e) = o.get("expect") { parse_expect(e) } else if o.get("expect_no_error").and_then(Value::as_bool) == Some(true) { Ok(Step::ExpectNoError) } else if o.len() == 1 && o.contains_key("comment") { return None; } else { Err("expected a `start`, `command`, `expect` or `expect_no_error` line".to_string()) }; Some(step.unwrap_or_else(Step::Invalid)) } /// Parse one command and its optional expected error without executing it. fn parse_command(c: &Value, o: &Map) -> std::result::Result { let id = c.as_str().filter(|s| !s.is_empty()).ok_or("`command` must be a command id")?; let expect_error = match o.get("expect_error") { None | Some(Value::Null | Value::Bool(false)) => None, Some(Value::Bool(true)) => Some(None), Some(Value::String(s)) => Some(Some(s.clone())), Some(_) => return Err("`expect_error` must be true or a text the error contains".into()), }; Ok(Step::Command { id: id.to_string(), params: params_of(o.get("params"))?, expect_error }) } /// Parse a query assertion, retaining the distinction between no expected value and JSON null. fn parse_expect(e: &Value) -> std::result::Result { let query = e.get("query").and_then(Value::as_str).filter(|s| !s.is_empty()).ok_or("`expect` needs a `query` command id")?; let pointer = e.get("pointer").map(|p| p.as_str().map(str::to_string).ok_or("`pointer` must be a JSON pointer such as /value")).transpose()?; Ok(Step::Expect { query: query.to_string(), params: params_of(e.get("params"))?, pointer, equals: e.get("equals").cloned() }) } // ---------- running ---------- /// How to run a script. #[derive(Clone, Debug, Default)] pub struct Options { /// Keep running after a failed step (default: stop at the first failure). pub keep_going: bool, /// Folder relative `start.project` paths are resolved against (the script's). pub base_dir: Option, } /// What happened to one line. #[derive(Clone, Debug, Serialize)] pub struct StepReport { /// 1-based line number (0: the implicit start). pub line: usize, /// `start`, `command`, `expect`, `expect_no_error` or `invalid`. pub kind: &'static str, #[serde(skip_serializing_if = "Option::is_none")] pub command: Option, pub ok: bool, #[serde(skip_serializing_if = "Option::is_none")] pub error: Option, #[serde(skip_serializing_if = "std::ops::Not::not")] pub panicked: bool, } /// The outcome of [`run`]. #[derive(Clone, Debug, Default, Serialize)] pub struct Report { pub ok: bool, /// A step panicked (caught by the last-resort guard): always a failure. pub panicked: bool, pub steps: Vec, #[serde(skip_serializing_if = "Option::is_none")] pub first_failure: Option, /// Steps not run after the first failure. pub skipped: usize, } /// Cut a message to [`MAX_TEXT`] characters. fn cut(s: &str) -> String { match s.char_indices().nth(MAX_TEXT) { Some((i, _)) => format!("{}…", s.get(..i).unwrap_or(s)), None => s.to_string(), } } /// Run one command the way the app does, noting whether it panicked. fn exec(s: &mut Session, id: &str, params: Value) -> (Result, bool) { let before = guard::caught(); let r = guard::guarded(&format!("replay of `{id}`"), || s.execute(id, params)); s.events.clear(); (r, guard::caught() != before) } /// Numbers within 1e-6 (relative above 1), everything else exactly. fn approx_eq(a: &Value, b: &Value) -> bool { match (a, b) { (Value::Number(x), Value::Number(y)) => match (x.as_f64(), y.as_f64()) { (Some(x), Some(y)) => (x - y).abs() <= 1e-6 * x.abs().max(y.abs()).max(1.0), _ => x == y, }, (Value::Array(x), Value::Array(y)) => x.len() == y.len() && x.iter().zip(y).all(|(a, b)| approx_eq(a, b)), (Value::Object(x), Value::Object(y)) => x.len() == y.len() && x.iter().all(|(k, a)| y.get(k).is_some_and(|b| approx_eq(a, b))), _ => a == b, } } /// Marks this thread as replaying while alive. struct Replaying(bool); impl Replaying { /// Suppress automatic crash exports for the duration of a replay. fn enter() -> Replaying { Replaying(REPLAYING.with(|r| r.replace(true))) } } impl Drop for Replaying { fn drop(&mut self) { REPLAYING.with(|r| r.set(self.0)); } } /// Create or open the initial project and retain whether its command panicked. fn start_step(s: &mut Session, start: &Start, base: Option<&Path>) -> (String, Result, bool) { match start { Start::New => { let (r, p) = exec(s, "file.newProject", json!({})); ("file.newProject".into(), r, p) } Start::Demo => { let (r, p) = exec(s, "file.openDemoProject", json!({})); ("file.openDemoProject".into(), r, p) } Start::Project(path) => { let full = match base { Some(b) if Path::new(path).is_relative() => b.join(path).display().to_string(), _ => path.clone(), }; let (r, p) = exec(s, "file.open", json!({"path": full})); ("file.open".into(), r, p) } } } /// Compare a query result and produce a bounded explanation when it fails. fn expectation_error(r: Result, panicked: bool, pointer: Option<&str>, equals: Option<&Value>) -> Option { let value = match r { Ok(v) => v, Err(e) => return Some(cut(&format!("{}{e}", if panicked { "panicked: " } else { "" }))), }; let got = match pointer { Some(p) => value.pointer(p), None => Some(&value), }; match (got, equals) { (None, _) => Some(cut(&format!("no value at {} in {value}", pointer.unwrap_or("")))), (Some(got), Some(want)) if !approx_eq(got, want) => Some(cut(&format!("expected {want}, got {got}"))), _ => None, } } /// Execute one parsed line and remember whether the last command failed for `expect_no_error`. fn run_step(s: &mut Session, line: usize, step: Step, opts: &Options, allow_errors: bool, last_command_failed: &mut Option) -> StepReport { let mut sr = StepReport { line, kind: "command", command: None, ok: true, error: None, panicked: false }; match step { Step::Invalid(m) => { sr.kind = "invalid"; sr.ok = false; sr.error = Some(m); } Step::Start(start) => { sr.kind = "start"; let (id, r, panicked) = start_step(s, &start, opts.base_dir.as_deref()); sr.command = Some(id); sr.panicked = panicked; sr.ok = !panicked; if let Err(e) = r { sr.ok = false; sr.error = Some(cut(&e.to_string())); } } Step::Command { id, params, expect_error } => { let (r, panicked) = exec(s, &id, params); sr.command = Some(id); sr.panicked = panicked; *last_command_failed = Some(r.is_err()); let err = r.err().map(|e| e.to_string()); let (ok, error) = match (err, expect_error) { (e, _) if panicked => (false, Some(format!("panicked: {}", e.unwrap_or_else(|| "a step failed with an internal error".into())))), (None, None) => (true, None), (None, Some(_)) => (false, Some("expected an error, but the command succeeded".into())), (Some(e), Some(Some(want))) if !e.contains(want.as_str()) => (false, Some(format!("expected an error containing {want:?}, got: {e}"))), (Some(_), Some(_)) => (true, None), (Some(e), None) => (allow_errors, Some(e)), }; sr.ok = ok; sr.error = error.as_deref().map(cut); } Step::Expect { query, params, pointer, equals } => { sr.kind = "expect"; let (r, panicked) = exec(s, &query, params); sr.command = Some(query); sr.panicked = panicked; sr.error = expectation_error(r, panicked, pointer.as_deref(), equals.as_ref()); sr.ok = sr.error.is_none() && !panicked; } Step::ExpectNoError => { sr.kind = "expect_no_error"; match last_command_failed { Some(false) => {} Some(true) => { sr.ok = false; sr.error = Some("the previous command failed".into()); } None => { sr.ok = false; sr.error = Some("no command before this line".into()); } } } } sr } /// Run a replay script against `s`. Never panics: malformed lines are failed steps. pub fn run(s: &mut Session, script: &str, opts: &Options) -> Report { let _replaying = Replaying::enter(); let mut report = Report { ok: true, ..Default::default() }; let fail = |report: &mut Report, sr: StepReport| { report.ok = false; report.panicked |= sr.panicked; if report.first_failure.is_none() { report.first_failure = Some(sr.clone()); } report.steps.push(sr); }; if script.len() > MAX_SCRIPT_BYTES { let msg = format!("the script is larger than {} MB", MAX_SCRIPT_BYTES >> 20); fail(&mut report, StepReport { line: 0, kind: "invalid", command: None, ok: false, error: Some(msg), panicked: false }); return report; } // Hand-edited UTF-8 scripts may start with a BOM, especially on Windows. let script = script.strip_prefix('\u{feff}').unwrap_or(script); let mut allow_errors = false; let mut steps: Vec<(usize, Step)> = vec![]; for (i, line) in script.lines().enumerate().take(MAX_LINES) { if let Some(step) = parse_line(line, steps.is_empty(), &mut allow_errors) { steps.push((i + 1, step)); } } if script.lines().nth(MAX_LINES).is_some() { steps.push((MAX_LINES + 1, Step::Invalid(format!("the script has more than {MAX_LINES} lines; the rest was not read")))); } if !matches!(steps.first(), Some((_, Step::Start(_)) | (_, Step::Invalid(_)))) { steps.insert(0, (0, Step::Start(Start::New))); } let mut last_command_failed: Option = None; let mut stopped = false; for (line, step) in steps { if stopped { report.skipped += 1; continue; } let sr = run_step(s, line, step, opts, allow_errors, &mut last_command_failed); if sr.ok { report.steps.push(sr); } else { fail(&mut report, sr); stopped = !opts.keep_going; } } report } #[cfg(test)] mod tests { use std::sync::Arc; use serde_json::json; use super::{Options, run}; use crate::Session; use crate::config::{ConfigStore, MemoryConfig}; fn replay(script: &str) -> super::Report { run(&mut Session::new(), script, &Options::default()) } #[test] fn steps_expectations_and_failures_are_reported() { let r = replay( r#"{"start": "new"} // a comment {"command": "comp.new", "params": {"name": "A", "width": 320, "height": 180, "frameRate": 30, "duration": 2}} {"expect_no_error": true} {"command": "comp.new", "params": {"frameRate": 0}, "expect_error": "frame"} {"expect": {"query": "comp.info", "pointer": "/width", "equals": 320}} "#, ); assert!(r.ok, "{r:?}"); assert_eq!(r.steps.len(), 5); let r = replay( "{\"command\": \"comp.new\"}\n{\"expect\": {\"query\": \"comp.info\", \"pointer\": \"/width\", \"equals\": 1}}\n{\"command\": \"comp.new\"}", ); assert!(!r.ok && !r.panicked && r.skipped == 1, "{r:?}"); assert_eq!(r.first_failure.as_ref().map(|f| f.line), Some(2)); // An unexpected success, an unknown command. assert!(!replay(r#"{"command": "comp.new", "expect_error": true}"#).ok); assert!(!replay(r#"{"command": "no.such.command"}"#).ok); // Tolerated errors. let r = replay("{\"start\": \"new\", \"allow_errors\": true}\n{\"command\": \"no.such.command\"}\n{\"expect_no_error\": true}"); assert!(!r.ok && r.first_failure.as_ref().map(|f| f.kind) == Some("expect_no_error"), "{r:?}"); } /// A UTF-8 BOM belongs to the text file, not the first JSON step. #[test] fn utf8_bom_preserves_explicit_and_implicit_start_lines() { for body in ["{\"start\":\"new\"}\n{\"command\":\"comp.new\"}", "{\"command\":\"comp.new\"}"] { let script = format!("\u{feff}{body}"); let report = replay(&script); assert!(report.ok, "{report:?}"); assert_eq!(report.steps.last().unwrap().line, body.lines().count()); } } #[test] fn malformed_lines_are_failures_not_crashes() { for bad in [ "not json", "[1, 2]", "{\"command\": 5}", "{\"command\": \"comp.new\", \"params\": [1]}", "{\"command\": \"comp.new\", \"expect_error\": 3}", "{\"expect\": {}}", "{\"expect\": {\"query\": \"comp.info\", \"pointer\": 4}}", "{\"expect\": {\"query\": \"comp.info\", \"pointer\": \"/nope\"}}", "{\"start\": 7}", "{\"start\": {\"project\": \"\"}}", "{\"command\": \"comp.new\"}\n{\"start\": \"new\"}", "{\"what\": 1}", "{\"expect_no_error\": true}", "{\"start\": {\"project\": \"/no/such/file.ecproj\"}}", ] { let r = replay(bad); assert!(!r.ok && !r.panicked, "{bad}: {r:?}"); } let r = replay(&format!("{{\"command\": \"{}\"}}", "\u{1F600}".repeat(1000))); assert!(!r.ok && r.first_failure.and_then(|f| f.error).is_some_and(|e| e.ends_with('…'))); assert!(replay("").ok, "an empty script is a new project"); } #[test] fn the_journal_exports_and_replays() { let mut s = Session::new(); s.execute("comp.new", json!({"name": "Old"})).unwrap(); s.execute("file.openDemoProject", json!({})).unwrap(); s.execute("layer.newSolid", json!({"color": "#ff0000", "name": "Red"})).unwrap(); s.execute("layer.newSolid", json!({"color": "#00ff00", "name": "Green"})).unwrap(); // A query isn't journaled; neither is saving. s.execute("comp.info", json!({})).unwrap(); let text = super::export(&s, None); let lines: Vec<&str> = text.lines().collect(); assert_eq!(lines.len(), 4, "{text}"); assert!(lines[0].contains("\"start\":\"new\"") && lines[1].contains("file.openDemoProject"), "starts at the last project open: {text}"); let mut again = Session::new(); let r = run(&mut again, &text, &Options::default()); assert!(r.ok, "{r:?}"); let layers = |s: &Session| s.active_comp().map(|c| c.layers.len()); assert_eq!(layers(&again), layers(&s)); // journal.export returns it; with `path` it writes the file. let v = s.execute("journal.export", json!({})).unwrap(); assert_eq!(v["steps"], 3); assert_eq!(v["script"].as_str().unwrap().lines().skip(1).collect::>(), lines[1..]); let dir = std::env::temp_dir().join(format!("ec-replay-{}", std::process::id())); std::fs::create_dir_all(&dir).unwrap(); let path = dir.join("j.jsonl"); s.execute("journal.export", json!({"path": path.to_str().unwrap()})).unwrap(); assert!(std::fs::read_to_string(&path).unwrap().contains("layer.newSolid")); let _ = std::fs::remove_dir_all(&dir); assert_eq!(s.journal.iter().filter(|(id, _)| id.starts_with("journal.")).count(), 0); } #[test] fn help_export_repro_saves_into_the_settings_store() { let mut s = Session::new(); assert!(s.execute("help.exportRepro", json!({})).is_err(), "no settings folder and no path"); let store = Arc::new(MemoryConfig::default()); s.config = Some(store.clone()); s.execute("comp.new", json!({})).unwrap(); let v = s.execute("help.exportRepro", json!({})).unwrap(); assert_eq!(v["steps"], 1); let saved = store.list(super::REPRO_DIR); assert_eq!(saved.len(), 1, "{saved:?}"); assert!(store.read(v["path"].as_str().unwrap()).unwrap().contains("comp.new")); } #[test] fn a_panicking_command_saves_a_crash_repro_and_replays_as_a_failure() { let mut s = Session::new(); let store = Arc::new(MemoryConfig::default()); s.config = Some(store.clone()); s.execute("comp.new", json!({"name": "C"})).unwrap(); // `test.panic` stands in for a command with a bug (see `commands::journal`). let e = s.execute("test.panic", json!({"why": "boom"})).unwrap_err().to_string(); assert!(e.contains("boom") && e.contains("Repros/crash-"), "{e}"); let names = store.list(super::REPRO_DIR); assert_eq!(names.len(), 1); let text = store.read(&format!("{}/{}", super::REPRO_DIR, names[0])).unwrap(); assert!(text.lines().next().unwrap().contains("\"crash\""), "{text}"); assert!(text.lines().last().unwrap().contains("test.panic"), "{text}"); // The replay fails on the panic (and doesn't save another repro). let r = run(&mut Session::new(), &text, &Options::default()); assert!(!r.ok && r.panicked, "{r:?}"); assert_eq!(r.first_failure.as_ref().and_then(|f| f.command.as_deref()), Some("test.panic")); // A failing replay inside a session with a store saves nothing more. let mut t = Session::new(); t.config = Some(store.clone()); assert!(!run(&mut t, &text, &Options::default()).ok); assert_eq!(store.list(super::REPRO_DIR).len(), 1); // Only the newest crash repros are kept. for i in 0..30 { store.write(&format!("{}/crash-{i:012}-x.jsonl", super::REPRO_DIR), "{}").unwrap(); } let _ = s.execute("test.panic", json!({})); assert_eq!(store.list(super::REPRO_DIR).len(), super::KEEP_CRASH_REPROS); } #[test] fn commands_run_by_a_journaled_command_are_not_journaled_twice() { let mut s = Session::new(); s.execute("comp.new", json!({})).unwrap(); // engine.batch isn't journaled: its steps are. s.execute("engine.batch", json!({"steps": [{"command": "layer.newNull"}, {"command": "layer.newNull"}]})).unwrap(); assert_eq!(s.journal.iter().filter(|(id, _)| id == "layer.newNull").count(), 2); // A journaled command's own steps replay with it. s.execute("file.runScript", json!({"steps": [{"command": "layer.newNull"}]})).unwrap(); let ids: Vec<&str> = s.journal.iter().map(|(id, _)| id.as_str()).collect(); assert_eq!(ids, ["comp.new", "layer.newNull", "layer.newNull", "file.runScript"]); } } #[cfg(all(test, not(target_arch = "wasm32")))] mod revert_tests { use super::{Options, export, run}; use crate::Session; use serde_json::json; /// Saving is omitted, so a successful Revert must keep the file it read as an open boundary. #[test] fn save_as_then_revert_exports_a_replayable_open() { let dir = tempfile::tempdir().unwrap(); let path = dir.path().join("saved.ecproj"); let mut s = Session::new(); s.execute("comp.new", json!({"name": "Saved"})).unwrap(); s.execute("file.saveAs", json!({"path": path})).unwrap(); s.execute("layer.newNull", json!({})).unwrap(); s.execute("file.revert", json!({})).unwrap(); s.execute("layer.newNull", json!({"name": "After Revert"})).unwrap(); let script = export(&s, None); assert!(!script.contains("file.save") && !script.contains("file.revert"), "{script}"); assert!(script.lines().nth(1).unwrap().contains("file.open"), "{script}"); let saved = std::fs::read(&path).unwrap(); let mut again = Session::new(); let report = run(&mut again, &script, &Options::default()); assert!(report.ok, "{report:?}"); assert_eq!(again.path, s.path); assert_eq!(again.active_comp().unwrap().layers.len(), s.active_comp().unwrap().layers.len()); assert_eq!(saved, std::fs::read(path).unwrap(), "replay must not rewrite the saved project"); } }