tegwick
72c594ee49
The gates existed; CI ran half of them and tolerated the failure case. - cb-sim no longer has a "tolerable" non-zero exit. An unregistered game prefix is a failure, and a run in which nothing executed is a failure. Previously CI carried `|| test $? -eq 2`, so renaming a scenario prefix would have skipped every scenario while the pipeline stayed green. Verified with a negative control. - CI now runs make coverage (AM-1) and make dep-weight (AM-4), both added after CI was written and neither enforced until now. - dep-weight enforces its targets instead of only reporting them. - CI lints the shipped-runtime configuration separately, so the feature split cannot rot unnoticed. - Dropped the stale `make deps` target, which still measured the retired crate-count metric. The positive-control rule is now executable: CI runs `cargo bench -- --test`, which executes every benchmark once, so a workload that stalls fails the build. That step immediately found a fourth instance of the error class it was written for. The committed replay benchmark was the broken version — an earlier patch never applied, leaving a command sequence that omits Resolve, so every round produced nothing and the log-building loop spun forever. It had never run to completion; the reported AM-7 replay numbers came from a probe test instead. Fixed, given the same positive control as the round loop, and re-measured from the benchmark: 100k events fold in 2.18ms (95% CI 2.14-2.23), against a 5s budget. Evidence now reports confidence intervals rather than point estimates, so the 3% regression rule in MetricsAndScenarios is enforceable. The finding worth carrying: writing the positive-control rule into InnerLoop v1.0 did not prevent the next instance. Making it a CI step did. Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
88 lines
2.9 KiB
Rust
88 lines
2.9 KiB
Rust
//! cb-sim — scenario runner binary (GameKernel K17; precursor of `cb sim`).
|
|
//! Parses scenario files, dispatches each to its game by the `<game>/`
|
|
//! prefix of its `scenario` field, and executes it. Exit codes: 0 all
|
|
//! passed, 1 any failure — including a scenario whose game prefix is not
|
|
//! registered, and a run in which nothing executed. There is deliberately
|
|
//! no "tolerable" non-zero exit: a silent skip is the failure mode this
|
|
//! binary exists to catch.
|
|
|
|
use cb_game_runtime::{scenario, RunOutcome, ScenarioFile};
|
|
use games_ground::GroundState;
|
|
|
|
fn main() {
|
|
let args: Vec<String> = std::env::args().skip(1).collect();
|
|
if args.is_empty() {
|
|
eprintln!("usage: cb-sim <scenario.yaml>...");
|
|
std::process::exit(64);
|
|
}
|
|
|
|
let mut failed = false;
|
|
let mut passed = 0usize;
|
|
let mut covered: Vec<String> = Vec::new();
|
|
|
|
for path in &args {
|
|
let text = match std::fs::read_to_string(path) {
|
|
Ok(t) => t,
|
|
Err(e) => {
|
|
eprintln!("{path}: read error: {e}");
|
|
failed = true;
|
|
continue;
|
|
}
|
|
};
|
|
let sc = match ScenarioFile::from_yaml(&text) {
|
|
Err(e) => {
|
|
eprintln!("{path}: parse error: {e}");
|
|
failed = true;
|
|
continue;
|
|
}
|
|
Ok(sc) => sc,
|
|
};
|
|
|
|
let outcome = match sc.scenario.split('/').next() {
|
|
Some("ground") => scenario::run::<GroundState>(&sc),
|
|
_ => {
|
|
// A renamed or typo'd prefix would otherwise skip every
|
|
// scenario while the run still looked clean.
|
|
eprintln!(
|
|
"FAIL {} — no game registered for prefix {:?}",
|
|
sc.scenario,
|
|
sc.scenario.split('/').next().unwrap_or("")
|
|
);
|
|
failed = true;
|
|
continue;
|
|
}
|
|
};
|
|
|
|
match outcome {
|
|
RunOutcome::Passed { covers } => {
|
|
println!(
|
|
"PASS {} covers={}{}",
|
|
sc.scenario,
|
|
covers.join(","),
|
|
if sc.provisional { " provisional" } else { "" }
|
|
);
|
|
covered.extend(covers);
|
|
passed += 1;
|
|
}
|
|
RunOutcome::Failed { reason } => {
|
|
println!("FAIL {} — {reason}", sc.scenario);
|
|
failed = true;
|
|
}
|
|
}
|
|
}
|
|
|
|
covered.sort();
|
|
covered.dedup();
|
|
println!("{passed} passed, {} rules covered", covered.len());
|
|
|
|
// Positive control: a run that executed nothing must not pass. This
|
|
// is the same class of error as a benchmark timing rejected work.
|
|
if passed == 0 {
|
|
eprintln!("FAIL — no scenario executed; refusing to report success");
|
|
failed = true;
|
|
}
|
|
|
|
if failed {
|
|
std::process::exit(1);
|
|
}
|
|
}
|