use proof_cli::demo;
fn tmpdir(name: &str) -> String {
let d = std::env::temp_dir().join(format!("proof-cli-test-{name}-{}", std::process::id()));
let _ = std::fs::remove_dir_all(&d);
std::fs::create_dir_all(&d).unwrap();
d.to_string_lossy().into_owned()
}
fn run(args: Vec<String>) -> Result<i32, String> {
let parsed = proof_cli::Cli::parse(&args)?;
match parsed.command.as_str() {
"create-event" => proof_cli::artifact::write_event(&parsed).map(|_| proof_cli::EXIT_OK),
"attest" => proof_cli::artifact::write_attestation(&parsed).map(|_| proof_cli::EXIT_OK),
"add-evidence" => proof_cli::artifact::write_evidence(&parsed).map(|_| proof_cli::EXIT_OK),
"relate" => proof_cli::artifact::write_relationship(&parsed).map(|_| proof_cli::EXIT_OK),
"build" => proof_cli::make::build(&parsed).map(|_| proof_cli::EXIT_OK),
"revoke" => {
proof_cli::artifact::write_status_object(&parsed, "revoke").map(|_| proof_cli::EXIT_OK)
}
"verify" => proof_cli::make::verify(&parsed),
"evaluate" => proof_cli::make::evaluate(&parsed, false),
other => Err(format!("test harness: unhandled command `{other}`")),
}
}
fn args(cmd: &str, pairs: &[&str]) -> Vec<String> {
let mut v = vec![cmd.to_string()];
v.extend(pairs.iter().map(|s| s.to_string()));
v
}
fn id_of(file: &str) -> String {
let v: serde_json::Value =
serde_json::from_str(&std::fs::read_to_string(file).unwrap()).unwrap();
v["id"].as_str().unwrap().to_string()
}
const D1: &str = "1111111111111111111111111111111111111111111111111111111111111111";
const D2: &str = "2222222222222222222222222222222222222222222222222222222222222222";
#[test]
fn cli_parses_flags_lists_and_bools() {
let c = proof_cli::Cli::parse(
[
"verify".into(),
"--proof".into(),
"p.json".into(),
"--clock".into(),
"1700000300".into(),
"--trusted".into(),
"key:a".into(),
"--trusted".into(),
"key:b,key:c".into(),
"--strict".into(),
"--skew=7".into(),
]
.as_ref(),
)
.unwrap();
assert_eq!(c.req("proof").unwrap(), "p.json");
assert_eq!(c.req_u64("clock").unwrap(), 1_700_000_300);
assert_eq!(c.many("trusted"), vec!["key:a", "key:b,key:c"]);
assert!(c.has("strict"));
assert_eq!(c.opt("skew").as_deref(), Some("7"));
assert!(c.req("missing").is_err());
let bad =
proof_cli::Cli::parse(["verify".into(), "--clock".into(), "not-a-number".into()].as_ref())
.unwrap();
assert!(bad.req_u64("clock").is_err());
}
#[test]
fn parse_fields_maps_text_uint_bool() {
use proof_core::model::MetaValue;
let f = proof_cli::parse_fields(Some("amount=4200,currency=EUR,live=true,old=false".into()))
.unwrap();
assert_eq!(f[0], ("amount".into(), MetaValue::Uint(4200)));
assert_eq!(f[1], ("currency".into(), MetaValue::Text("EUR".into())));
assert_eq!(f[2], ("live".into(), MetaValue::Bool(true)));
assert_eq!(f[3], ("old".into(), MetaValue::Bool(false)));
assert!(proof_cli::parse_fields(Some("broken".into())).is_err());
}
#[test]
fn evaluate_json_flag_keeps_exit_contract() {
let w = tmpdir("json");
let (ev1, ev2) = (format!("{w}/ev1.json"), format!("{w}/ev2.json"));
let (att, evd, rel) = (
format!("{w}/att.json"),
format!("{w}/evd.json"),
format!("{w}/rel.json"),
);
let proof = format!("{w}/proof.json");
run(args(
"create-event",
&[
"--type",
"payment.created",
"--subject",
"payment:p-json",
"--effective-at",
"1700000000",
"--payload-hex",
D1,
"--out",
&ev1,
],
))
.unwrap();
run(args(
"create-event",
&[
"--type",
"invoice.issued",
"--subject",
"invoice:i-json",
"--effective-at",
"1700000000",
"--payload-hex",
D2,
"--out",
&ev2,
],
))
.unwrap();
run(args(
"attest",
&[
"--seed",
"test",
"--subject",
"payment:p-json",
"--claim-type",
"payment.settled",
"--claim",
"amount=4200",
"--issued-at",
"1700000150",
"--out",
&att,
],
))
.unwrap();
let att_id = id_of(&att);
run(args(
"add-evidence",
&[
"--kind",
"transaction_record",
"--digest-hex",
D2,
"--attestation-ref",
&att_id,
"--out",
&evd,
],
))
.unwrap();
let evd_id = id_of(&evd);
let (e1, e2) = (id_of(&ev1), id_of(&ev2));
run(args(
"relate",
&[
"--from",
&e1,
"--type",
"SETTLES",
"--to",
&e2,
"--evidence-ref",
&evd_id,
"--out",
&rel,
],
))
.unwrap();
run(args(
"build",
&[
"--kind",
"payment.settles-invoice",
"--subject",
&e1,
"--predicate",
"settles",
"--object",
&e2,
"--at-time",
"1700000150",
"--created-at",
"1700000200",
"--events",
&format!("{ev1},{ev2}"),
"--attestations",
&att,
"--evidence",
&evd,
"--relationships",
&rel,
"--out",
&proof,
],
))
.unwrap();
let policy = format!("{w}/policy.json");
std::fs::write(
&policy,
r#"{"policy_version":1,"policy_id":"pj","requirements":[
{"type":"signature_valid"},{"type":"not_expired"},
{"type":"relationship_exists","relationship":"SETTLES"}]}"#,
)
.unwrap();
assert_eq!(
run(args(
"evaluate",
&[
"--proof",
&proof,
"--policy",
&policy,
"--clock",
"1700000300",
"--revocations-known-at",
"1700000300",
"--json"
]
)),
Ok(0),
"--json must not change the PASS exit code"
);
let stranger = proof_crypto::Ed25519Key::from_seed(&[9u8; 32]).key_ref();
let ptrust = format!("{w}/policy-trust.json");
std::fs::write(
&ptrust,
format!(
r#"{{"policy_version":1,"policy_id":"tj","requirements":[
{{"type":"issuer_trusted","issuer":"{stranger}"}}]}}"#
),
)
.unwrap();
assert_eq!(
run(args(
"evaluate",
&[
"--proof",
&proof,
"--policy",
&ptrust,
"--clock",
"1700000300",
"--revocations-known-at",
"1700000300",
"--json"
]
)),
Ok(1),
"--json must not change the FAIL exit code"
);
}
#[test]
fn artifact_workflow_verify_then_revoke() {
let w = tmpdir("workflow");
let (ev1, ev2) = (format!("{w}/ev1.json"), format!("{w}/ev2.json"));
let (att, evd, rel) = (
format!("{w}/att.json"),
format!("{w}/evd.json"),
format!("{w}/rel.json"),
);
let proof = format!("{w}/proof.json");
let rev = format!("{w}/rev.json");
run(args(
"create-event",
&[
"--type",
"payment.created",
"--subject",
"payment:p-it",
"--effective-at",
"1700000000",
"--payload-hex",
D1,
"--out",
&ev1,
],
))
.unwrap();
run(args(
"create-event",
&[
"--type",
"invoice.issued",
"--subject",
"invoice:i-it",
"--effective-at",
"1700000000",
"--payload-hex",
D2,
"--out",
&ev2,
],
))
.unwrap();
run(args(
"attest",
&[
"--seed",
"test",
"--subject",
"payment:p-it",
"--claim-type",
"payment.settled",
"--claim",
"amount=4200",
"--issued-at",
"1700000150",
"--out",
&att,
],
))
.unwrap();
let att_id = id_of(&att);
run(args(
"add-evidence",
&[
"--kind",
"transaction_record",
"--digest-hex",
D2,
"--attestation-ref",
&att_id,
"--out",
&evd,
],
))
.unwrap();
let evd_id = id_of(&evd);
let (e1, e2) = (id_of(&ev1), id_of(&ev2));
run(args(
"relate",
&[
"--from",
&e1,
"--type",
"SETTLES",
"--to",
&e2,
"--evidence-ref",
&evd_id,
"--out",
&rel,
],
))
.unwrap();
run(args(
"build",
&[
"--kind",
"payment.settles-invoice",
"--subject",
&e1,
"--predicate",
"settles",
"--object",
&e2,
"--at-time",
"1700000150",
"--created-at",
"1700000200",
"--events",
&format!("{ev1},{ev2}"),
"--attestations",
&att,
"--evidence",
&evd,
"--relationships",
&rel,
"--out",
&proof,
],
))
.unwrap();
assert_eq!(
run(args(
"verify",
&[
"--proof",
&proof,
"--clock",
"1700000300",
"--revocations-known-at",
"1700000300"
]
)),
Ok(0)
);
let policy = format!("{w}/policy.json");
std::fs::write(
&policy,
r#"{"policy_version":1,"policy_id":"p","requirements":[
{"type":"signature_valid"},{"type":"not_expired"},
{"type":"relationship_exists","relationship":"SETTLES"}]}"#,
)
.unwrap();
assert_eq!(
run(args(
"evaluate",
&[
"--proof",
&proof,
"--policy",
&policy,
"--clock",
"1700000300",
"--revocations-known-at",
"1700000300"
]
)),
Ok(0)
);
let stranger = proof_crypto::Ed25519Key::from_seed(&[7u8; 32]).key_ref();
let ptrust = format!("{w}/policy-trust.json");
std::fs::write(
&ptrust,
format!(
r#"{{"policy_version":1,"policy_id":"t","requirements":[
{{"type":"issuer_trusted","issuer":"{stranger}"}}]}}"#
),
)
.unwrap();
assert_eq!(
run(args(
"evaluate",
&[
"--proof",
&proof,
"--policy",
&ptrust,
"--clock",
"1700000300",
"--revocations-known-at",
"1700000300"
]
)),
Ok(1),
"issuer_trusted with empty trust list must FAIL (exit 1), never error"
);
run(args(
"revoke",
&[
"--seed",
"test",
"--target",
&att_id,
"--reason",
"it chargeback",
"--at",
"1700000400",
"--out",
&rev,
],
))
.unwrap();
let second = run(args(
"verify",
&[
"--proof",
&proof,
"--clock",
"1700000500",
"--status",
&rev,
"--revocations-known-at",
"1700000500",
],
));
assert_eq!(second, Ok(1), "revoked proof must exit 1, not error");
}
#[test]
fn tampered_artifact_file_rejected_at_build() {
let w = tmpdir("tampered");
let ev = format!("{w}/ev.json");
run(args(
"create-event",
&[
"--type",
"payment.created",
"--subject",
"payment:p-tamper",
"--effective-at",
"1700000000",
"--payload-hex",
D1,
"--out",
&ev,
],
))
.unwrap();
let mut v: serde_json::Value =
serde_json::from_str(&std::fs::read_to_string(&ev).unwrap()).unwrap();
let cbor = v["cbor"].as_str().unwrap().to_string();
let mut hex: Vec<char> = cbor.chars().collect();
hex[10] = if hex[10] == '0' { '1' } else { '0' };
v["cbor"] = serde_json::Value::String(hex.into_iter().collect());
std::fs::write(&ev, serde_json::to_string_pretty(&v).unwrap()).unwrap();
let err = run(args(
"build",
&[
"--kind",
"k",
"--subject",
"s",
"--predicate",
"p",
"--created-at",
"1700000200",
"--events",
&ev,
"--attestations",
&ev,
"--evidence",
&ev,
"--relationships",
&ev,
"--out",
&format!("{w}/out.json"),
],
))
.unwrap_err();
assert!(
err.contains("ev.json"),
"error must identify the offending file: {err}"
);
}
#[test]
fn seed_file_matches_seed_and_refuses_combination() {
let w = tmpdir("seedfile");
let seed_hex = "0a".to_string() + &"0b".repeat(31);
assert_eq!(seed_hex.len(), 64);
let sf = format!("{w}/seed.hex");
std::fs::write(
&sf,
format!(
"{seed_hex}
"
),
)
.unwrap();
let e1 = format!("{w}/e1.json");
run(args(
"create-event",
&[
"--type",
"payment.created",
"--subject",
"payment:p-sf",
"--effective-at",
"1700000000",
"--payload-hex",
D1,
"--out",
&e1,
],
))
.unwrap();
let a1 = format!("{w}/a1.json");
let a2 = format!("{w}/a2.json");
for (flag, val, out) in [
("--seed", seed_hex.as_str(), a1.as_str()),
("--seed-file", sf.as_str(), a2.as_str()),
] {
let pairs: Vec<&str> = vec![
"--subject",
"payment:p-sf",
"--claim-type",
"payment.settled",
flag,
val,
"--issued-at",
"1700000150",
"--out",
out,
];
run(args("attest", &pairs)).unwrap();
}
assert_eq!(id_of(&a1), id_of(&a2));
let bad = run(args(
"attest",
&[
"--seed",
&seed_hex,
"--seed-file",
&sf,
"--subject",
"payment:p-sf",
"--claim-type",
"payment.settled",
"--issued-at",
"1700000150",
"--out",
&format!("{w}/a3.json"),
],
));
assert!(bad.is_err());
}
#[test]
fn oversized_input_files_fail_closed() {
let w = tmpdir("oversized");
let big = format!("{w}/big.json");
let over = (proof_cli::MAX_INPUT_FILE_BYTES + 100) as usize;
std::fs::write(&big, vec![b'x'; over]).unwrap();
let err = proof_cli::read_input_file(&big).unwrap_err();
assert!(err.contains("too large"), "unexpected error: {err}");
assert!(proof_cli::check::load_proof(&big).is_err());
assert!(proof_cli::artifact::load_event(&big, &proof_cli::limits()).is_err());
}
#[test]
fn demo_is_deterministic_and_green() {
let d1 = tmpdir("demo1");
let d2 = tmpdir("demo2");
assert_eq!(demo::run(&d1), Ok(proof_cli::EXIT_OK));
assert_eq!(demo::run(&d2), Ok(proof_cli::EXIT_OK));
for f in ["proof.cbor", "report.json", "explanation.txt"] {
let a = std::fs::read(format!("{d1}/{f}")).unwrap();
let b = std::fs::read(format!("{d2}/{f}")).unwrap();
assert_eq!(a, b, "{f} must be byte-identical across runs");
}
let report = std::fs::read_to_string(format!("{d1}/report.json")).unwrap();
assert!(report.contains("\"evidence_validity\": \"invalid\""));
assert!(report.contains("REVOKED"));
}