use std::fmt;
use serde::{Deserialize, Serialize};
use crate::Version;
use crate::model::EntityKind;
#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Serialize, Deserialize)]
#[serde(rename_all = "snake_case")]
pub enum Severity {
Error,
Warning,
}
#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
#[serde(rename_all = "snake_case")]
pub enum IssueKind {
MissingEntity,
MissingRequired,
MissingOptional,
MisplacedVolatile,
MissingVolatile,
}
#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
pub struct VerificationIssue {
pub severity: Severity,
pub kind: IssueKind,
pub entity: EntityKind,
pub row_id: Option<String>,
pub path: Option<String>,
pub introduced_in: Option<Version>,
pub message: String,
}
impl VerificationIssue {
pub fn summary(&self) -> String {
match (&self.row_id, &self.path) {
(Some(row_id), Some(path)) => {
format!(
"{} [{}/{}] {} -> {}",
self.kind_label(),
self.entity_label(),
row_id,
path,
self.message
)
}
(Some(row_id), None) => {
format!(
"{} [{}/{}] {}",
self.kind_label(),
self.entity_label(),
row_id,
self.message
)
}
_ => format!(
"{} [{}] {}",
self.kind_label(),
self.entity_label(),
self.message
),
}
}
fn kind_label(&self) -> &'static str {
match self.kind {
IssueKind::MissingEntity => "missing-entity",
IssueKind::MissingRequired => "missing-required",
IssueKind::MissingOptional => "missing-optional",
IssueKind::MisplacedVolatile => "misplaced-volatile",
IssueKind::MissingVolatile => "missing-volatile",
}
}
fn entity_label(&self) -> &'static str {
super::entity_label(self.entity)
}
}
#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
pub struct VerificationReport {
pub backend: String,
pub against_version: Version,
pub issues: Vec<VerificationIssue>,
}
impl VerificationReport {
pub fn is_complete(&self) -> bool {
self.issues.iter().all(|i| i.severity != Severity::Error)
}
pub fn counts(&self) -> (usize, usize) {
let errors = self
.issues
.iter()
.filter(|i| i.severity == Severity::Error)
.count();
(errors, self.issues.len() - errors)
}
}
impl fmt::Display for VerificationReport {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
let (errors, warnings) = self.counts();
write!(
f,
"VerificationReport({} @ {}, {} errors, {} warnings, {} issues)",
self.backend,
self.against_version,
errors,
warnings,
self.issues.len()
)
}
}
#[cfg(test)]
mod tests {
use super::*;
fn issue(kind: IssueKind, severity: Severity) -> VerificationIssue {
VerificationIssue {
severity,
kind,
entity: EntityKind::Client,
row_id: Some("c1".into()),
path: Some("native.secret".into()),
introduced_in: Some(Version::new(1, 0, 0)),
message: "boom".into(),
}
}
#[test]
fn report_counts_and_completeness() {
let report = VerificationReport {
backend: "stub".into(),
against_version: Version::new(1, 0, 0),
issues: vec![
issue(IssueKind::MissingRequired, Severity::Error),
issue(IssueKind::MissingVolatile, Severity::Warning),
],
};
assert!(!report.is_complete());
assert_eq!(report.counts(), (1, 1));
let clean = VerificationReport {
issues: vec![],
..report.clone()
};
assert!(clean.is_complete());
assert_eq!(clean.counts(), (0, 0));
}
#[test]
fn issue_summary_includes_entity_and_path() {
let s = issue(IssueKind::MissingRequired, Severity::Error).summary();
assert!(s.contains("missing-required"));
assert!(s.contains("client"));
assert!(s.contains("native.secret"));
}
}