1use anyhow::{Context, Result, bail};
2use serde_json::Value as JsonValue;
3use std::collections::{BTreeMap, BTreeSet};
4use std::fs;
5use std::path::{Path, PathBuf};
6use std::process::{Command, Stdio};
7
8use crate::cli::CoverageArgs;
9
10const SUCCESS_EXIT_CODE: i32 = 0;
11const POLICY_MISSING_EXIT_CODE: i32 = 2;
12const SETUP_FAILURE_EXIT_CODE: i32 = 3;
13const RUN_FAILURE_EXIT_CODE: i32 = 4;
14const POLICY_FAILURE_EXIT_CODE: i32 = 5;
15
16pub fn run(args: CoverageArgs) -> Result<()> {
17 let exit_code = run_inner(args)?;
18 if exit_code == SUCCESS_EXIT_CODE {
19 return Ok(());
20 }
21 std::process::exit(exit_code);
22}
23
24fn run_inner(args: CoverageArgs) -> Result<i32> {
25 let policy_file = PathBuf::from(
26 std::env::var("COVERAGE_POLICY_FILE")
27 .unwrap_or_else(|_| "coverage-policy.json".to_string()),
28 );
29 let report_dir = PathBuf::from(
30 std::env::var("COVERAGE_REPORT_DIR").unwrap_or_else(|_| "target/coverage".to_string()),
31 );
32 let report_file = PathBuf::from(
33 std::env::var("COVERAGE_REPORT_FILE")
34 .unwrap_or_else(|_| report_dir.join("coverage.json").display().to_string()),
35 );
36 let offline = env_true("CARGO_NET_OFFLINE");
37
38 if !policy_file.is_file() {
39 print_policy_missing_instructions(&policy_file);
40 return Ok(POLICY_MISSING_EXIT_CODE);
41 }
42
43 log("ensuring coverage tools are installed");
44 if !args.skip_run {
45 if let Err(err) = ensure_tool("cargo-llvm-cov", "cargo-llvm-cov", offline) {
46 eprintln!("[coverage] {err}");
47 return Ok(SETUP_FAILURE_EXIT_CODE);
48 }
49 if let Err(err) = ensure_tool("cargo-nextest", "cargo-nextest", offline) {
50 eprintln!("[coverage] {err}");
51 return Ok(SETUP_FAILURE_EXIT_CODE);
52 }
53 if let Err(err) = ensure_llvm_tools(offline) {
54 eprintln!("[coverage] {err}");
55 return Ok(SETUP_FAILURE_EXIT_CODE);
56 }
57 }
58
59 fs::create_dir_all(&report_dir)
60 .with_context(|| format!("failed to create {}", report_dir.display()))?;
61
62 if args.skip_run {
63 log(&format!(
64 "skipping coverage run and reusing {}",
65 report_file.display()
66 ));
67 } else {
68 log("running cargo llvm-cov nextest");
69 let status = Command::new("cargo")
70 .args([
71 "llvm-cov",
72 "nextest",
73 "--ignore-run-fail",
74 "--json",
75 "--output-path",
76 ])
77 .arg(&report_file)
78 .args(["--workspace", "--all-features"])
79 .stdin(Stdio::inherit())
80 .stdout(Stdio::inherit())
81 .stderr(Stdio::inherit())
82 .status()
83 .context("failed to execute cargo llvm-cov nextest")?;
84 if !status.success() {
85 eprintln!("[coverage] coverage command failed before policy evaluation");
86 return Ok(RUN_FAILURE_EXIT_CODE);
87 }
88 }
89
90 if !report_file.is_file() {
91 eprintln!(
92 "[coverage] expected coverage report missing: {}",
93 report_file.display()
94 );
95 return Ok(RUN_FAILURE_EXIT_CODE);
96 }
97
98 log(&format!("evaluating policy from {}", policy_file.display()));
99 let policy = CoveragePolicy::load(&policy_file)?;
100 let report = CoverageReport::load(&report_file)?;
101 let result = evaluate_policy(&policy, &report, &std::env::current_dir()?);
102 if !result.violations.is_empty() {
103 println!("[coverage] policy check failed");
104 println!("[coverage] Codex instructions:");
105 println!(
106 "Increase test coverage for the files below or update the exclusion list only for generated code, tooling entrypoints, or thin wiring layers."
107 );
108 println!(
109 "Do not lower thresholds to make the report pass unless the team intentionally changes the policy."
110 );
111 println!("[coverage] violations:");
112 for violation in result.violations {
113 println!("- {violation}");
114 }
115 return Ok(POLICY_FAILURE_EXIT_CODE);
116 }
117
118 println!("[coverage] policy check passed");
119 println!(
120 "[coverage] workspace line coverage: {:.2}%",
121 result.workspace_line_percent
122 );
123 log("success");
124 log(&format!("report written to {}", report_file.display()));
125 Ok(SUCCESS_EXIT_CODE)
126}
127
128fn log(message: &str) {
129 println!("[coverage] {message}");
130}
131
132fn print_policy_missing_instructions(policy_file: &Path) {
133 println!("[coverage] missing policy file: {}", policy_file.display());
134 println!("[coverage] Codex instructions:");
135 println!("Create coverage-policy.json at the repository root with:");
136 println!("- a global line coverage minimum");
137 println!("- a default per-file line coverage minimum");
138 println!("- an explicit exclusion list for generated code or thin entrypoints");
139 println!("- per-file overrides for high-risk modules that need stricter targets");
140 println!("Suggested starting point:");
141 println!("{{");
142 println!(" \"version\": 1,");
143 println!(" \"global\": {{ \"line_coverage_min\": 60.0 }},");
144 println!(" \"defaults\": {{ \"per_file_line_coverage_min\": 60.0 }},");
145 println!(" \"exclusions\": {{ \"files\": [] }},");
146 println!(" \"per_file\": {{}}");
147 println!("}}");
148}
149
150fn env_true(name: &str) -> bool {
151 std::env::var(name)
152 .ok()
153 .map(|value| value == "1" || value.eq_ignore_ascii_case("true"))
154 .unwrap_or(false)
155}
156
157fn command_exists(name: &str) -> bool {
158 which::which(name).is_ok()
159}
160
161fn cargo_args_for_network(offline: bool) -> Vec<&'static str> {
162 if offline {
163 Vec::new()
164 } else {
165 vec!["--locked"]
166 }
167}
168
169fn ensure_binstall(offline: bool) -> Result<()> {
170 if command_exists("cargo-binstall") {
171 return Ok(());
172 }
173 if offline {
174 bail!("cargo-binstall is required but offline mode is enabled");
175 }
176
177 log("installing cargo-binstall");
178 let mut args = vec!["install", "cargo-binstall"];
179 args.extend(cargo_args_for_network(offline));
180 let status = Command::new("cargo")
181 .args(&args)
182 .stdin(Stdio::inherit())
183 .stdout(Stdio::inherit())
184 .stderr(Stdio::inherit())
185 .status()
186 .context("failed to install cargo-binstall")?;
187 if !status.success() {
188 bail!("failed to install cargo-binstall");
189 }
190 Ok(())
191}
192
193fn ensure_tool(bin: &str, package: &str, offline: bool) -> Result<()> {
194 if command_exists(bin) {
195 return Ok(());
196 }
197 ensure_binstall(offline)?;
198 if offline {
199 bail!("missing {package} but offline mode is enabled");
200 }
201
202 log(&format!("installing {package}"));
203 let mut command = Command::new("cargo");
204 command.arg("binstall");
205 command.args(cargo_args_for_network(offline));
206 command.args(["-y", package]);
207 let status = command
208 .stdin(Stdio::inherit())
209 .stdout(Stdio::inherit())
210 .stderr(Stdio::inherit())
211 .status()
212 .with_context(|| format!("failed to install {package}"))?;
213 if !status.success() {
214 bail!("failed to install {package}");
215 }
216 Ok(())
217}
218
219fn ensure_llvm_tools(offline: bool) -> Result<()> {
220 if !command_exists("rustup") {
221 bail!("rustup is required to add llvm-tools-preview");
222 }
223
224 let output = Command::new("rustup")
225 .args(["component", "list", "--installed"])
226 .stdout(Stdio::piped())
227 .stderr(Stdio::inherit())
228 .output()
229 .context("failed to inspect rustup components")?;
230 let stdout = String::from_utf8(output.stdout).context("rustup output was not valid UTF-8")?;
231 if stdout
232 .lines()
233 .any(|line| line.trim() == "llvm-tools-preview")
234 {
235 return Ok(());
236 }
237
238 if offline {
239 bail!("llvm-tools-preview is missing and offline mode is enabled");
240 }
241
242 log("installing llvm-tools-preview");
243 let status = Command::new("rustup")
244 .args(["component", "add", "llvm-tools-preview"])
245 .stdin(Stdio::inherit())
246 .stdout(Stdio::inherit())
247 .stderr(Stdio::inherit())
248 .status()
249 .context("failed to install llvm-tools-preview")?;
250 if !status.success() {
251 bail!("failed to install llvm-tools-preview");
252 }
253 Ok(())
254}
255
256#[derive(Debug)]
257struct CoveragePolicy {
258 global_line_min: f64,
259 default_per_file_min: f64,
260 excluded_paths: BTreeSet<String>,
261 per_file_line_min: BTreeMap<String, f64>,
262}
263
264impl CoveragePolicy {
265 fn load(path: &Path) -> Result<Self> {
266 let raw = fs::read_to_string(path)
267 .with_context(|| format!("failed to read {}", path.display()))?;
268 let json: JsonValue = serde_json::from_str(&raw)
269 .with_context(|| format!("failed to parse {}", path.display()))?;
270 let global_line_min = json
271 .get("global")
272 .and_then(|v| v.get("line_coverage_min"))
273 .and_then(JsonValue::as_f64)
274 .unwrap_or(0.0);
275 let default_per_file_min = json
276 .get("defaults")
277 .and_then(|v| v.get("per_file_line_coverage_min"))
278 .and_then(JsonValue::as_f64)
279 .unwrap_or(global_line_min);
280
281 let mut excluded_paths = BTreeSet::new();
282 if let Some(files) = json
283 .get("exclusions")
284 .and_then(|v| v.get("files"))
285 .and_then(JsonValue::as_array)
286 {
287 for entry in files {
288 match entry {
289 JsonValue::String(path) => {
290 excluded_paths.insert(path.clone());
291 }
292 JsonValue::Object(map) => {
293 if let Some(path) = map.get("path").and_then(JsonValue::as_str) {
294 excluded_paths.insert(path.to_string());
295 }
296 }
297 _ => {}
298 }
299 }
300 }
301
302 let mut per_file_line_min = BTreeMap::new();
303 if let Some(per_file) = json.get("per_file").and_then(JsonValue::as_object) {
304 for (path, cfg) in per_file {
305 if let Some(min) = cfg.get("line_coverage_min").and_then(JsonValue::as_f64) {
306 per_file_line_min.insert(path.clone(), min);
307 }
308 }
309 }
310
311 Ok(Self {
312 global_line_min,
313 default_per_file_min,
314 excluded_paths,
315 per_file_line_min,
316 })
317 }
318}
319
320#[derive(Debug)]
321struct CoverageReport {
322 files: Vec<FileCoverage>,
323 total_line_percent: f64,
324}
325
326#[derive(Debug)]
327struct FileCoverage {
328 rel_path: String,
329 line_percent: f64,
330 line_count: u64,
331 line_covered: u64,
332}
333
334impl CoverageReport {
335 fn load(path: &Path) -> Result<Self> {
336 let raw = fs::read_to_string(path)
337 .with_context(|| format!("failed to read {}", path.display()))?;
338 let json: JsonValue = serde_json::from_str(&raw)
339 .with_context(|| format!("failed to parse {}", path.display()))?;
340
341 let root = std::env::current_dir()?;
342 let data0 = json
343 .get("data")
344 .and_then(JsonValue::as_array)
345 .and_then(|arr| arr.first())
346 .cloned()
347 .unwrap_or_else(|| json.clone());
348
349 let total_line_percent = data0
350 .get("totals")
351 .and_then(|v| v.get("lines"))
352 .and_then(|v| v.get("percent"))
353 .and_then(JsonValue::as_f64)
354 .or_else(|| {
355 json.get("totals")
356 .and_then(|v| v.get("lines"))
357 .and_then(|v| v.get("percent"))
358 .and_then(JsonValue::as_f64)
359 })
360 .unwrap_or(0.0);
361
362 let files_json = data0
363 .get("files")
364 .and_then(JsonValue::as_array)
365 .or_else(|| json.get("files").and_then(JsonValue::as_array))
366 .cloned()
367 .unwrap_or_default();
368
369 let mut files = Vec::new();
370 for file in files_json {
371 let Some(filename) = file.get("filename").and_then(JsonValue::as_str) else {
372 continue;
373 };
374 let rel_path = relativize_path(&root, filename);
375 let line_summary = file
376 .get("summary")
377 .and_then(|v| v.get("lines"))
378 .cloned()
379 .unwrap_or(JsonValue::Null);
380 files.push(FileCoverage {
381 rel_path,
382 line_percent: line_summary
383 .get("percent")
384 .and_then(JsonValue::as_f64)
385 .unwrap_or(0.0),
386 line_count: line_summary
387 .get("count")
388 .and_then(JsonValue::as_u64)
389 .unwrap_or(0),
390 line_covered: line_summary
391 .get("covered")
392 .and_then(JsonValue::as_u64)
393 .unwrap_or(0),
394 });
395 }
396
397 Ok(Self {
398 files,
399 total_line_percent,
400 })
401 }
402}
403
404fn relativize_path(root: &Path, raw: &str) -> String {
405 let path = PathBuf::from(raw);
406 let canonical_root = root.canonicalize().ok();
407 path.canonicalize()
408 .ok()
409 .and_then(|canon| {
410 let root = canonical_root.as_deref().unwrap_or(root);
411 canon
412 .strip_prefix(root)
413 .ok()
414 .map(|rel| rel.to_string_lossy().replace('\\', "/"))
415 })
416 .unwrap_or_else(|| raw.replace('\\', "/"))
417}
418
419#[derive(Debug)]
420struct PolicyEvaluation {
421 workspace_line_percent: f64,
422 violations: Vec<String>,
423}
424
425fn evaluate_policy(
426 policy: &CoveragePolicy,
427 report: &CoverageReport,
428 _repo_root: &Path,
429) -> PolicyEvaluation {
430 let mut effective_line_count = 0u64;
431 let mut effective_line_covered = 0u64;
432 let mut violations = Vec::new();
433
434 for file in &report.files {
435 if policy.excluded_paths.contains(&file.rel_path) {
436 continue;
437 }
438
439 effective_line_count += file.line_count;
440 effective_line_covered += file.line_covered;
441 let expected = policy
442 .per_file_line_min
443 .get(&file.rel_path)
444 .copied()
445 .unwrap_or(policy.default_per_file_min);
446 if file.line_percent < expected {
447 violations.push(format!(
448 "{} line coverage {:.2}% is below required minimum {:.2}%",
449 file.rel_path, file.line_percent, expected
450 ));
451 }
452 }
453
454 let workspace_line_percent = if effective_line_count == 0 {
455 report.total_line_percent
456 } else {
457 (effective_line_covered as f64 / effective_line_count as f64) * 100.0
458 };
459
460 if workspace_line_percent < policy.global_line_min {
461 violations.insert(
462 0,
463 format!(
464 "workspace line coverage {:.2}% is below global minimum {:.2}%",
465 workspace_line_percent, policy.global_line_min
466 ),
467 );
468 }
469
470 PolicyEvaluation {
471 workspace_line_percent,
472 violations,
473 }
474}
475
476#[cfg(test)]
477mod tests {
478 use super::{CoveragePolicy, CoverageReport, evaluate_policy, relativize_path};
479 use std::collections::BTreeMap;
480 use std::path::Path;
481 use tempfile::tempdir;
482
483 #[test]
484 fn relativize_path_prefers_repo_relative_paths() {
485 let dir = tempdir().unwrap();
486 let file = dir.path().join("src").join("demo.rs");
487 std::fs::create_dir_all(file.parent().unwrap()).unwrap();
488 std::fs::write(&file, "fn main() {}\n").unwrap();
489
490 let rel = relativize_path(dir.path(), file.to_str().unwrap());
491 assert_eq!(rel, "src/demo.rs");
492 }
493
494 #[test]
495 fn policy_loader_supports_exclusions_and_overrides() {
496 let dir = tempdir().unwrap();
497 let path = dir.path().join("coverage-policy.json");
498 std::fs::write(
499 &path,
500 r#"{
501 "global": { "line_coverage_min": 60.0 },
502 "defaults": { "per_file_line_coverage_min": 55.0 },
503 "exclusions": { "files": [ { "path": "src/generated.rs" }, "src/wrapper.rs" ] },
504 "per_file": { "src/core.rs": { "line_coverage_min": 80.0 } }
505 }"#,
506 )
507 .unwrap();
508
509 let policy = CoveragePolicy::load(&path).unwrap();
510 assert_eq!(policy.global_line_min, 60.0);
511 assert_eq!(policy.default_per_file_min, 55.0);
512 assert!(policy.excluded_paths.contains("src/generated.rs"));
513 assert_eq!(policy.per_file_line_min["src/core.rs"], 80.0);
514 }
515
516 #[test]
517 fn report_loader_reads_llvm_cov_json_shape() {
518 let dir = tempdir().unwrap();
519 let report_path = dir.path().join("coverage.json");
520 let file = dir.path().join("src").join("demo.rs");
521 std::fs::create_dir_all(file.parent().unwrap()).unwrap();
522 std::fs::write(&file, "fn demo() {}\n").unwrap();
523
524 std::fs::write(
525 &report_path,
526 format!(
527 r#"{{
528 "data": [{{
529 "totals": {{ "lines": {{ "percent": 50.0 }} }},
530 "files": [{{
531 "filename": "{}",
532 "summary": {{ "lines": {{ "percent": 75.0, "count": 4, "covered": 3 }} }}
533 }}]
534 }}]
535 }}"#,
536 file.display()
537 ),
538 )
539 .unwrap();
540
541 let old_cwd = std::env::current_dir().unwrap();
542 std::env::set_current_dir(dir.path()).unwrap();
543 let report = CoverageReport::load(&report_path).unwrap();
544 std::env::set_current_dir(old_cwd).unwrap();
545
546 assert_eq!(report.files.len(), 1);
547 assert_eq!(report.files[0].rel_path, "src/demo.rs");
548 assert_eq!(report.files[0].line_percent, 75.0);
549 }
550
551 #[test]
552 fn evaluation_uses_excluded_files_for_neither_global_nor_per_file_checks() {
553 let report = CoverageReport {
554 total_line_percent: 10.0,
555 files: vec![
556 super::FileCoverage {
557 rel_path: "src/generated.rs".to_string(),
558 line_percent: 0.0,
559 line_count: 100,
560 line_covered: 0,
561 },
562 super::FileCoverage {
563 rel_path: "src/core.rs".to_string(),
564 line_percent: 75.0,
565 line_count: 4,
566 line_covered: 3,
567 },
568 ],
569 };
570 let policy = CoveragePolicy {
571 global_line_min: 60.0,
572 default_per_file_min: 60.0,
573 excluded_paths: ["src/generated.rs".to_string()].into_iter().collect(),
574 per_file_line_min: BTreeMap::new(),
575 };
576
577 let result = evaluate_policy(&policy, &report, Path::new("."));
578 assert!(result.violations.is_empty());
579 assert_eq!(format!("{:.2}", result.workspace_line_percent), "75.00");
580 }
581}