//! Runs the `cairns` binary on commands that need no network or sign-in. use std::io::Write; use std::process::{Command, Stdio}; use serde_json::{Value, json}; const H1: &str = "9f86d081884c7d659a2feaa0c55ad015a3bf4f1b2b0b822cd15d6c15b0f00a08"; /// A stand-in schema hash: the hash of defs that are just "org.example.grid". const GRID: &str = "56dcf6509c4ce37f0ed6de30f33f7fe9c22d3d41fccc4552a567f0ed94af6e5f"; /// The key of the source site H1 with schema GRID. const SITE: &str = "06574899e4104826a4632f35c7a9a160bd44ec326b75d0abb5cd8e7757667735"; const R2400: &str = "979fd5fdef9f595230b21ccfdf446dbc396fd5ed04a49156b9cd56dd37badc602706b2cd42332b89574fdff28e8dba15"; /// Runs `cairns args...` with `stdin`, returning (success, parsed stdout or stderr). fn cairns(args: &[&str], stdin: Option<&Value>) -> (bool, Value) { let mut child = Command::new(env!("CARGO_BIN_EXE_cairns")) .args(args) .stdin(Stdio::piped()) .stdout(Stdio::piped()) .stderr(Stdio::piped()) .spawn() .unwrap(); let input = stdin.map(Value::to_string).unwrap_or_default(); child .stdin .take() .unwrap() .write_all(input.as_bytes()) .unwrap(); let out = child.wait_with_output().unwrap(); let text = if out.status.success() { out.stdout } else { out.stderr }; let text = String::from_utf8(text).unwrap(); let value = serde_json::from_str(text.trim()).unwrap_or_else(|e| panic!("{e}: {text}")); (out.status.success(), value) } fn stone(source: &str) -> Value { json!({ "site": { "base": { "$type": "org.cairnsproto.draft.defs#sourceBase", "source": { "alg": "sha256", "value": source } }, "schema": { "alg": "sha256", "value": GRID } }, "payload": { "$type": "org.cairnsproto.draft.defs#inlinePayload", "data": { "votes": "412" } }, "result": "found", "method": { "tool": "claude-code", "toolVersion": "2.3.1" } }) } #[test] fn place_dry_run_fills_and_keys_the_stone() { let (ok, out) = cairns(&["place", "--dry-run", "--draw", "2400"], Some(&stone(H1))); assert!(ok, "{out}"); assert_eq!(out["site"], SITE); assert_eq!(out["value"]["$type"], "org.cairnsproto.draft.stone"); assert_eq!(out["value"]["draw"], json!({ "beaconRound": 2400 })); let created = out["value"]["createdAt"].as_str().unwrap(); assert!(created.ends_with('Z') && created.len() == 24, "{created}"); let uri = out["uri"].as_str().unwrap(); assert!( uri.contains("/org.cairnsproto.draft.stone/") && uri.len() > 13, "{uri}" ); } #[test] fn place_rejects_bad_stones_before_writing() { let (ok, out) = cairns(&["place", "--dry-run"], Some(&stone(&H1.to_uppercase()))); assert!(!ok); assert!( out["error"].as_str().unwrap().contains("site.base.source"), "{out}" ); let mut missing = stone(H1); missing.as_object_mut().unwrap().remove("site"); let (ok, out) = cairns(&["place", "--dry-run"], Some(&missing)); assert!(!ok); assert!(out["error"].as_str().unwrap().contains("site"), "{out}"); let mut wrong_type = stone(H1); wrong_type["$type"] = json!("org.cairnsproto.draft.witness"); let (ok, _) = cairns(&["place", "--dry-run"], Some(&wrong_type)); assert!(!ok); } /// A composer check reference; nothing in these tests fetches it. fn compose() -> Value { json!({ "uri": "at://did:web:dry.example/org.cairnsproto.draft.check/c", "cid": "bafyreie5737gdxlw5i64vzichcalba3z2v5n6icifvx5xytvske7mr3hpm" }) } fn foundation() -> Value { json!({ "policy": { "draw": { "startThresholdPpm": 62500 } }, "project": { "status": "active", "scope": { "$type": "org.cairnsproto.draft.project#openScope" }, "courses": [{ "id": "transcribe", "markType": "org.cairnsproto.draft.mark#pdfRegion", "schema": { "alg": "sha256", "value": GRID }, "schemaRecord": { "uri": "at://did:web:dry.example/org.cairnsproto.draft.schema/s", "cid": "bafyreie5737gdxlw5i64vzichcalba3z2v5n6icifvx5xytvske7mr3hpm" }, "compose": compose(), "bounds": "closed" }] } }) } #[test] fn foundation_pins_the_policy_it_creates() { let (ok, out) = cairns( &[ "foundation", "--dry-run", "--did", "did:web:maintainer.example", ], Some(&foundation()), ); assert!(ok, "{out}"); let records = out["records"].as_array().unwrap(); let (policy, project) = (&records[0], &records[1]); assert_eq!(policy["value"]["$type"], "org.cairnsproto.draft.policy"); assert_eq!( project["value"]["policy"], json!({ "uri": policy["uri"], "cid": policy["cid"] }) ); assert!( policy["uri"] .as_str() .unwrap() .starts_with("at://did:web:maintainer.example/") ); assert_eq!( project["value"]["maintainers"], json!(["did:web:maintainer.example"]) ); assert_eq!( policy["value"]["timekeepers"], json!(["did:plc:jtu4o5k252bsaurj7onzcuip"]), "the Cairns timekeeper by default" ); for own in [json!([]), json!(["did:web:clock.example"])] { let mut input = foundation(); input["policy"] = json!({ "timekeepers": own }); let (ok, out) = cairns( &[ "foundation", "--dry-run", "--did", "did:web:maintainer.example", ], Some(&input), ); assert!(ok, "{out}"); assert_eq!( out["records"][0]["value"]["timekeepers"], own, "a policy's own list, even an empty one, stands" ); } let mut preset = foundation(); preset["project"]["policy"] = json!({ "uri": "at://did:web:x.example/org.cairnsproto.draft.policy/p", "cid": "x" }); let (ok, _) = cairns(&["foundation", "--dry-run"], Some(&preset)); assert!( !ok, "a caller-chosen policy would not be the one foundation writes" ); } #[test] fn expected_sponsors_set_the_starting_draw_threshold() { let start = |expected: Value, policy: Value| { let mut input = foundation(); input["expectedSponsors"] = expected; input["policy"] = policy; let (ok, out) = cairns( &["foundation", "--dry-run", "--did", "did:web:m.example"], Some(&input), ); assert!(ok, "{out}"); out["records"][0]["value"]["draw"]["startThresholdPpm"].clone() }; // About two of the expected sponsors drawn per site, rounded up, capped at everyone. for (expected, ppm) in [ (4, 500_000), (3, 666_667), (100, 20_000), (2, 1_000_000), (1, 1_000_000), ] { assert_eq!(start(json!(expected), json!({})), json!(ppm), "{expected}"); } // The estimate keeps the policy's other draw settings. let mut input = foundation(); input["expectedSponsors"] = json!(4); input["policy"] = json!({ "draw": { "windowEpochs": 12 } }); let (ok, out) = cairns( &["foundation", "--dry-run", "--did", "did:web:m.example"], Some(&input), ); assert!(ok, "{out}"); assert_eq!( out["records"][0]["value"]["draw"], json!({ "windowEpochs": 12, "startThresholdPpm": 500_000 }) ); // A threshold the policy sets wins over the estimate. assert_eq!( start(json!(4), json!({ "draw": { "startThresholdPpm": 62500 } })), json!(62500) ); for bad in [json!(0), json!(-3), json!(2.5), json!("4")] { let mut input = foundation(); input["expectedSponsors"] = bad.clone(); let (ok, _) = cairns(&["foundation", "--dry-run"], Some(&input)); assert!(!ok, "{bad}"); } } #[test] fn a_course_over_whole_pdfs_needs_a_composer() { let mut input = foundation(); input["project"]["courses"][0] .as_object_mut() .unwrap() .remove("compose"); let run = |input: &Value| { cairns( &["foundation", "--dry-run", "--did", "did:web:m.example"], Some(input), ) }; let (ok, err) = run(&input); assert!(!ok); assert!( err["error"].as_str().unwrap().contains("needs `compose`"), "{err}" ); // Working on marked regions, a course 0 doesn't cover whole PDFs. input["project"]["courses"][0]["minMark"] = json!({ "$type": "org.cairnsproto.draft.mark#pdfRegion", "page": 1 }); let (ok, out) = run(&input); assert!(ok, "{out}"); } #[test] fn a_split_course_is_checked_at_foundation() { let with_rows = |rows: Value| { let mut input = foundation(); input["project"]["courses"] .as_array_mut() .unwrap() .push(rows); cairns( &["foundation", "--dry-run", "--did", "did:web:m.example"], Some(&input), ) }; let rows = |extra: Value| { let mut c = json!({ "id": "rows", "parent": "transcribe", "split": "/contests", "markType": "org.cairnsproto.draft.mark#jsonPointer", "schema": { "alg": "sha256", "value": GRID }, "schemaRecord": { "uri": "at://did:web:dry.example/org.cairnsproto.draft.schema/s", "cid": "bafyreie5737gdxlw5i64vzichcalba3z2v5n6icifvx5xytvske7mr3hpm" }, "compose": compose(), "bounds": "closed" }); for (k, v) in extra.as_object().unwrap() { if v.is_null() { c.as_object_mut().unwrap().remove(k); } else { c[k] = v.clone(); } } c }; let (ok, out) = with_rows(rows(json!({}))); assert!(ok, "{out}"); assert_eq!( out["records"][1]["value"]["courses"][1]["compose"], json!({ "$type": "org.cairnsproto.draft.project#checkComposer", "check": compose() }) ); let (ok, out) = with_rows(rows(json!({ "compose": "concat" }))); assert!(ok, "{out}"); assert_eq!( out["records"][1]["value"]["courses"][1]["compose"], json!({ "$type": "org.cairnsproto.draft.project#builtinComposer", "name": "concat" }) ); assert_eq!( out["records"][1]["value"]["courses"][1]["split"], "/contests" ); for (bad, why) in [ (json!({ "split": "contests" }), "isn't a JSON pointer"), (json!({ "parent": null }), "needs a parent"), ( json!({ "markType": "org.cairnsproto.draft.mark#pdfRegion" }), "markType", ), (json!({ "split": 3 }), "JSON pointer string"), (json!({ "compose": null }), "needs `compose`"), (json!({ "compose": "merge" }), "no built-in composer"), (json!({ "compose": 7 }), "compose is"), ] { let (ok, err) = with_rows(rows(bad.clone())); assert!(!ok, "{bad}"); assert!(err["error"].as_str().unwrap().contains(why), "{bad}: {err}"); } } #[test] fn draw_checks_a_given_beacon() { let beacon = format!("2400:{R2400}"); let run = |sponsor: &str, quiet: &str| { cairns( &[ "draw", "--site", SITE, "--sponsor", sponsor, "--quiet-epochs", quiet, "--beacon", &beacon, ], None, ) }; // Smallest drawing thresholds, computed outside this crate: 14062 ppm for // placed1 and 511211 ppm for undrawn0 at this site and round. let (ok, out) = run("did:web:placed1.example", "0"); assert!(ok, "{out}"); assert_eq!( (out["epoch"].clone(), out["drawn"].clone()), (json!(2), json!(true)) ); let (_, out) = run("did:web:undrawn0.example", "4"); assert_eq!( (out["thresholdPpm"].clone(), out["drawn"].clone()), (json!(500000), json!(false)) ); let (_, out) = run("did:web:undrawn0.example", "5"); assert_eq!( (out["thresholdPpm"].clone(), out["drawn"].clone()), (json!(1000000), json!(true)) ); let forged = format!("3600:{R2400}"); let (ok, out) = cairns( &[ "draw", "--site", SITE, "--sponsor", "did:web:a.example", "--beacon", &forged, ], None, ); assert!(!ok, "{out}"); } const PROJECT_DIR: &str = concat!(env!("CARGO_MANIFEST_DIR"), "/tests/fixtures/project"); fn dry_run_file(path: &str) -> (bool, Value) { cairns( &[ "foundation", "--dry-run", "--did", "did:web:maintainer.example", path, ], None, ) } #[test] fn foundation_publishes_schemas_and_procedures_with_the_project() { let (ok, out) = dry_run_file(&format!("{PROJECT_DIR}/foundation.json")); assert!(ok, "{out}"); let records = out["records"].as_array().unwrap(); let types: Vec<&str> = records .iter() .map(|r| r["value"]["$type"].as_str().unwrap()) .collect(); assert_eq!( types, [ "org.cairnsproto.draft.source", "org.cairnsproto.draft.schema", "org.cairnsproto.draft.procedure", "org.cairnsproto.draft.policy", "org.cairnsproto.draft.project" ] ); let (schema, procedure, project) = (&records[1], &records[2], &records[4]); let course = &project["value"]["courses"][0]; let hash = cairns_core::schema::schema_hash(&schema["value"]["defs"]).unwrap(); assert_eq!( course["schema"], json!(hash), "the course names the schema by its hash" ); assert_eq!( course["schemaRecord"], json!({ "uri": schema["uri"], "cid": schema["cid"] }) ); assert_eq!( course["procedure"], json!({ "uri": procedure["uri"], "cid": procedure["cid"] }) ); let paths: Vec<&str> = procedure["value"]["bundle"]["files"] .as_array() .unwrap() .iter() .map(|f| f["path"].as_str().unwrap()) .collect(); assert_eq!(paths, ["SKILL.md", "examples/zero.json"]); assert_eq!(procedure["value"]["tools"], json!(["source.region"])); } /// A copy of the fixture project in a fresh directory, changed by `edit`. fn variant(name: &str, edit: impl FnOnce(&std::path::Path)) -> String { let dir = std::path::Path::new(env!("CARGO_TARGET_TMPDIR")).join(format!("project-{name}")); let _ = std::fs::remove_dir_all(&dir); copy_dir(std::path::Path::new(PROJECT_DIR), &dir); edit(&dir); dir.join("foundation.json").to_string_lossy().into_owned() } fn copy_dir(from: &std::path::Path, to: &std::path::Path) { std::fs::create_dir_all(to).unwrap(); for entry in std::fs::read_dir(from).unwrap() { let entry = entry.unwrap(); let target = to.join(entry.file_name()); if entry.file_type().unwrap().is_dir() { copy_dir(&entry.path(), &target); } else { std::fs::copy(entry.path(), target).unwrap(); } } } fn refused(path: &str, needle: &str) { let (ok, out) = dry_run_file(path); assert!(!ok, "expected a refusal mentioning {needle}"); assert!(out.to_string().contains(needle), "{out}"); } #[test] fn foundation_refuses_bundles_that_do_not_check() { let skill = |dir: &std::path::Path| dir.join("procedures/votes/SKILL.md"); refused( &variant("bad-example", |d| { let text = std::fs::read_to_string(skill(d)) .unwrap() .replace("412", "-1"); std::fs::write(skill(d), text).unwrap(); }), "SKILL.md example 1", ); refused( &variant("bad-file-example", |d| { std::fs::write( d.join("procedures/votes/examples/zero.json"), "{ \"count\": 0 }", ) .unwrap(); }), "examples/zero.json", ); refused( &variant("scripts", |d| { std::fs::create_dir_all(d.join("procedures/votes/scripts")).unwrap(); std::fs::write(d.join("procedures/votes/scripts/run.sh"), "echo").unwrap(); }), "scripts", ); refused( &variant("no-skill", |d| std::fs::remove_file(skill(d)).unwrap()), "no SKILL.md", ); refused( &variant("binary", |d| { std::fs::write( d.join("procedures/votes/page.png"), [0x89, 0x50, 0xff, 0x00], ) .unwrap() }), "page.png is not text", ); #[cfg(unix)] refused( &variant("executable", |d| { use std::os::unix::fs::PermissionsExt; let path = d.join("procedures/votes/examples/zero.json"); std::fs::set_permissions(path, std::fs::Permissions::from_mode(0o755)).unwrap(); }), "zero.json is executable", ); let rewrite = |d: &std::path::Path, from: &str, to: &str| { let path = d.join("foundation.json"); let text = std::fs::read_to_string(&path) .unwrap() .replacen(from, to, 1); std::fs::write(path, text).unwrap(); }; refused( &variant("unknown", |d| { rewrite(d, "\"schema\": \"votes\"", "\"schema\": \"tally\"") }), "no schema named tally", ); refused( &variant("unused", |d| { rewrite( d, "\"schemas\": { \"votes\": \"schemas/votes.json\" }", "\"schemas\": { \"votes\": \"schemas/votes.json\", \"spare\": \"schemas/votes.json\" }", ) }), "schema spare is not used", ); let (ok, out) = dry_run_file(&variant("fine", |_| {})); assert!(ok, "the unchanged copy is accepted: {out}"); } #[test] fn social_records_validate_before_writing() { let (ok, out) = cairns(&["follow", "did:web:alice.example", "--dry-run"], None); assert!(ok, "{out}"); assert_eq!(out["value"]["subject"]["did"], "did:web:alice.example"); let (ok, out) = cairns( &[ "block", "did:web:mallory.example", "--dry-run", "--reason", "spam", ], None, ); assert!(ok, "{out}"); assert_eq!(out["value"]["$type"], "org.cairnsproto.draft.block"); let long = "x".repeat(10_000); let (ok, out) = cairns( &[ "block", "did:web:mallory.example", "--dry-run", "--reason", &long, ], None, ); assert!(!ok, "an over-long reason fails the lexicon: {out}"); }