344 lines
12 KiB
Rust
344 lines
12 KiB
Rust
|
//! Handler for the `coverage` command — show or refresh test coverage.
|
||
|
|
//!
|
||
|
|
//! Default (no args): reads the cached `.coverage_baseline` file and reports
|
||
|
|
//! the stored value instantly without running the test suite.
|
||
|
|
//!
|
||
|
|
//! `coverage run`: executes `script/test_coverage` to collect fresh coverage
|
||
|
|
//! data, parses the summary, and reports the result.
|
||
|
|
|
||
|
|
use super::CommandContext;
|
||
|
|
|
||
|
|
const BASELINE_FILE: &str = ".coverage_baseline";
|
||
|
|
const COVERAGE_SCRIPT: &str = "script/test_coverage";
|
||
|
|
|
||
|
|
pub(super) fn handle_coverage(ctx: &CommandContext) -> Option<String> {
|
||
|
|
let args = ctx.args.trim();
|
||
|
|
|
||
|
|
match args {
|
||
|
|
"run" => Some(run_coverage(ctx.project_root)),
|
||
|
|
"" => Some(read_cached_coverage(ctx.project_root)),
|
||
|
|
other => Some(format!(
|
||
|
|
"Usage: `coverage` (cached) or `coverage run` (fresh)\n\nUnknown argument: `{other}`"
|
||
|
|
)),
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
/// Read coverage from `.coverage_baseline` and return a formatted report.
|
||
|
|
fn read_cached_coverage(project_root: &std::path::Path) -> String {
|
||
|
|
let baseline_path = project_root.join(BASELINE_FILE);
|
||
|
|
|
||
|
|
match std::fs::read_to_string(&baseline_path) {
|
||
|
|
Ok(content) => {
|
||
|
|
let lines: Vec<&str> = content.lines().filter(|l| !l.trim().is_empty()).collect();
|
||
|
|
if lines.is_empty() {
|
||
|
|
return "**Coverage (cached)**\n\nNo baseline data found.\n\n*Run `coverage run` to collect coverage.*".to_string();
|
||
|
|
}
|
||
|
|
format_cached_coverage(&lines)
|
||
|
|
}
|
||
|
|
Err(e) if e.kind() == std::io::ErrorKind::NotFound => {
|
||
|
|
"**Coverage (cached)**\n\nNo `.coverage_baseline` file found.\n\n*Run `coverage run` to collect coverage.*".to_string()
|
||
|
|
}
|
||
|
|
Err(e) => format!("**Coverage (cached)**\n\nError reading `.coverage_baseline`: {e}"),
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
/// Format cached coverage lines for display.
|
||
|
|
///
|
||
|
|
/// The baseline file stores the last overall coverage percentage written by
|
||
|
|
/// `script/test_coverage`. It always contains one line (the overall percentage)
|
||
|
|
/// but may have been seeded manually with two lines (Rust + Frontend baselines).
|
||
|
|
fn format_cached_coverage(lines: &[&str]) -> String {
|
||
|
|
let mut out = "**Coverage (cached)**\n\n".to_string();
|
||
|
|
if lines.len() == 2 {
|
||
|
|
out.push_str(&format!("Rust: {}%\n", lines[0].trim()));
|
||
|
|
out.push_str(&format!("Frontend: {}%\n", lines[1].trim()));
|
||
|
|
} else {
|
||
|
|
out.push_str(&format!("Overall: {}%\n", lines[0].trim()));
|
||
|
|
}
|
||
|
|
out.push_str("\n*Run `coverage run` for fresh results.*");
|
||
|
|
out
|
||
|
|
}
|
||
|
|
|
||
|
|
/// Run `script/test_coverage`, parse its summary, and return a formatted report.
|
||
|
|
fn run_coverage(project_root: &std::path::Path) -> String {
|
||
|
|
let script_path = project_root.join(COVERAGE_SCRIPT);
|
||
|
|
|
||
|
|
if !script_path.exists() {
|
||
|
|
return format!(
|
||
|
|
"**Coverage**\n\nCoverage script not found: `{COVERAGE_SCRIPT}`\n\nEnsure `{COVERAGE_SCRIPT}` exists in the project root."
|
||
|
|
);
|
||
|
|
}
|
||
|
|
|
||
|
|
let output = std::process::Command::new("bash")
|
||
|
|
.arg(&script_path)
|
||
|
|
.current_dir(project_root)
|
||
|
|
.output();
|
||
|
|
|
||
|
|
match output {
|
||
|
|
Err(e) => format!("**Coverage**\n\nFailed to run coverage script: {e}"),
|
||
|
|
Ok(out) => {
|
||
|
|
let stdout = String::from_utf8_lossy(&out.stdout);
|
||
|
|
let stderr = String::from_utf8_lossy(&out.stderr);
|
||
|
|
let combined = format!("{stdout}{stderr}");
|
||
|
|
|
||
|
|
// Check if llvm-cov is missing
|
||
|
|
if combined.contains("cargo-llvm-cov not available") && !combined.contains("TOTAL") {
|
||
|
|
return format!(
|
||
|
|
"**Coverage**\n\n`cargo-llvm-cov` is not installed.\n\nInstall it with:\n```\ncargo install cargo-llvm-cov\n```"
|
||
|
|
);
|
||
|
|
}
|
||
|
|
|
||
|
|
parse_coverage_output(&combined, out.status.success())
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
/// Parse the summary block from `script/test_coverage` output and format it.
|
||
|
|
fn parse_coverage_output(output: &str, passed: bool) -> String {
|
||
|
|
let rust_cov = extract_line_value(output, "Rust line coverage:");
|
||
|
|
let frontend_cov = extract_line_value(output, "Frontend line coverage:");
|
||
|
|
let overall = extract_summary_field(output, "Overall:");
|
||
|
|
let threshold = extract_summary_field(output, "Threshold:");
|
||
|
|
|
||
|
|
let mut out = "**Coverage (fresh)**\n\n".to_string();
|
||
|
|
|
||
|
|
if let Some(r) = &rust_cov {
|
||
|
|
out.push_str(&format!("Rust: {r}\n"));
|
||
|
|
}
|
||
|
|
if let Some(f) = &frontend_cov {
|
||
|
|
out.push_str(&format!("Frontend: {f}\n"));
|
||
|
|
}
|
||
|
|
if let Some(o) = &overall {
|
||
|
|
out.push_str(&format!("Overall: {o}\n"));
|
||
|
|
}
|
||
|
|
if let Some(t) = &threshold {
|
||
|
|
out.push_str(&format!("Threshold: {t}\n"));
|
||
|
|
}
|
||
|
|
|
||
|
|
if rust_cov.is_none() && frontend_cov.is_none() && overall.is_none() {
|
||
|
|
// Could not parse — show raw output excerpt
|
||
|
|
let excerpt: String = output.lines().rev().take(10).collect::<Vec<_>>().into_iter().rev().collect::<Vec<_>>().join("\n");
|
||
|
|
return format!("**Coverage (fresh)**\n\n```\n{excerpt}\n```");
|
||
|
|
}
|
||
|
|
|
||
|
|
if passed {
|
||
|
|
out.push_str("\nPASS");
|
||
|
|
} else {
|
||
|
|
out.push_str("\nFAIL: coverage below threshold");
|
||
|
|
}
|
||
|
|
|
||
|
|
out
|
||
|
|
}
|
||
|
|
|
||
|
|
/// Extract a value from lines like `"Rust line coverage: 62.5%"`.
|
||
|
|
fn extract_line_value(output: &str, prefix: &str) -> Option<String> {
|
||
|
|
output
|
||
|
|
.lines()
|
||
|
|
.find(|l| l.trim().starts_with(prefix))
|
||
|
|
.map(|l| l.trim()[prefix.len()..].trim().to_string())
|
||
|
|
}
|
||
|
|
|
||
|
|
/// Extract a value from the summary block: `" Overall: 62.5%"`.
|
||
|
|
fn extract_summary_field(output: &str, label: &str) -> Option<String> {
|
||
|
|
output
|
||
|
|
.lines()
|
||
|
|
.find(|l| l.trim().starts_with(label))
|
||
|
|
.map(|l| l.trim()[label.len()..].trim().to_string())
|
||
|
|
}
|
||
|
|
|
||
|
|
// ---------------------------------------------------------------------------
|
||
|
|
// Tests
|
||
|
|
// ---------------------------------------------------------------------------
|
||
|
|
|
||
|
|
#[cfg(test)]
|
||
|
|
mod tests {
|
||
|
|
use super::*;
|
||
|
|
use crate::agents::AgentPool;
|
||
|
|
use std::collections::HashSet;
|
||
|
|
use std::sync::{Arc, Mutex};
|
||
|
|
|
||
|
|
fn make_ctx<'a>(
|
||
|
|
agents: &'a Arc<AgentPool>,
|
||
|
|
ambient_rooms: &'a Arc<Mutex<HashSet<String>>>,
|
||
|
|
project_root: &'a std::path::Path,
|
||
|
|
args: &'a str,
|
||
|
|
) -> super::super::CommandContext<'a> {
|
||
|
|
super::super::CommandContext {
|
||
|
|
bot_name: "Timmy",
|
||
|
|
args,
|
||
|
|
project_root,
|
||
|
|
agents,
|
||
|
|
ambient_rooms,
|
||
|
|
room_id: "!test:example.com",
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
fn test_agents() -> Arc<AgentPool> {
|
||
|
|
Arc::new(AgentPool::new_test(3000))
|
||
|
|
}
|
||
|
|
|
||
|
|
fn test_ambient() -> Arc<Mutex<HashSet<String>>> {
|
||
|
|
Arc::new(Mutex::new(HashSet::new()))
|
||
|
|
}
|
||
|
|
|
||
|
|
#[test]
|
||
|
|
fn coverage_command_is_registered() {
|
||
|
|
use super::super::commands;
|
||
|
|
let found = commands().iter().any(|c| c.name == "coverage");
|
||
|
|
assert!(found, "coverage command must be in the registry");
|
||
|
|
}
|
||
|
|
|
||
|
|
#[test]
|
||
|
|
fn coverage_command_appears_in_help() {
|
||
|
|
let result = super::super::tests::try_cmd_addressed(
|
||
|
|
"Timmy",
|
||
|
|
"@timmy:homeserver.local",
|
||
|
|
"@timmy help",
|
||
|
|
);
|
||
|
|
let output = result.unwrap();
|
||
|
|
assert!(
|
||
|
|
output.contains("coverage"),
|
||
|
|
"help should list coverage command: {output}"
|
||
|
|
);
|
||
|
|
}
|
||
|
|
|
||
|
|
#[test]
|
||
|
|
fn coverage_no_args_reads_baseline() {
|
||
|
|
let dir = tempfile::tempdir().expect("tempdir");
|
||
|
|
std::fs::write(dir.path().join(".coverage_baseline"), "72.5\n").unwrap();
|
||
|
|
|
||
|
|
let agents = test_agents();
|
||
|
|
let ambient = test_ambient();
|
||
|
|
let ctx = make_ctx(&agents, &ambient, dir.path(), "");
|
||
|
|
let output = handle_coverage(&ctx).unwrap();
|
||
|
|
|
||
|
|
assert!(
|
||
|
|
output.contains("72.5"),
|
||
|
|
"should report cached value from baseline: {output}"
|
||
|
|
);
|
||
|
|
assert!(
|
||
|
|
output.contains("cached"),
|
||
|
|
"response should indicate cached result: {output}"
|
||
|
|
);
|
||
|
|
}
|
||
|
|
|
||
|
|
#[test]
|
||
|
|
fn coverage_no_args_two_line_baseline() {
|
||
|
|
let dir = tempfile::tempdir().expect("tempdir");
|
||
|
|
std::fs::write(dir.path().join(".coverage_baseline"), "60.00\n65.21\n").unwrap();
|
||
|
|
|
||
|
|
let agents = test_agents();
|
||
|
|
let ambient = test_ambient();
|
||
|
|
let ctx = make_ctx(&agents, &ambient, dir.path(), "");
|
||
|
|
let output = handle_coverage(&ctx).unwrap();
|
||
|
|
|
||
|
|
assert!(
|
||
|
|
output.contains("60.00"),
|
||
|
|
"should report first baseline value: {output}"
|
||
|
|
);
|
||
|
|
assert!(
|
||
|
|
output.contains("65.21"),
|
||
|
|
"should report second baseline value: {output}"
|
||
|
|
);
|
||
|
|
}
|
||
|
|
|
||
|
|
#[test]
|
||
|
|
fn coverage_missing_baseline_reports_clearly() {
|
||
|
|
let dir = tempfile::tempdir().expect("tempdir");
|
||
|
|
|
||
|
|
let agents = test_agents();
|
||
|
|
let ambient = test_ambient();
|
||
|
|
let ctx = make_ctx(&agents, &ambient, dir.path(), "");
|
||
|
|
let output = handle_coverage(&ctx).unwrap();
|
||
|
|
|
||
|
|
assert!(
|
||
|
|
output.contains("No `.coverage_baseline`") || output.contains("coverage_baseline"),
|
||
|
|
"missing baseline should mention the file name: {output}"
|
||
|
|
);
|
||
|
|
}
|
||
|
|
|
||
|
|
#[test]
|
||
|
|
fn coverage_run_missing_script_reports_error() {
|
||
|
|
let dir = tempfile::tempdir().expect("tempdir");
|
||
|
|
|
||
|
|
let agents = test_agents();
|
||
|
|
let ambient = test_ambient();
|
||
|
|
let ctx = make_ctx(&agents, &ambient, dir.path(), "run");
|
||
|
|
let output = handle_coverage(&ctx).unwrap();
|
||
|
|
|
||
|
|
assert!(
|
||
|
|
output.contains("not found") || output.contains("script"),
|
||
|
|
"missing script should produce a clear error: {output}"
|
||
|
|
);
|
||
|
|
}
|
||
|
|
|
||
|
|
#[test]
|
||
|
|
fn coverage_unknown_arg_returns_usage() {
|
||
|
|
let dir = tempfile::tempdir().expect("tempdir");
|
||
|
|
let agents = test_agents();
|
||
|
|
let ambient = test_ambient();
|
||
|
|
let ctx = make_ctx(&agents, &ambient, dir.path(), "blah");
|
||
|
|
let output = handle_coverage(&ctx).unwrap();
|
||
|
|
assert!(
|
||
|
|
output.contains("Usage"),
|
||
|
|
"unknown arg should show usage: {output}"
|
||
|
|
);
|
||
|
|
}
|
||
|
|
|
||
|
|
#[test]
|
||
|
|
fn coverage_command_works_via_dispatch() {
|
||
|
|
let dir = tempfile::tempdir().expect("tempdir");
|
||
|
|
std::fs::write(dir.path().join(".coverage_baseline"), "55.0\n").unwrap();
|
||
|
|
|
||
|
|
let agents = test_agents();
|
||
|
|
let ambient = test_ambient();
|
||
|
|
let room_id = "!test:example.com".to_string();
|
||
|
|
let dispatch = super::super::CommandDispatch {
|
||
|
|
bot_name: "Timmy",
|
||
|
|
bot_user_id: "@timmy:homeserver.local",
|
||
|
|
project_root: dir.path(),
|
||
|
|
agents: &agents,
|
||
|
|
ambient_rooms: &ambient,
|
||
|
|
room_id: &room_id,
|
||
|
|
};
|
||
|
|
let result = super::super::try_handle_command(&dispatch, "@timmy coverage");
|
||
|
|
assert!(
|
||
|
|
result.is_some(),
|
||
|
|
"coverage command must respond via dispatch (not fall through to LLM)"
|
||
|
|
);
|
||
|
|
}
|
||
|
|
|
||
|
|
#[test]
|
||
|
|
fn parse_coverage_output_extracts_fields() {
|
||
|
|
let sample = "\
|
||
|
|
Rust line coverage: 62.5%\n\
|
||
|
|
Frontend line coverage: 70.0%\n\
|
||
|
|
=== Coverage Summary ===\n\
|
||
|
|
Rust: 62.5%\n\
|
||
|
|
Frontend: 70.0%\n\
|
||
|
|
Overall: 66.25%\n\
|
||
|
|
Threshold: 60.00%\n\
|
||
|
|
PASS: Coverage 66.25% meets threshold 60.00%\n\
|
||
|
|
";
|
||
|
|
let result = parse_coverage_output(sample, true);
|
||
|
|
assert!(result.contains("62.5"), "should include Rust coverage: {result}");
|
||
|
|
assert!(result.contains("70.0"), "should include Frontend coverage: {result}");
|
||
|
|
assert!(result.contains("66.25"), "should include Overall coverage: {result}");
|
||
|
|
assert!(result.contains("PASS"), "should indicate PASS: {result}");
|
||
|
|
}
|
||
|
|
|
||
|
|
#[test]
|
||
|
|
fn extract_line_value_finds_rust_coverage() {
|
||
|
|
let output = "Rust line coverage: 55.3%\n";
|
||
|
|
let val = extract_line_value(output, "Rust line coverage:");
|
||
|
|
assert_eq!(val.as_deref(), Some("55.3%"));
|
||
|
|
}
|
||
|
|
|
||
|
|
#[test]
|
||
|
|
fn extract_summary_field_finds_overall() {
|
||
|
|
let output = " Overall: 72.1%\n";
|
||
|
|
let val = extract_summary_field(output, "Overall:");
|
||
|
|
assert_eq!(val.as_deref(), Some("72.1%"));
|
||
|
|
}
|
||
|
|
}
|