use crate::*;
const RECEIPT_ORDER: [&str; 11] =
["Db", "Net", "Llm", "Fs", "Exec", "Env", "Clock", "Ipc", "Rand", "Clipboard", "Log"];
#[derive(Default, Clone)]
pub(crate) struct FnInfo {
pub(crate) inferred: BTreeSet<String>,
pub(crate) direct: BTreeSet<String>,
pub(crate) calls: BTreeSet<String>,
}
fn load_fninfo_flagged(prefix: &str) -> (BTreeMap<String, FnInfo>, bool) {
let mut out: BTreeMap<String, FnInfo> = BTreeMap::new();
let (entries, hard_fail) = load_entries_inner(prefix);
for e in entries {
let info = out.entry(e.func.clone()).or_default();
info.inferred.extend(e.inferred);
info.direct.extend(e.direct);
info.calls.extend(e.calls);
}
(out, hard_fail)
}
pub(crate) fn load_fninfo_loud(prefix: &str, which: &str) -> Result<BTreeMap<String, FnInfo>, i32> {
let at = if which.is_empty() { String::new() } else { format!("{which} ") };
if glob_reports(prefix).is_empty() {
eprintln!("candor: no report files at {at}prefix `{prefix}` — check the path.");
return Err(2);
}
let (map, hard_fail) = load_fninfo_flagged(prefix);
if map.is_empty() && hard_fail {
eprintln!("candor: every report found at {at}prefix `{prefix}` failed to load — refusing to report an empty (all-clear) answer over a corrupt report; re-run the scan.");
return Err(2);
}
Ok(map)
}
#[derive(Serialize, Clone)]
pub(crate) struct Change {
#[serde(rename = "fn")]
pub(crate) func: String,
pub(crate) gained: Vec<String>,
pub(crate) introduced: Vec<String>,
pub(crate) inherited: Vec<String>,
pub(crate) lost: Vec<String>,
pub(crate) status: String,
}
#[derive(Serialize)]
pub(crate) struct DiffJson<'a> {
pub(crate) baseline_version: &'a str,
pub(crate) engine_version: &'a str,
pub(crate) changes: Vec<Change>,
#[serde(flatten, skip_serializing_if = "Option::is_none")]
pub(crate) completeness: Option<crate::completeness::CompletenessFields>,
#[serde(flatten, skip_serializing_if = "Option::is_none")]
pub(crate) baseline_completeness: Option<crate::completeness::BaselineCompletenessFields>,
}
fn diff_note(comp: &crate::completeness::ReportCompleteness, side: &str) {
comp.print_note(
&format!("the changes below are computed against only the {side} report candor could see"),
&format!(
"A change hiding in an unread unit of the {side} tree means `changes` can MISS a real gain, \
or show a stale effect as newly gained (or lost) — and an empty `changes` reads as *nothing \
about this codebase's effects changed*, a claim built from two reports where at least one \
was not read in full. {} Re-scan before treating this diff as complete.",
comp.gate_line()
),
);
}
pub(crate) fn cmd_diff(args: &[String]) -> i32 {
let mut want_json = false;
let mut pos: Vec<String> = Vec::new();
for a in args {
match a.as_str() {
"--json" => want_json = true,
"--text" | "--human" => {}
other if other.starts_with('-') && other.len() > 1 => {
let hint = if other == "--report" {
" — diff takes its two reports as POSITIONAL locators: `diff <current> <baseline>`"
} else {
""
};
eprintln!("candor-query diff: unknown flag `{other}`{hint}\n known flags: --json");
return 2;
}
_ => pos.push(a.clone()),
}
}
if pos.len() < 2 {
eprintln!("usage: candor-query diff <current> <baseline> [--json] [<baseline_ver> <engine_ver>]");
return 2;
}
let mut rest: Vec<String> = pos[2..].to_vec();
if matches!(rest.first().map(String::as_str), Some("0") | Some("1")) {
deprecation_note("a trailing `0|1` JSON sentinel");
if rest.first().map(String::as_str) == Some("1") {
want_json = true;
}
rest.remove(0);
}
let cur_loc = resolve_locator(&pos[0]);
let base_loc = resolve_locator(&pos[1]);
let (cur_pre, base_pre) = (&cur_loc, &base_loc);
let bver = rest.first().map(String::as_str).unwrap_or("");
let ever = rest.get(1).map(String::as_str).unwrap_or("");
let cur = match load_fninfo_loud(cur_pre, "current") {
Ok(m) => m,
Err(c) => return c,
};
let base = match load_fninfo_loud(base_pre, "baseline") {
Ok(m) => m,
Err(c) => return c,
};
let cur_comp = crate::completeness::report_completeness(cur_pre);
let base_comp = crate::completeness::report_completeness(base_pre);
let empty = BTreeSet::new();
let mut changes: Vec<Change> = Vec::new();
let keys: BTreeSet<&String> = cur.keys().chain(base.keys()).collect();
for fn_ in keys {
let ci = cur.get(fn_).map(|v| &v.inferred).unwrap_or(&empty);
let bi = base.get(fn_).map(|v| &v.inferred).unwrap_or(&empty);
if !cur.contains_key(fn_) {
if !bi.is_empty() {
changes.push(Change {
func: fn_.clone(),
gained: vec![],
introduced: vec![],
inherited: vec![],
lost: bi.iter().cloned().collect(),
status: "removed".into(),
});
}
continue;
}
let gained: Vec<String> = gained_effects(ci, bi);
let lost: Vec<String> =
if base.contains_key(fn_) { bi.difference(ci).cloned().collect() } else { vec![] };
if gained.is_empty() && lost.is_empty() {
continue;
}
let cd = &cur[fn_].direct;
let introduced: Vec<String> = gained.iter().filter(|e| cd.contains(*e)).cloned().collect();
let inherited: Vec<String> = gained.iter().filter(|e| !cd.contains(*e)).cloned().collect();
changes.push(Change {
func: fn_.clone(),
gained,
introduced,
inherited,
lost,
status: if base.contains_key(fn_) { "changed".into() } else { "new".into() },
});
}
if want_json {
changes.sort_by(|a, b| a.func.cmp(&b.func));
let out = DiffJson {
baseline_version: bver,
engine_version: ever,
changes,
completeness: cur_comp.fields(),
baseline_completeness: base_comp.baseline_fields(),
};
println!("{}", serde_json::to_string_pretty(&out).unwrap());
return 0;
}
if cur_comp.must_hedge() {
diff_note(&cur_comp, "CURRENT");
}
if base_comp.must_hedge() {
diff_note(&base_comp, "BASELINE");
}
if changes.is_empty() {
if cur_comp.must_hedge() || base_comp.must_hedge() {
println!(
"candor: no effect changes IN WHAT CANDOR COULD SEE vs {base_pre} (@{}) — but see the \
INCOMPLETE note(s) above; this is NOT \"nothing changed\".",
q_or(bver)
);
return 0;
}
println!("candor: no effect changes vs {base_pre} (@{}).", q_or(bver));
return 0;
}
println!("candor diff — current (@{ever}) vs {base_pre} (@{})", q_or(bver));
if !bver.is_empty() && !ever.is_empty() && bver != ever {
println!(" ⚠ baseline @{bver} ≠ engine @{ever} — some changes may be the engine reclassifying, not your code.");
}
println!();
let calls_of: BTreeMap<&String, &BTreeSet<String>> =
cur.iter().map(|(fn_, v)| (fn_, &v.calls)).collect();
let sources: BTreeSet<String> =
changes.iter().filter(|c| !c.introduced.is_empty()).map(|c| c.func.clone()).collect();
let all_effects: BTreeSet<String> = changes.iter().flat_map(|c| c.gained.iter().cloned()).collect();
let mut top_level: BTreeSet<String> = BTreeSet::new();
let mut endpoints_of: BTreeMap<String, Vec<String>> = BTreeMap::new();
for e in &all_effects {
let gainers: BTreeSet<String> =
changes.iter().filter(|c| c.gained.contains(e)).map(|c| c.func.clone()).collect();
let mut called: BTreeSet<String> = BTreeSet::new();
for g in &gainers {
if let Some(cs) = calls_of.get(g) {
called.extend(cs.intersection(&gainers).cloned());
}
}
let tl: BTreeSet<String> = gainers.difference(&called).cloned().collect();
top_level.extend(tl.iter().cloned());
endpoints_of.insert(e.clone(), tl.difference(&sources).cloned().collect());
}
let consequential: BTreeSet<String> = sources.union(&top_level).cloned().collect();
changes.sort_by(|a, b| rank(a, &top_level).cmp(&rank(b, &top_level)).then_with(|| a.func.cmp(&b.func)));
let mut shown: BTreeSet<String> = BTreeSet::new();
for c in &changes {
if !consequential.contains(&c.func) && c.lost.is_empty() {
continue; }
shown.insert(c.func.clone());
let mut parts: Vec<String> = Vec::new();
parts.extend(c.introduced.iter().map(|e| format!("+{e}*")));
parts.extend(c.inherited.iter().map(|e| format!("+{e}")));
parts.extend(c.lost.iter().map(|e| format!("-{e}")));
let mark = if !c.gained.is_empty() { "+" } else { "-" };
let mut tags: Vec<&str> = Vec::new();
if c.status == "new" {
tags.push("new fn");
}
if c.status == "removed" {
tags.push("removed fn");
}
if top_level.contains(&c.func) && !sources.contains(&c.func) {
tags.push("top-level");
}
if c.gained.iter().any(|e| e == "Unknown") {
tags.push("⚠ now unresolvable");
}
let tag = if tags.is_empty() { String::new() } else { format!(" ({})", tags.join(", ")) };
println!(" {mark} {}{tag} {{ {} }}", c.func, parts.join(" "));
}
let mut hidden: Vec<String> =
changes.iter().filter(|c| !shown.contains(&c.func)).map(|c| c.func.clone()).collect();
hidden.sort();
if !hidden.is_empty() {
let head: Vec<String> = hidden.iter().take(4).cloned().collect();
let names = if hidden.len() > 4 {
format!("{}, +{} more", head.join(", "), hidden.len() - 4)
} else {
head.join(", ")
};
println!(" … {} intermediate caller(s) also inherit it: {names}", hidden.len());
}
println!();
println!(" * = introduced here; (top-level) = where the effect surfaces (an entry point / public API).");
for e in &all_effects {
let mut srcs: Vec<String> =
changes.iter().filter(|c| c.introduced.contains(e)).map(|c| c.func.clone()).collect();
srcs.sort();
let gainers: BTreeSet<String> =
changes.iter().filter(|c| c.gained.contains(e)).map(|c| c.func.clone()).collect();
let eps = endpoints_of.get(e).cloned().unwrap_or_default();
if !srcs.is_empty() {
let reach = if !eps.is_empty() { format!(" → reaches {}", eps.join(", ")) } else { String::new() };
let extra = gainers.len() as i64 - srcs.len() as i64 - eps.len() as i64;
let tail = if extra > 0 {
format!(" (+{extra} intermediate)")
} else if eps.is_empty() {
" (stays local)".to_string()
} else {
String::new()
};
println!(" {e}: introduced in {}{reach}{tail}", srcs.join(", "));
} else if !gainers.is_empty() {
let names = if !eps.is_empty() { eps.join(", ") } else { gainers.iter().cloned().collect::<Vec<_>>().join(", ") };
println!(" {e}: reaches {names} (source outside this crate/baseline)");
}
}
if changes.iter().any(|c| c.gained.iter().any(|e| e == "Unknown")) {
println!(" ⚠ a new Unknown means candor can no longer prove that function's effect set is complete — review it.");
}
0
}
pub(crate) fn rank(c: &Change, top_level: &BTreeSet<String>) -> u8 {
if !c.introduced.is_empty() {
0
} else if top_level.contains(&c.func) {
1
} else if !c.gained.is_empty() {
2
} else {
3
}
}
pub(crate) fn cmd_receipt(args: &[String]) -> i32 {
let Some(pre) = args.first().map(String::as_str) else {
eprintln!("usage: candor-query receipt <prefix>");
return 2;
};
let base = prefix_base(pre);
let fns = match load_entries_loud(pre) {
Ok(v) => v,
Err(c) => return c,
};
let comp = crate::completeness::report_completeness(pre);
let (tally, unresolved) = tally_effects(&fns);
let unresolved = unresolved.len();
let effects = RECEIPT_ORDER
.iter()
.filter(|k| tally.get(**k).copied().unwrap_or(0) > 0)
.map(|k| format!("{} {k}", tally[*k]))
.collect::<Vec<_>>()
.join(", ");
let (mut calib_c, calib_p, calib_path) = load_calibrated(pre, &base);
calib_c.extend(calib_path); let encountered = encountered_set(pre);
let join = |s: &BTreeSet<String>| s.iter().cloned().collect::<Vec<_>>().join(" ");
println!("fns\t{}", fns.len());
println!("effects\t{effects}");
println!("unresolved\t{unresolved}");
println!("calibrated\t{}|{}", join(&calib_c), join(&calib_p));
println!("encountered\t{}", join(&encountered));
if comp.must_hedge() {
println!("incomplete\ttrue");
comp.eprint_note(
"the fields above are computed against only what candor could see in this report",
&format!(
"A gap here can UNDER-count `fns`/`effects`, hide a class from `encountered`, or leave \
`unresolved` short — this row's boolean is the whole of the machine-readable warning \
(a TSV cell cannot safely carry the manifest itself). {} Re-scan before trusting this \
receipt as complete.",
comp.gate_line()
),
);
}
0
}
fn gain_origin(
func: &str,
base: &BTreeMap<String, FnInfo>,
cg_nodes: &BTreeSet<&str>,
cg_empty_or_partial: bool,
) -> &'static str {
if base.contains_key(func) || cg_nodes.contains(func) {
"existing"
} else if cg_empty_or_partial {
"unknown"
} else {
"new"
}
}
fn attach_coverage(
v: &mut serde_json::Value,
cur: Option<candor_report::Coverage>,
base: Option<candor_report::Coverage>,
) {
let cur_set: BTreeSet<&str> =
cur.iter().flat_map(|c| c.uncovered.iter()).map(|e| e.name.as_str()).collect();
let base_set: BTreeSet<&str> =
base.iter().flat_map(|c| c.uncovered.iter()).map(|e| e.name.as_str()).collect();
if cur_set != base_set {
let now_uncovered: Vec<&str> = cur_set.difference(&base_set).copied().collect();
let no_longer: Vec<&str> = base_set.difference(&cur_set).copied().collect();
v["coverageDelta"] =
serde_json::json!({ "nowUncovered": now_uncovered, "noLongerUncovered": no_longer });
}
if let Some(cur) = &cur {
v["coverage"] = serde_json::to_value(cur).unwrap_or_default();
}
}
fn attach_manifest(v: &mut serde_json::Value, cur_pre: &str, base_pre: &str) {
let cur = crate::completeness::report_completeness(cur_pre);
let base = crate::completeness::report_completeness(base_pre);
if cur.must_hedge() {
v["incomplete"] = serde_json::json!(true);
if !cur.unanalyzed.is_empty() {
v["unanalyzed"] = serde_json::json!(cur.unanalyzed);
}
if !cur.judged_nothing.is_empty() {
v["judgedNothing"] = serde_json::json!(cur.judged_nothing);
}
if !cur.no_manifest.is_empty() {
v["noManifest"] = serde_json::json!(cur.no_manifest);
}
}
if base.must_hedge() {
v["baselineIncomplete"] = serde_json::json!(true);
if !base.unanalyzed.is_empty() {
v["baselineUnanalyzed"] = serde_json::json!(base.unanalyzed);
}
if !base.judged_nothing.is_empty() {
v["baselineJudgedNothing"] = serde_json::json!(base.judged_nothing);
}
if !base.no_manifest.is_empty() {
v["baselineNoManifest"] = serde_json::json!(base.no_manifest);
}
}
}
pub(crate) fn cmd_gains(args: &[String]) -> i32 {
let mut want_json = false;
let mut strict = false;
let mut pos: Vec<String> = Vec::new();
for a in args {
match a.as_str() {
"--json" => want_json = true,
"--strict" => strict = true,
"--text" | "--human" => {}
other if other.starts_with('-') && other.len() > 1 => {
let hint = if other == "--policy" {
" — gains is a diff view; to FAIL CI on a newly-gained effect, gate at scan time with a `deny <E> gained` policy (AS-EFF-005), or use `--strict` to fail on ANY gain"
} else {
""
};
eprintln!("candor-query gains: unknown flag `{other}`{hint}\n known flags: --json, --strict");
return 2;
}
_ => pos.push(a.clone()),
}
}
let (cur_loc, base_loc) = match pos.as_slice() {
[a, b, ..] => (resolve_locator(a), resolve_locator(b)),
_ => {
eprintln!("usage: candor-query gains <current> <baseline> [--json] [--strict]");
return 2;
}
};
if matches!(pos.get(2).map(String::as_str), Some("0") | Some("1")) {
deprecation_note("a trailing `0|1` JSON sentinel");
if pos.get(2).map(String::as_str) == Some("1") {
want_json = true;
}
}
let (cur_pre, base_pre) = (cur_loc.as_str(), base_loc.as_str());
let cur = match load_fninfo_loud(cur_pre, "current") {
Ok(m) => m,
Err(c) => return c,
};
let base = match load_fninfo_loud(base_pre, "baseline") {
Ok(m) => m,
Err(c) => return c,
};
let empty = BTreeSet::new();
let mut out: Vec<(String, String)> = Vec::new();
for (func, info) in &cur {
let b = base.get(func).map(|i| &i.inferred).unwrap_or(&empty);
for e in gained_effects(&info.inferred, b) {
out.push((func.clone(), e));
}
}
out.sort();
let baseline_version = report_build_version(base_pre);
let engine_version = report_build_version(cur_pre);
if !baseline_version.is_empty() && !engine_version.is_empty() && baseline_version != engine_version {
eprintln!("candor: ⚠ baseline @{baseline_version} ≠ engine @{engine_version} — a \"gained capability\" may be the engine reclassifying, not the dependency changing; regenerate both reports with one build to compare releases.");
}
if want_json {
let (base_cg, base_cg_partial) = load_callgraph_flagged(base_pre);
let base_cg_nodes: BTreeSet<&str> = base_cg
.iter()
.flat_map(|(k, vs)| std::iter::once(k.as_str()).chain(vs.iter().map(String::as_str)))
.collect();
let cg_unusable = base_cg.is_empty() || base_cg_partial;
let origin_of = |f: &str| gain_origin(f, &base, &base_cg_nodes, cg_unusable);
let mut gained: Vec<&str> = out.iter().map(|(_, e)| e.as_str()).collect();
gained.sort_unstable();
gained.dedup();
let by_function: Vec<_> = out
.iter()
.map(|(f, e)| serde_json::json!({ "effect": e, "fn": f, "origin": origin_of(f) }))
.collect();
let mut v = serde_json::json!({
"baseline_version": baseline_version,
"byFunction": by_function,
"engine_version": engine_version,
"gained": gained,
});
attach_coverage(&mut v, load_coverage(cur_pre), load_coverage(base_pre));
attach_manifest(&mut v, cur_pre, base_pre);
println!("{}", serde_json::to_string_pretty(&v).unwrap());
return if strict && !out.is_empty() { 1 } else { 0 };
}
let gained_any = !out.is_empty();
for (func, e) in out {
println!("{func}\t{e}");
}
if strict && gained_any {
eprintln!("candor gains --strict: the surface gained new effect(s) vs the baseline → exit 1");
return 1;
}
0
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn receipt_order_is_a_permutation_of_effects() {
assert_eq!(
RECEIPT_ORDER.iter().copied().collect::<BTreeSet<_>>(),
EFFECTS.iter().copied().collect::<BTreeSet<_>>(),
"receipt RECEIPT_ORDER must be a permutation of candor_report::EFFECTS \
(a new effect was added to one array but not the other)",
);
}
#[test]
fn corrupt_report_fails_gains_and_diff_loud_not_empty() {
let dir = std::env::temp_dir().join(format!("candor-gains-loud-test-{}", std::process::id()));
let _ = std::fs::create_dir_all(&dir);
let (cur, base) = (dir.join("cur"), dir.join("base"));
let (cur_s, base_s) = (cur.to_string_lossy().into_owned(), base.to_string_lossy().into_owned());
let valid = serde_json::json!({
"candor": { "version": "b1", "toolchain": "stable", "spec": candor_report::SPEC_VERSION },
"functions": [ { "fn": "a::f", "inferred": ["Fs"], "direct": ["Fs"] } ]
});
std::fs::write(dir.join("base.demo.scan.json"), serde_json::to_string(&valid).unwrap()).unwrap();
std::fs::write(dir.join("cur.demo.scan.json"), r#"{ "candor": {}, "functions": [ { "fn": "x."#).unwrap();
let args = |j: bool| -> Vec<String> {
let mut v = vec![cur_s.clone(), base_s.clone()];
if j { v.push("--json".into()) }
v
};
assert_eq!(cmd_gains(&args(true)), 2, "gains --json over a corrupt current report must exit 2");
assert_eq!(cmd_gains(&args(false)), 2, "gains (TSV) over a corrupt current report must exit 2");
assert_eq!(cmd_diff(&args(true)), 2, "diff over a corrupt current report must exit 2");
std::fs::write(dir.join("cur.demo.scan.json"), "[1, 2, 3]").unwrap();
assert_eq!(load_fninfo_loud(&cur_s, "current").err(), Some(2), "all-junk array must fail loud");
std::fs::write(dir.join("cur.demo.scan.json"), serde_json::to_string(&valid).unwrap()).unwrap();
std::fs::write(dir.join("base.demo.scan.json"), "not json").unwrap();
assert_eq!(cmd_gains(&args(true)), 2, "gains over a corrupt baseline must exit 2");
std::fs::write(dir.join("base.demo.scan.json"), serde_json::to_string(&valid).unwrap()).unwrap();
assert_eq!(cmd_gains(&args(true)), 0, "valid reports still succeed");
let clean_empty = serde_json::json!({
"candor": { "version": "b1", "toolchain": "stable", "spec": candor_report::SPEC_VERSION },
"functions": []
});
std::fs::write(dir.join("cur.demo.scan.json"), serde_json::to_string(&clean_empty).unwrap()).unwrap();
assert!(load_fninfo_loud(&cur_s, "current").is_ok(), "a well-formed empty report is not corrupt");
let _ = std::fs::remove_dir_all(&dir);
}
#[test]
fn partial_baseline_callgraph_reads_unknown_not_new() {
let dir = std::env::temp_dir().join(format!("candor-cg-partial-test-{}", std::process::id()));
let _ = std::fs::create_dir_all(&dir);
let base = dir.join("base");
let base_s = base.to_string_lossy().into_owned();
std::fs::write(dir.join("base.a.scan.callgraph.json"), r#"{"a::caller":["a::callee"]}"#).unwrap();
std::fs::write(dir.join("base.b.scan.callgraph.json"), r#"{"b::caller": ["b::"#).unwrap();
let (cg, partial) = load_callgraph_flagged(&base_s);
assert!(partial, "a matched-but-corrupt sidecar must flag the graph PARTIAL");
assert!(cg.contains_key("a::caller"), "the surviving sidecar still merges");
let nodes: BTreeSet<&str> =
cg.iter().flat_map(|(k, vs)| std::iter::once(k.as_str()).chain(vs.iter().map(String::as_str))).collect();
let report_base: BTreeMap<String, FnInfo> = BTreeMap::new();
let unusable = cg.is_empty() || partial;
assert_eq!(gain_origin("b::caller", &report_base, &nodes, unusable), "unknown");
assert_eq!(gain_origin("a::callee", &report_base, &nodes, unusable), "existing");
std::fs::write(dir.join("base.b.scan.callgraph.json"), r#"{"b::caller":["b::callee"]}"#).unwrap();
let (cg2, partial2) = load_callgraph_flagged(&base_s);
assert!(!partial2, "two valid sidecars are not partial");
let nodes2: BTreeSet<&str> =
cg2.iter().flat_map(|(k, vs)| std::iter::once(k.as_str()).chain(vs.iter().map(String::as_str))).collect();
assert_eq!(gain_origin("never::existed", &report_base, &nodes2, cg2.is_empty()), "new");
let bare = dir.join("bare");
let (cg3, partial3) = load_callgraph_flagged(&bare.to_string_lossy());
assert!(cg3.is_empty() && !partial3, "a genuinely absent sidecar is empty, not partial");
assert_eq!(gain_origin("anything", &report_base, &BTreeSet::new(), true), "unknown");
let _ = std::fs::remove_dir_all(&dir);
}
#[test]
fn report_build_version_reads_envelope_with_meta_fallback() {
let dir = std::env::temp_dir().join(format!("candor-buildver-test-{}", std::process::id()));
let _ = std::fs::create_dir_all(&dir);
let pre = dir.join("r");
let pre_s = pre.to_string_lossy().into_owned();
let report = dir.join("r.demo.scan.json");
std::fs::write(&report, r#"{"candor":{"version":"0.9.9","toolchain":"t"},"functions":[]}"#).unwrap();
assert_eq!(report_build_version(&pre_s), "0.9.9", "the §2 envelope candor.version");
std::fs::write(&report, r#"{"meta":{"version":"0.1.1","toolchain":"t"},"functions":[]}"#).unwrap();
assert_eq!(report_build_version(&pre_s), "0.1.1", "older meta.version shape");
std::fs::write(&report, r#"{"functions":[]}"#).unwrap();
assert_eq!(report_build_version(&pre_s), "", "no version anywhere → empty string");
std::fs::write(&report, "not json").unwrap();
assert_eq!(report_build_version(&pre_s), "", "unreadable → empty string, never a guess");
let _ = std::fs::remove_dir_all(&dir);
}
#[test]
fn gains_json_coverage_block_and_delta() {
use candor_report::{Coverage, CoverageEntry};
let cov = |names: &[(&str, usize)]| {
Some(Coverage {
uncovered: names.iter().map(|(n, c)| CoverageEntry { name: n.to_string(), calls: *c }).collect(),
})
};
let base_v = || serde_json::json!({ "gained": [] });
let mut v = base_v();
attach_coverage(&mut v, cov(&[("somedep", 3)]), None);
assert_eq!(v["coverage"], serde_json::json!({ "uncovered": [{ "name": "somedep", "calls": 3 }] }));
assert_eq!(
v["coverageDelta"],
serde_json::json!({ "nowUncovered": ["somedep"], "noLongerUncovered": [] })
);
let mut v = base_v();
attach_coverage(&mut v, cov(&[("a", 1)]), cov(&[("a", 99)]));
assert_eq!(v["coverage"]["uncovered"][0]["name"], "a");
assert!(v.get("coverageDelta").is_none(), "a call-count wobble is not a delta: {v:#}");
let mut v = base_v();
attach_coverage(&mut v, cov(&[("newdep", 1)]), cov(&[("olddep", 2)]));
assert_eq!(
v["coverageDelta"],
serde_json::json!({ "nowUncovered": ["newdep"], "noLongerUncovered": ["olddep"] })
);
let mut v = base_v();
attach_coverage(&mut v, None, cov(&[("olddep", 2)]));
assert!(v.get("coverage").is_none());
assert_eq!(
v["coverageDelta"],
serde_json::json!({ "nowUncovered": [], "noLongerUncovered": ["olddep"] })
);
let mut v = base_v();
attach_coverage(&mut v, None, None);
assert_eq!(v, base_v());
}
}