856f865cf98d
psd_write_oracle.rs
//! Execute small PSD export recipes with the headless CLI. Photoshop is a separate judge.
use std::collections::HashSet;
use std::fs::{self, File, OpenOptions};
use std::path::{Component, Path, PathBuf};
use std::process::{Command, Stdio};
use std::time::{Duration, Instant};
use serde::{Deserialize, Serialize};
use serde_json::{Value, json};
const MAX_FILE: u64 = 64 * 1024 * 1024;
const MAX_RECIPES: usize = 1000;
const TIMEOUT: Duration = Duration::from_secs(120);
#[derive(Deserialize, Serialize)]
#[serde(deny_unknown_fields)]
struct Recipes {
version: u32,
corpus_revision: String,
cases: Vec<Recipe>,
}
#[derive(Deserialize, Serialize)]
#[serde(deny_unknown_fields)]
struct Recipe {
id: String,
base: String,
base_sha256: String,
target: Target,
#[serde(default)]
commands: Vec<Step>,
checks: Vec<Check>,
}
#[derive(Deserialize, Serialize)]
#[serde(deny_unknown_fields)]
struct Target {
kind: String,
#[serde(default)]
name: Option<String>,
}
#[derive(Deserialize, Serialize)]
#[serde(deny_unknown_fields)]
struct Step {
command: String,
#[serde(default = "empty_object")]
params: Value,
}
/// Fallback serde default producing an empty JSON object.
fn empty_object() -> Value {
json!({})
}
#[derive(Deserialize, Serialize)]
#[serde(tag = "op", deny_unknown_fields)]
enum Check {
#[serde(rename = "changed_to")]
ChangedTo { path: String, value: Value },
#[serde(rename = "unchanged")]
Unchanged { path: String },
#[serde(rename = "equals")]
Equals { path: String, value: Value },
}
/// Reject nonregular files and files whose metadata exceeds the caller’s byte limit.
fn read_limited_to(path: &Path, max: u64) -> Result<Vec<u8>, String> {
let meta = fs::metadata(path).map_err(|e| format!("{}: {e}", path.display()))?;
if !meta.is_file() || meta.len() > max {
return Err(format!("{} is not a regular file of at most {max} bytes", path.display()));
}
fs::read(path).map_err(|e| format!("{}: {e}", path.display()))
}
/// Read one recipe artifact within the runner’s file-size limit.
fn read_limited(path: &Path) -> Result<Vec<u8>, String> {
read_limited_to(path, MAX_FILE)
}
/// Accept a case identifier that can safely name one output subdirectory.
fn valid_id(id: &str) -> bool {
!id.is_empty() && id.len() <= 100 && id.bytes().all(|b| b.is_ascii_alphanumeric() || b == b'-' || b == b'_')
}
/// Reject unsupported recipes, unsafe paths, duplicate IDs, and incomplete checks.
fn validate(recipes: &Recipes) -> Result<(), String> {
if recipes.version != 1 || recipes.corpus_revision.is_empty() || recipes.cases.is_empty() || recipes.cases.len() > MAX_RECIPES {
return Err("expected version 1, a corpus revision and 1..=1000 cases".into());
}
let mut seen = HashSet::new();
for case in &recipes.cases {
// An id names the case's output directory, and `A` and `a` are one directory on a case-insensitive filesystem.
if !valid_id(&case.id) || !seen.insert(case.id.to_ascii_lowercase()) {
return Err(format!("invalid or duplicate case id: {}", case.id));
}
let path = Path::new(&case.base);
if path.components().any(|c| !matches!(c, Component::Normal(_))) || path.extension().is_none_or(|e| e != "psd") {
return Err(format!("{}: base must be a relative PSD path", case.id));
}
if case.base_sha256.len() != 64 || !case.base_sha256.bytes().all(|b| b.is_ascii_hexdigit() && !b.is_ascii_uppercase()) {
return Err(format!("{}: invalid SHA-256", case.id));
}
if case.target.kind.is_empty() || case.checks.is_empty() || case.commands.len() > 50 {
return Err(format!("{}: target, checks and at most 50 commands are required", case.id));
}
if !case.commands.is_empty() && !case.checks.iter().any(|c| matches!(c, Check::ChangedTo { .. })) {
return Err(format!("{}: an edit needs a changed_to assertion", case.id));
}
for step in &case.commands {
// The contour library commands edit no document, and their `path` param reaches any file.
if !(step.command.starts_with("type.") || step.command.starts_with("layer.layerStyle."))
|| step.command.starts_with("layer.layerStyle.contours.")
|| !step.params.is_object()
|| step.params.get("layer").is_some()
|| step.params.get("layers").is_some()
{
return Err(format!("{}: invalid command or explicit layer in params", case.id));
}
}
for check in &case.checks {
let path = match check {
Check::ChangedTo { path, .. } | Check::Unchanged { path } | Check::Equals { path, .. } => path,
};
if !path.starts_with('/') || path.len() > 512 {
return Err(format!("{}: check path must be a JSON pointer", case.id));
}
}
}
Ok(())
}
/// Resolve a corpus input and reject paths escaping the canonical corpus root.
fn input_path(root: &Path, relative: &str) -> Result<PathBuf, String> {
let p = root.join(relative).canonicalize().map_err(|e| format!("{relative}: {e}"))?;
if !p.starts_with(root) {
return Err(format!("{relative}: path escapes corpus directory"));
}
Ok(p)
}
/// Find exactly one layer matching the recipe’s kind and optional name.
fn target<'a>(doc: &'a Value, wanted: &Target) -> Result<&'a Value, String> {
let mut stack = vec![(doc.get("layers").and_then(Value::as_array).ok_or("missing layers")?, 0usize)];
let mut found = Vec::new();
while let Some((layers, depth)) = stack.pop() {
if depth > 128 {
return Err("layer nesting exceeds 128".into());
}
for layer in layers {
if layer.get("kind").and_then(Value::as_str) == Some(wanted.kind.as_str())
&& wanted.name.as_ref().is_none_or(|name| layer.get("name").and_then(Value::as_str) == Some(name.as_str()))
{
found.push(layer);
}
if let Some(children) = layer.get("children").and_then(Value::as_array) {
stack.push((children, depth + 1));
}
}
}
if found.len() != 1 {
return Err(format!("target matched {} layers, expected exactly one", found.len()));
}
found.into_iter().next().ok_or_else(|| "missing target".into())
}
/// Compare two JSON numbers by exact value, with no tolerance: `17` equals `17.0`, and integers too
/// large for `f64` stay distinct.
fn numbers_equal(a: &serde_json::Number, b: &serde_json::Number) -> bool {
let int = |n: &serde_json::Number| n.as_i64().map(i128::from).or_else(|| n.as_u64().map(i128::from));
let whole_float_is = |float: &serde_json::Number, i: i128| float.as_f64().is_some_and(|f| f.fract() == 0.0 && f as i128 == i);
match (int(a), int(b)) {
(Some(x), Some(y)) => x == y,
(Some(i), None) => whole_float_is(b, i),
(None, Some(i)) => whole_float_is(a, i),
(None, None) => a.as_f64() == b.as_f64(),
}
}
/// Compare JSON by value: numbers as in `numbers_equal`; arrays and objects element-wise. Recursion is
/// bounded because serde_json's parser already limits nesting depth.
fn values_equal(a: &Value, b: &Value) -> bool {
match (a, b) {
(Value::Number(x), Value::Number(y)) => numbers_equal(x, y),
(Value::Array(x), Value::Array(y)) => x.len() == y.len() && x.iter().zip(y).all(|(x, y)| values_equal(x, y)),
(Value::Object(x), Value::Object(y)) => x.len() == y.len() && x.iter().all(|(k, v)| y.get(k).is_some_and(|w| values_equal(v, w))),
_ => a == b,
}
}
/// `values_equal` over optional values: both absent are equal, one absent is not.
fn options_equal(a: Option<&Value>, b: Option<&Value>) -> bool {
match (a, b) {
(None, None) => true,
(Some(a), Some(b)) => values_equal(a, b),
_ => false,
}
}
fn verify(checks: &[Check], before: &Value, after: &Value) -> Vec<Value> {
let mut results = Vec::new();
let layer = after.get("name").or_else(|| before.get("name"));
for check in checks {
let (path, op, expected) = match check {
Check::ChangedTo { path, value } => (path, "changed_to", Some(value)),
Check::Equals { path, value } => (path, "equals", Some(value)),
Check::Unchanged { path } => (path, "unchanged", None),
};
let old = before.pointer(path);
let new = after.pointer(path);
let pass = match check {
Check::ChangedTo { value, .. } => new.is_some_and(|n| values_equal(n, value)) && !options_equal(old, new),
Check::Equals { value, .. } => new.is_some_and(|n| values_equal(n, value)),
Check::Unchanged { .. } => old.is_some() && options_equal(old, new),
};
results.push(
json!({"layer": layer, "path": path, "op": op, "expected": expected, "before": old, "after": new, "status": if pass { "pass" } else { "fail" }}),
);
}
results
}
/// Capture into files to avoid pipe deadlocks. Terminate a stuck CLI instead of blocking a batch.
fn invoke(cli: &Path, args: &[String], dir: &Path, tag: &str) -> Result<(String, String), String> {
let stdout = dir.join(format!("{tag}.stdout"));
let stderr = dir.join(format!("{tag}.stderr"));
let out = File::create(&stdout).map_err(|e| e.to_string())?;
let err = File::create(&stderr).map_err(|e| e.to_string())?;
let mut child = Command::new(cli).args(args).stdin(Stdio::null()).stdout(out).stderr(err).spawn().map_err(|e| format!("start CLI: {e}"))?;
let start = Instant::now();
let status = loop {
match child.try_wait() {
Ok(Some(status)) => break status,
Ok(None) if start.elapsed() < TIMEOUT => std::thread::sleep(Duration::from_millis(50)),
Ok(None) => {
let _ = child.kill();
let _ = child.wait();
return Err(format!("CLI timed out after {}s", TIMEOUT.as_secs()));
}
Err(e) => {
let _ = child.kill();
let _ = child.wait();
return Err(format!("wait for CLI: {e}"));
}
}
};
let out = String::from_utf8(read_limited(&stdout)?).map_err(|e| e.to_string())?;
let err = String::from_utf8(read_limited(&stderr)?).map_err(|e| e.to_string())?;
if !status.success() {
return Err(format!("CLI {tag} failed ({status}): {err}"));
}
Ok((out, err))
}
/// Request detailed CLI inspection and parse the returned document JSON.
fn inspect(cli: &Path, file: &Path, dir: &Path, tag: &str) -> Result<Value, String> {
let path = file.to_str().ok_or("non-UTF-8 path")?;
let (out, _) = invoke(cli, &["info".into(), path.into(), "--compact".into(), "--detail".into()], dir, tag)?;
serde_json::from_str(&out).map_err(|e| format!("invalid CLI inspection: {e}"))
}
/// Reference-editor verdicts, which this runner never produces itself.
fn not_run() -> Value {
json!({"opens": "not_run", "meaning": "not_run", "rendering": "not_run"})
}
/// Reopen the exported candidate and check it against the recipe.
fn check_candidate(
case: &Recipe,
cli: &Path,
dir: &Path,
candidate_sha256: &str,
before: &Value,
layer: &Value,
export_warnings: &str,
) -> Result<Value, String> {
let candidate = dir.join("candidate.psd");
let after = inspect(cli, &candidate, dir, "after")?;
let checks = verify(&case.checks, layer, target(&after, &case.target)?);
let passed = checks.iter().all(|v| v.get("status").and_then(Value::as_str) == Some("pass"));
Ok(json!({"id": case.id, "status": if passed { "pass" } else { "fail" }, "base": case.base, "base_sha256": case.base_sha256,
"candidate": format!("{}/candidate.psd", case.id), "candidate_sha256": candidate_sha256, "checks": checks,
"warnings": {"input": before.get("warnings"), "export": export_warnings, "output": after.get("warnings")},
"photoshop": not_run()}))
}
/// Export and check one case, retaining candidate provenance after export succeeds.
fn execute(case: &Recipe, corpus: &Path, cli: &Path, output: &Path) -> Result<Value, String> {
use std::io::Write;
let input = input_path(corpus, &case.base)?;
let input_bytes = read_limited(&input)?;
if crate::sha256::hex(&input_bytes) != case.base_sha256 {
return Err("base SHA-256 mismatch".into());
}
let dir = output.join(&case.id);
fs::create_dir(&dir).map_err(|e| e.to_string())?;
// Run on a private copy of the hashed bytes so the CLI never opens the corpus.
let pinned = dir.join("base.psd");
let mut f = OpenOptions::new().write(true).create_new(true).open(&pinned).map_err(|e| e.to_string())?;
f.write_all(&input_bytes).map_err(|e| e.to_string())?;
drop(f);
let before = inspect(cli, &pinned, &dir, "before")?;
let layer = target(&before, &case.target)?;
let layer_id = layer.get("id").and_then(Value::as_u64).ok_or("target lacks numeric id")?;
let candidate = dir.join("candidate.psd");
let mut args = vec!["run".to_string(), pinned.to_str().ok_or("non-UTF-8 input path")?.to_string()];
for step in &case.commands {
let mut params = step.params.clone();
params.as_object_mut().ok_or("params must be an object")?.insert("layer".into(), json!(layer_id));
args.extend(["--cmd".into(), step.command.clone(), "--params".into(), params.to_string()]);
}
args.extend(["--out".into(), candidate.to_str().ok_or("non-UTF-8 output path")?.to_string()]);
let (_, warnings) = invoke(cli, &args, &dir, "export")?;
let bytes = read_limited(&candidate)?;
let candidate_sha256 = crate::sha256::hex(&bytes);
match check_candidate(case, cli, &dir, &candidate_sha256, &before, layer, &warnings) {
Ok(record) => Ok(record),
Err(e) => Ok(json!({"id": case.id, "status": "fail", "base": case.base, "base_sha256": case.base_sha256,
"candidate": format!("{}/candidate.psd", case.id), "candidate_sha256": candidate_sha256,
"error": format!("exported file: {e}"),
"warnings": {"input": before.get("warnings"), "export": warnings},
"photoshop": not_run()})),
}
}
/// Create a report artifact without overwriting an existing file.
fn write_json(path: &Path, value: &Value) -> Result<(), String> {
use std::io::Write;
let mut f = OpenOptions::new().write(true).create_new(true).open(path).map_err(|e| e.to_string())?;
serde_json::to_writer_pretty(&mut f, value).map_err(|e| e.to_string())?;
writeln!(f).map_err(|e| e.to_string())
}
/// Trimmed stdout of `git args` in `root`; `None` outside a checkout or without git.
fn git(root: &Path, args: &[&str]) -> Option<String> {
let out = Command::new("git").current_dir(root).args(args).output().ok()?;
if !out.status.success() {
return None;
}
String::from_utf8(out.stdout).ok().map(|s| s.trim().to_string())
}
/// Execute a batch of recipes against an oracle corpus and write a verification report.
pub fn run(root: &Path, args: &[&str]) -> Result<(), String> {
let [recipe_path, corpus, cli, output] = args else {
return Err("usage: cargo xtask psd-write-oracle <recipes.json> <corpus-dir> <photocraft-cli> <new-output-dir>".into());
};
let recipe_bytes = read_limited(Path::new(recipe_path))?;
let recipes: Recipes = serde_json::from_slice(&recipe_bytes).map_err(|e| format!("invalid recipes: {e}"))?;
validate(&recipes)?;
let corpus = Path::new(corpus).canonicalize().map_err(|e| format!("corpus: {e}"))?;
let cli = Path::new(cli).canonicalize().map_err(|e| format!("CLI: {e}"))?;
let cli_sha = crate::sha256::hex(&read_limited_to(&cli, 2048 * 1024 * 1024)?);
let output = Path::new(output);
fs::create_dir(output).map_err(|e| format!("output directory must be new: {e}"))?;
let revision = git(root, &["rev-parse", "HEAD"]).unwrap_or_else(|| "unknown".into());
let dirty = match git(root, &["status", "--porcelain", "--untracked-files=no"]) {
Some(s) => json!(!s.is_empty()),
None => json!("unknown"),
};
let mut cases = Vec::new();
for case in &recipes.cases {
let result = execute(case, &corpus, &cli, output).unwrap_or_else(|e| {
json!({"id": case.id, "status": "fail", "error": e,
"photoshop": not_run()})
});
cases.push(result);
}
let passed = cases.iter().all(|c| c.get("status").and_then(Value::as_str) == Some("pass"));
let report = json!({"version": 1, "source_revision": revision, "source_dirty": dirty, "corpus_revision": recipes.corpus_revision,
"recipe_sha256": crate::sha256::hex(&recipe_bytes), "cli_sha256": cli_sha, "cases": cases});
write_json(&output.join("report.json"), &report)?;
write_json(
&output.join("manifest.json"),
&json!({"version": 1, "source_revision": revision, "source_dirty": dirty, "corpus_revision": recipes.corpus_revision,
"recipe_sha256": crate::sha256::hex(&recipe_bytes), "cli_sha256": cli_sha,
"candidates": report["cases"].as_array().into_iter().flatten().filter_map(|c| Some(json!({"id": c.get("id")?, "path": c.get("candidate")?, "sha256": c.get("candidate_sha256")?}))).collect::<Vec<_>>() }),
)?;
if passed { Ok(()) } else { Err(format!("one or more recipes failed; see {}/report.json", output.display())) }
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn git_is_optional() {
assert!(git(&std::env::temp_dir().join("psd-write-oracle-no-such-dir"), &["rev-parse", "HEAD"]).is_none());
}
#[test]
fn detects_wrong_or_unchanged_edits_and_missing_fields() {
let before = json!({"text":{"tracking":0,"value":"hello"}});
let after = json!({"text":{"tracking":30,"value":"hello"}});
let checks = [Check::ChangedTo { path: "/text/tracking".into(), value: json!(30) }, Check::Unchanged { path: "/text/value".into() }];
assert!(verify(&checks, &before, &after).iter().all(|c| c["status"] == "pass"));
assert_eq!(verify(&checks, &before, &before)[0]["status"], "fail");
let missing = [Check::Unchanged { path: "/missing".into() }];
assert_eq!(verify(&missing, &before, &after)[0]["status"], "fail");
}
#[test]
fn every_failed_check_is_reported_with_layer_name_and_property() {
let before = json!({"name":"Title","text":{"tracking":0,"value":"a"}});
let after = json!({"name":"Title","text":{"tracking":0,"value":"b"}});
let checks = [
Check::ChangedTo { path: "/text/tracking".into(), value: json!(30) },
Check::Unchanged { path: "/text/value".into() },
Check::Equals { path: "/text/value".into(), value: json!("c") },
];
let results = verify(&checks, &before, &after);
assert_eq!(results.len(), 3);
assert!(results.iter().all(|r| r["status"] == "fail" && r["layer"] == "Title"));
assert_eq!(results[0]["path"], "/text/tracking");
assert_eq!(results[1]["path"], "/text/value");
}
#[test]
fn wrong_layer_count_and_unsupported_version_are_errors() {
let selector = Target { kind: "Text".into(), name: None };
let none = json!({"layers":[{"kind":"Raster"}]});
assert!(target(&none, &selector).unwrap_err().contains("matched 0 layers"));
let two = json!({"layers":[{"kind":"Text"},{"kind":"Text"}]});
assert!(target(&two, &selector).unwrap_err().contains("matched 2 layers"));
let recipe = json!({"version":2,"corpus_revision":"pin","cases":[{"id":"x","base":"x.psd","base_sha256":"a".repeat(64),"target":{"kind":"Type"},"checks":[{"op":"unchanged","path":"/name"}]}]});
assert!(validate(&serde_json::from_value(recipe).unwrap()).unwrap_err().contains("version 1"));
}
#[test]
fn unknown_keys_are_rejected_in_every_object() {
let case = |extra: Value| {
let mut c = json!({"id":"x","base":"x.psd","base_sha256":"a".repeat(64),"target":{"kind":"Type"},"checks":[{"op":"unchanged","path":"/name"}]});
c.as_object_mut().unwrap().extend(extra.as_object().unwrap().clone());
json!({"version":1,"corpus_revision":"pin","cases":[c]})
};
assert!(serde_json::from_value::<Recipes>(case(json!({"target":{"kind":"Type","nmae":"x"}}))).is_err());
assert!(serde_json::from_value::<Recipes>(case(json!({"checks":[{"op":"unchanged","path":"/name","extra":1}]}))).is_err());
assert!(serde_json::from_value::<Recipes>(case(json!({"commands":[{"command":"type.x","parms":{}}]}))).is_err());
let mut top = case(json!({}));
top["extra"] = json!(1);
assert!(serde_json::from_value::<Recipes>(top).is_err());
}
#[test]
fn layer_selection_rejects_ambiguity_and_finds_nested_layers() {
let doc = json!({"layers":[{"kind":"Group","children":[{"kind":"Text","id":7,"name":"A"}]}]});
let selector = Target { kind: "Text".into(), name: None };
assert_eq!(target(&doc, &selector).unwrap()["id"], 7);
let ambiguous = json!({"layers":[{"kind":"Text"},{"kind":"Text"}]});
assert!(target(&ambiguous, &selector).is_err());
}
#[test]
fn schema_rejects_unsafe_paths_duplicate_ids_and_unverified_edits() {
let recipe = json!({"version":1,"corpus_revision":"pin","cases":[{"id":"case","base":"../x.psd","base_sha256":"a".repeat(64),"target":{"kind":"Text"},"checks":[{"op":"unchanged","path":"/name"}]}]});
let parsed: Recipes = serde_json::from_value(recipe).unwrap();
assert!(validate(&parsed).is_err());
let duplicate = json!({"version":1,"corpus_revision":"pin","cases":[{"id":"x","base":"x.psd","base_sha256":"a".repeat(64),"target":{"kind":"Text"},"checks":[{"op":"unchanged","path":"/name"}]},{"id":"x","base":"x.psd","base_sha256":"a".repeat(64),"target":{"kind":"Text"},"checks":[{"op":"unchanged","path":"/name"}]}]});
assert!(validate(&serde_json::from_value(duplicate).unwrap()).is_err());
let case_only = json!({"version":1,"corpus_revision":"pin","cases":[{"id":"A","base":"x.psd","base_sha256":"a".repeat(64),"target":{"kind":"Text"},"checks":[{"op":"unchanged","path":"/name"}]},{"id":"a","base":"x.psd","base_sha256":"a".repeat(64),"target":{"kind":"Text"},"checks":[{"op":"unchanged","path":"/name"}]}]});
assert!(validate(&serde_json::from_value(case_only).unwrap()).unwrap_err().contains("duplicate"));
let contour = |command: &str| {
json!({"version":1,"corpus_revision":"pin","cases":[{"id":"x","base":"x.psd","base_sha256":"a".repeat(64),"target":{"kind":"Text"},
"commands":[{"command":command,"params":{"path":"base.psd"}}],"checks":[{"op":"changed_to","path":"/name","value":"y"}]}]})
};
for command in ["layer.layerStyle.contours.save", "layer.layerStyle.contours.load"] {
assert!(validate(&serde_json::from_value(contour(command)).unwrap()).unwrap_err().contains("invalid command"));
}
assert!(validate(&serde_json::from_value(contour("layer.layerStyle.dropShadow")).unwrap()).is_ok());
let edit = json!({"version":1,"corpus_revision":"pin","cases":[{"id":"x","base":"x.psd","base_sha256":"a".repeat(64),"target":{"kind":"Text"},"commands":[{"command":"type.setStyle"}],"checks":[{"op":"unchanged","path":"/name"}]}]});
assert!(validate(&serde_json::from_value(edit).unwrap()).is_err());
}
#[cfg(unix)]
#[test]
fn export_batch_checks_reopened_result_and_propagates_command_failure() {
use std::os::unix::fs::PermissionsExt;
let tmp = tempfile::Builder::new().prefix("psd-write-oracle-").tempdir().unwrap();
let root = tmp.path().to_path_buf();
let corpus = root.join("corpus");
let output = root.join("output");
fs::create_dir(&corpus).unwrap();
let corpus = corpus.canonicalize().unwrap();
fs::create_dir(&output).unwrap();
fs::write(corpus.join("base.psd"), b"base").unwrap();
let cli = root.join("fake-cli");
fs::write(
&cli,
r##"#!/bin/sh
if [ "$1" = info ]; then
case "$2" in
*/candidate.psd) echo '{"layers":[{"kind":"Type","id":4,"text":{"antialias":"Crisp"}}]}' ;;
*) echo '{"layers":[{"kind":"Type","id":4,"text":{"antialias":"None"}}]}' ;;
esac
exit 0
fi
if [ "$3" = --cmd ] && [ "$4" = type.bad ]; then
echo 'bad command' >&2
exit 1
fi
input="$2"
while [ "$#" -gt 0 ]; do
if [ "$1" = --out ]; then cp "$input" "$2"; exit 0; fi
shift
done
exit 1
"##,
)
.unwrap();
fs::set_permissions(&cli, fs::Permissions::from_mode(0o755)).unwrap();
let make_case = |id: &str, command: &str| Recipe {
id: id.into(),
base: "base.psd".into(),
base_sha256: crate::sha256::hex(b"base"),
target: Target { kind: "Type".into(), name: None },
commands: vec![Step { command: command.into(), params: json!({}) }],
checks: vec![Check::ChangedTo { path: "/text/antialias".into(), value: json!("Crisp") }],
};
let good = execute(&make_case("good", "type.antiAlias.crisp"), &corpus, &cli, &output).unwrap();
assert_eq!(good["status"], "pass");
assert_eq!(good["photoshop"]["opens"], "not_run");
assert!(execute(&make_case("bad", "type.bad"), &corpus, &cli, &output).unwrap_err().contains("bad command"));
}
/// Fake CLI that logs its arguments, tampers with the file it is asked to run on, and reports
/// `candidate_info` for the exported file.
#[cfg(unix)]
fn fake_cli(root: &Path, log: &Path, candidate_info: &str, export_fails: bool) -> PathBuf {
use std::os::unix::fs::PermissionsExt;
let cli = root.join("fake-cli");
let script = r##"#!/bin/sh
echo "$@" >> 'LOG'
if [ "$1" = info ]; then
case "$2" in
*/candidate.psd) echo 'CANDIDATE' ;;
*) echo '{"layers":[{"kind":"Type","id":4,"text":{"antialias":"None"}}]}' ;;
esac
exit 0
fi
if [ EXPORT_FAILS = 1 ]; then
echo 'export broke' >&2
exit 1
fi
input="$2"
cp "$input" "$input.received"
echo tamper >> "$input"
while [ "$#" -gt 0 ]; do
if [ "$1" = --out ]; then cp "$input" "$2"; exit 0; fi
shift
done
exit 1
"##
.replace("LOG", &log.display().to_string())
.replace("CANDIDATE", candidate_info)
.replace("EXPORT_FAILS", if export_fails { "1" } else { "0" });
fs::write(&cli, script).unwrap();
fs::set_permissions(&cli, fs::Permissions::from_mode(0o755)).unwrap();
cli
}
/// Run one recipe case through `run`; returns (temp dir guard, result, output dir, corpus dir, log path).
#[cfg(unix)]
fn run_case(id: &str, candidate_info: &str, export_fails: bool) -> (tempfile::TempDir, Result<(), String>, PathBuf, PathBuf, PathBuf) {
let tmp = tempfile::Builder::new().prefix("psd-write-oracle-").tempdir().unwrap();
let root = tmp.path().canonicalize().unwrap();
let corpus = root.join("corpus");
fs::create_dir(&corpus).unwrap();
fs::write(corpus.join("base.psd"), b"base").unwrap();
let log = root.join("calls.log");
let cli = fake_cli(&root, &log, candidate_info, export_fails);
let recipes = json!({"version":1,"corpus_revision":"pin","cases":[{"id":id,"base":"base.psd","base_sha256":crate::sha256::hex(b"base"),
"target":{"kind":"Type"},"commands":[{"command":"type.antiAlias.crisp","params":{}}],
"checks":[{"op":"changed_to","path":"/text/antialias","value":"Crisp"}]}]});
let recipe_path = root.join("recipes.json");
fs::write(&recipe_path, recipes.to_string()).unwrap();
let out = root.join("out");
let args = [recipe_path.to_str().unwrap(), corpus.to_str().unwrap(), cli.to_str().unwrap(), out.to_str().unwrap()];
let result = run(&root, &args);
(tmp, result, out, corpus, log)
}
#[cfg(unix)]
#[test]
fn target_lost_after_export_keeps_candidate_in_manifest() {
let (_tmp, result, out, _, _) = run_case("lost", r#"{"layers":[]}"#, false);
assert!(result.is_err());
let report: Value = serde_json::from_slice(&fs::read(out.join("report.json")).unwrap()).unwrap();
assert_eq!(report["cases"][0]["status"], "fail");
assert!(report["cases"][0]["error"].as_str().unwrap().starts_with("exported file: "));
let manifest: Value = serde_json::from_slice(&fs::read(out.join("manifest.json")).unwrap()).unwrap();
let entry = &manifest["candidates"][0];
assert_eq!(entry["id"], "lost");
assert_eq!(entry["path"], "lost/candidate.psd");
assert_eq!(entry["sha256"], crate::sha256::hex(&fs::read(out.join("lost/candidate.psd")).unwrap()));
}
#[cfg(unix)]
#[test]
fn export_failure_has_no_manifest_entry() {
let (_tmp, result, out, _, _) = run_case("broken", r#"{"layers":[]}"#, true);
assert!(result.is_err());
let report: Value = serde_json::from_slice(&fs::read(out.join("report.json")).unwrap()).unwrap();
assert_eq!(report["cases"][0]["status"], "fail");
assert!(report["cases"][0]["error"].as_str().unwrap().contains("export broke"));
let manifest: Value = serde_json::from_slice(&fs::read(out.join("manifest.json")).unwrap()).unwrap();
assert!(manifest["candidates"].as_array().unwrap().is_empty());
}
#[cfg(unix)]
#[test]
fn cli_runs_on_pinned_base_never_on_corpus() {
let (_tmp, result, out, corpus, log) = run_case("pin", r#"{"layers":[{"kind":"Type","id":4,"text":{"antialias":"Crisp"}}]}"#, false);
assert!(result.is_ok(), "{result:?}");
assert_eq!(fs::read(corpus.join("base.psd")).unwrap(), b"base");
let pinned = out.join("pin/base.psd");
assert!(pinned.exists());
assert_eq!(fs::read(out.join("pin/base.psd.received")).unwrap(), b"base");
let log = fs::read_to_string(log).unwrap();
let corpus_path = corpus.join("base.psd").display().to_string();
assert!(!log.contains(&corpus_path));
let pinned = pinned.display().to_string();
let base_calls: Vec<&str> = log.lines().filter(|l| !l.starts_with("info ") || !l.contains("candidate.psd")).collect();
assert_eq!(base_calls.len(), 2);
assert!(base_calls.iter().all(|l| l.contains(&pinned)));
}
#[test]
fn numbers_compare_by_value() {
assert!(values_equal(&json!(17), &json!(17.0)));
assert!(!values_equal(&json!(17), &json!(18.0)));
assert!(!values_equal(&json!(17), &json!(17.5)));
assert!(values_equal(&json!(0.5), &json!(0.5)));
assert!(values_equal(&json!(-3), &json!(-3.0)));
assert!(values_equal(&json!(u64::MAX), &json!(u64::MAX)));
assert!(!values_equal(&json!(9_007_199_254_740_993_u64), &json!(9_007_199_254_740_992_u64)));
assert!(!values_equal(&json!(9_007_199_254_740_993_u64), &json!(9_007_199_254_740_992.0)));
assert!(values_equal(&json!(9_007_199_254_740_992_u64), &json!(9_007_199_254_740_992.0)));
assert!(!values_equal(&json!(u64::MAX), &json!(1e300)));
assert!(values_equal(&json!({"a":[1,2.0,{"b":3}],"c":"x"}), &json!({"c":"x","a":[1.0,2,{"b":3.0}]})));
assert!(!values_equal(&json!({"a":1}), &json!({"b":1})));
assert!(!values_equal(&json!({"a":1}), &json!({"a":1,"b":1})));
assert!(!values_equal(&json!([1, 2]), &json!([1])));
let before = json!({"n":17});
let after = json!({"n":17.0});
assert_eq!(verify(&[Check::ChangedTo { path: "/n".into(), value: json!(17) }], &before, &after)[0]["status"], "fail");
assert_eq!(verify(&[Check::Equals { path: "/n".into(), value: json!(17) }], &before, &after)[0]["status"], "pass");
assert_eq!(verify(&[Check::Unchanged { path: "/n".into() }], &before, &after)[0]["status"], "pass");
assert_eq!(verify(&[Check::ChangedTo { path: "/n".into(), value: json!(17) }], &json!({}), &after)[0]["status"], "pass");
assert_eq!(verify(&[Check::Equals { path: "/m".into(), value: json!(1) }], &before, &after)[0]["status"], "fail");
}
}
No file is open. Choose one in the tree, or press Ctrl+O (⌘O on a Mac) to find one by name.
Syntax highlighting could not load. The unmodified read-only text remains available above.