use crate::types::{Proof, TaskId};
pub trait Verifier {
fn verify(&self, proof: &Proof) -> VerifyResult;
}
#[derive(Debug, Clone, PartialEq, Eq)]
pub enum VerifyResult {
Verified { message: String },
Decayed { reason: String },
Unverifiable { reason: String },
}
pub struct NoopVerifier;
impl Verifier for NoopVerifier {
fn verify(&self, _: &Proof) -> VerifyResult {
VerifyResult::Unverifiable {
reason: "no verifier configured".to_string(),
}
}
}
#[derive(Debug, Clone, PartialEq, Eq)]
pub struct VerifyEntry {
pub task_id: TaskId,
pub result: VerifyResult,
}
#[derive(Debug, Clone, PartialEq, Eq)]
pub struct VerifyReport {
pub plan: String,
pub results: Vec<VerifyEntry>,
}
impl VerifyReport {
pub fn verified_count(&self) -> usize {
self.results
.iter()
.filter(|r| matches!(r.result, VerifyResult::Verified { .. }))
.count()
}
pub fn decayed_count(&self) -> usize {
self.results
.iter()
.filter(|r| matches!(r.result, VerifyResult::Decayed { .. }))
.count()
}
pub fn unverifiable_count(&self) -> usize {
self.results
.iter()
.filter(|r| matches!(r.result, VerifyResult::Unverifiable { .. }))
.count()
}
pub fn all_strongly_verified(&self) -> bool {
!self.results.is_empty()
&& self
.results
.iter()
.all(|r| matches!(r.result, VerifyResult::Verified { .. }))
}
pub fn has_unverifiable(&self) -> bool {
self.results
.iter()
.any(|r| matches!(r.result, VerifyResult::Unverifiable { .. }))
}
pub fn summary(&self) -> String {
let verified = self.verified_count();
let decayed = self.decayed_count();
let unverifiable = self.unverifiable_count();
format!(
"{verified} verified (mechanically checked); {decayed} decayed (proof no longer holds); {unverifiable} unverifiable (text proof — human attestation, not mechanically checked; do NOT treat as success)."
)
}
}
#[cfg(test)]
mod tests {
use super::*;
use crate::types::{Proof, ProofKind};
#[test]
fn noop_verifier_returns_unverifiable() {
let v = NoopVerifier;
let p = Proof::commit("abc");
assert!(matches!(v.verify(&p), VerifyResult::Unverifiable { .. }));
}
#[test]
fn report_counts() {
let report = VerifyReport {
plan: "p".to_string(),
results: vec![
VerifyEntry {
task_id: TaskId::new(1),
result: VerifyResult::Verified {
message: "ok".into(),
},
},
VerifyEntry {
task_id: TaskId::new(2),
result: VerifyResult::Decayed {
reason: "file deleted".into(),
},
},
VerifyEntry {
task_id: TaskId::new(3),
result: VerifyResult::Unverifiable {
reason: "text".into(),
},
},
],
};
assert_eq!(report.verified_count(), 1);
assert_eq!(report.decayed_count(), 1);
assert_eq!(report.unverifiable_count(), 1);
assert!(!report.all_strongly_verified());
assert!(report.has_unverifiable());
}
#[test]
fn summary_distinguishes_three_categories() {
let report = VerifyReport {
plan: "p".to_string(),
results: vec![
VerifyEntry {
task_id: TaskId::new(1),
result: VerifyResult::Verified {
message: "ok".into(),
},
},
VerifyEntry {
task_id: TaskId::new(2),
result: VerifyResult::Verified {
message: "ok".into(),
},
},
VerifyEntry {
task_id: TaskId::new(3),
result: VerifyResult::Decayed {
reason: "file missing".into(),
},
},
VerifyEntry {
task_id: TaskId::new(4),
result: VerifyResult::Unverifiable {
reason: "text".into(),
},
},
],
};
let s = report.summary();
assert!(s.contains("verified"), "summary: {s}");
assert!(s.contains("decayed"), "summary: {s}");
assert!(s.contains("unverifiable"), "summary: {s}");
assert!(
s.contains('2'),
"summary should mention the 2 verified: {s}"
);
assert!(
s.to_lowercase().contains("not")
&& (s.to_lowercase().contains("success")
|| s.to_lowercase().contains("mechanically checked")),
"summary should flag unverifiable is not safe to treat as success: {s}"
);
}
#[test]
fn all_strongly_verified_rejects_unverifiable() {
let report = VerifyReport {
plan: "p".to_string(),
results: vec![
VerifyEntry {
task_id: TaskId::new(1),
result: VerifyResult::Verified {
message: "ok".into(),
},
},
VerifyEntry {
task_id: TaskId::new(2),
result: VerifyResult::Unverifiable {
reason: "text".into(),
},
},
],
};
assert!(!report.all_strongly_verified());
assert!(report.has_unverifiable());
}
#[allow(dead_code)]
fn _touch_kinds() -> ProofKind {
ProofKind::Text
}
}