#![allow(dead_code)]
use std::collections::BTreeSet;
use std::time::{SystemTime, UNIX_EPOCH};
use engenho_diff::{
DiffTarget, Divergence, EngenhoTarget, HttpMethod, K3sTarget, Normalizer, Operation,
OracleKubeconfig, Severity, Verdict, cotejo,
};
#[must_use]
pub fn oracle_kubeconfig() -> OracleKubeconfig {
OracleKubeconfig::from_env().unwrap_or_else(|e| panic!("{e}"))
}
#[must_use]
pub fn unique_suffix() -> String {
SystemTime::now()
.duration_since(UNIX_EPOCH)
.unwrap()
.as_nanos()
.to_string()
}
pub struct OpFindings {
pub op_id: String,
pub hard: Vec<Divergence>,
pub cosmetic: Vec<Divergence>,
}
pub async fn boot_engenho(kinds: &[&str]) -> EngenhoTarget {
EngenhoTarget::boot_in_process(kinds)
.await
.expect("engenho boots in-process")
}
pub async fn load_oracle() -> K3sTarget {
let kubeconfig = oracle_kubeconfig();
let k3s = K3sTarget::from_kubeconfig(kubeconfig.path())
.unwrap_or_else(|e| panic!("cannot load oracle kubeconfig {kubeconfig}: {e}"));
if let Some(Verdict::ReferenceUnreachable) = k3s.preflight().await {
panic!("{}", kubeconfig.unreachable());
}
k3s
}
pub async fn run_one(
op: &Operation,
engenho: &EngenhoTarget,
k3s: &K3sTarget,
norm: &Normalizer,
) -> OpFindings {
let (hard, cosmetic) = cotejo::run_strict(op, engenho, k3s, norm)
.await
.unwrap_or_else(|e| panic!("op {} failed: {e}", op.id));
OpFindings {
op_id: op.id.clone(),
hard,
cosmetic,
}
}
pub async fn exec_only(op: &Operation, engenho: &EngenhoTarget, k3s: &K3sTarget) {
let body = op.body_bytes();
for t in [engenho as &dyn DiffTarget, k3s as &dyn DiffTarget] {
let _ = t
.raw(
op.method,
&op.path,
body.as_deref(),
op.content_type.as_deref(),
)
.await;
}
}
pub async fn cleanup(k3s: &K3sTarget, path: &str) {
let _ = k3s.raw(HttpMethod::Delete, path, None, None).await;
}
pub fn print_report(title: &str, findings: &[OpFindings]) {
eprintln!("\n════════════ engenho-diff {title}: engenho vs k3s v1.34 ════════════");
let mut total_hard = 0usize;
let mut total_cosmetic = 0usize;
for f in findings {
let verdict = if f.hard.is_empty() {
"PARITY"
} else {
"DIVERGENT"
};
eprintln!("\n▶ {} — {verdict}", f.op_id);
for d in &f.hard {
eprintln!(" {d} [owner: {}]", d.owning_crate());
total_hard += 1;
}
for d in &f.cosmetic {
debug_assert_eq!(d.severity(), Severity::Cosmetic);
eprintln!(" (masked) {d}");
total_cosmetic += 1;
}
}
eprintln!(
"\n──────────── {total_hard} hard divergence(s), {total_cosmetic} cosmetic (masked) ────────────\n"
);
}
pub fn assert_ratchet(findings: &[OpFindings], known: &[&str]) -> BTreeSet<String> {
let observed: BTreeSet<String> = findings
.iter()
.flat_map(|f| f.hard.iter())
.map(Divergence::signature)
.collect();
let known_set: BTreeSet<String> = known.iter().map(|s| (*s).to_string()).collect();
let new: Vec<&String> = observed.difference(&known_set).collect();
let stale: Vec<&String> = known_set.difference(&observed).collect();
assert!(
new.is_empty(),
"NEW hard divergences not in the baseline (a regression, or a gap to \
record):\n {}\n\nFull observed hard baseline (copy in if intended):\n{}",
join_lines(&new, "\n "),
observed
.iter()
.map(|s| {
let mut line = String::from(" \"");
line.push_str(s);
line.push_str("\",");
line
})
.collect::<Vec<_>>()
.join("\n")
);
assert!(
stale.is_empty(),
"STALE baseline entries that NO LONGER diverge (the ratchet must SHRINK \
— remove these from the baseline):\n {}",
join_lines(&stale, "\n ")
);
observed
}
fn join_lines(items: &[&String], sep: &str) -> String {
items
.iter()
.map(|s| s.as_str())
.collect::<Vec<_>>()
.join(sep)
}