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 path.canonicalize()
407 .ok()
408 .and_then(|canon| {
409 canon
410 .strip_prefix(root)
411 .ok()
412 .map(|rel| rel.to_string_lossy().replace('\\', "/"))
413 })
414 .unwrap_or_else(|| raw.replace('\\', "/"))
415}
416
417#[derive(Debug)]
418struct PolicyEvaluation {
419 workspace_line_percent: f64,
420 violations: Vec<String>,
421}
422
423fn evaluate_policy(
424 policy: &CoveragePolicy,
425 report: &CoverageReport,
426 _repo_root: &Path,
427) -> PolicyEvaluation {
428 let mut effective_line_count = 0u64;
429 let mut effective_line_covered = 0u64;
430 let mut violations = Vec::new();
431
432 for file in &report.files {
433 if policy.excluded_paths.contains(&file.rel_path) {
434 continue;
435 }
436
437 effective_line_count += file.line_count;
438 effective_line_covered += file.line_covered;
439 let expected = policy
440 .per_file_line_min
441 .get(&file.rel_path)
442 .copied()
443 .unwrap_or(policy.default_per_file_min);
444 if file.line_percent < expected {
445 violations.push(format!(
446 "{} line coverage {:.2}% is below required minimum {:.2}%",
447 file.rel_path, file.line_percent, expected
448 ));
449 }
450 }
451
452 let workspace_line_percent = if effective_line_count == 0 {
453 report.total_line_percent
454 } else {
455 (effective_line_covered as f64 / effective_line_count as f64) * 100.0
456 };
457
458 if workspace_line_percent < policy.global_line_min {
459 violations.insert(
460 0,
461 format!(
462 "workspace line coverage {:.2}% is below global minimum {:.2}%",
463 workspace_line_percent, policy.global_line_min
464 ),
465 );
466 }
467
468 PolicyEvaluation {
469 workspace_line_percent,
470 violations,
471 }
472}
473
474#[cfg(test)]
475mod tests {
476 use super::{CoveragePolicy, CoverageReport, evaluate_policy, relativize_path};
477 use std::collections::BTreeMap;
478 use std::path::Path;
479 use tempfile::tempdir;
480
481 #[test]
482 fn relativize_path_prefers_repo_relative_paths() {
483 let dir = tempdir().unwrap();
484 let file = dir.path().join("src").join("demo.rs");
485 std::fs::create_dir_all(file.parent().unwrap()).unwrap();
486 std::fs::write(&file, "fn main() {}\n").unwrap();
487
488 let rel = relativize_path(dir.path(), file.to_str().unwrap());
489 assert_eq!(rel, "src/demo.rs");
490 }
491
492 #[test]
493 fn policy_loader_supports_exclusions_and_overrides() {
494 let dir = tempdir().unwrap();
495 let path = dir.path().join("coverage-policy.json");
496 std::fs::write(
497 &path,
498 r#"{
499 "global": { "line_coverage_min": 60.0 },
500 "defaults": { "per_file_line_coverage_min": 55.0 },
501 "exclusions": { "files": [ { "path": "src/generated.rs" }, "src/wrapper.rs" ] },
502 "per_file": { "src/core.rs": { "line_coverage_min": 80.0 } }
503 }"#,
504 )
505 .unwrap();
506
507 let policy = CoveragePolicy::load(&path).unwrap();
508 assert_eq!(policy.global_line_min, 60.0);
509 assert_eq!(policy.default_per_file_min, 55.0);
510 assert!(policy.excluded_paths.contains("src/generated.rs"));
511 assert_eq!(policy.per_file_line_min["src/core.rs"], 80.0);
512 }
513
514 #[test]
515 fn report_loader_reads_llvm_cov_json_shape() {
516 let dir = tempdir().unwrap();
517 let report_path = dir.path().join("coverage.json");
518 let file = dir.path().join("src").join("demo.rs");
519 std::fs::create_dir_all(file.parent().unwrap()).unwrap();
520 std::fs::write(&file, "fn demo() {}\n").unwrap();
521
522 std::fs::write(
523 &report_path,
524 format!(
525 r#"{{
526 "data": [{{
527 "totals": {{ "lines": {{ "percent": 50.0 }} }},
528 "files": [{{
529 "filename": "{}",
530 "summary": {{ "lines": {{ "percent": 75.0, "count": 4, "covered": 3 }} }}
531 }}]
532 }}]
533 }}"#,
534 file.display()
535 ),
536 )
537 .unwrap();
538
539 let old_cwd = std::env::current_dir().unwrap();
540 std::env::set_current_dir(dir.path()).unwrap();
541 let report = CoverageReport::load(&report_path).unwrap();
542 std::env::set_current_dir(old_cwd).unwrap();
543
544 assert_eq!(report.files.len(), 1);
545 assert_eq!(report.files[0].rel_path, "src/demo.rs");
546 assert_eq!(report.files[0].line_percent, 75.0);
547 }
548
549 #[test]
550 fn evaluation_uses_excluded_files_for_neither_global_nor_per_file_checks() {
551 let report = CoverageReport {
552 total_line_percent: 10.0,
553 files: vec![
554 super::FileCoverage {
555 rel_path: "src/generated.rs".to_string(),
556 line_percent: 0.0,
557 line_count: 100,
558 line_covered: 0,
559 },
560 super::FileCoverage {
561 rel_path: "src/core.rs".to_string(),
562 line_percent: 75.0,
563 line_count: 4,
564 line_covered: 3,
565 },
566 ],
567 };
568 let policy = CoveragePolicy {
569 global_line_min: 60.0,
570 default_per_file_min: 60.0,
571 excluded_paths: ["src/generated.rs".to_string()].into_iter().collect(),
572 per_file_line_min: BTreeMap::new(),
573 };
574
575 let result = evaluate_policy(&policy, &report, Path::new("."));
576 assert!(result.violations.is_empty());
577 assert_eq!(format!("{:.2}", result.workspace_line_percent), "75.00");
578 }
579}