automapper_validation/validator/
report.rs

1//! Validation report aggregating all issues from a validation run.
2
3use serde::{Deserialize, Serialize};
4
5use super::issue::{Severity, ValidationCategory, ValidationIssue};
6use super::level::ValidationLevel;
7
8/// Complete validation report for an EDIFACT message.
9///
10/// Contains all issues found during validation, with convenience methods
11/// for filtering by severity and checking overall validity.
12#[derive(Debug, Clone, Serialize, Deserialize)]
13pub struct ValidationReport {
14    /// The detected EDIFACT message type (e.g., "UTILMD", "ORDERS").
15    pub message_type: String,
16
17    /// The detected Pruefidentifikator (e.g., "11001", "55001").
18    pub pruefidentifikator: Option<String>,
19
20    /// The detected format version (e.g., "FV2510").
21    pub format_version: Option<String>,
22
23    /// The validation level that was used.
24    pub level: ValidationLevel,
25
26    /// All validation issues found.
27    pub issues: Vec<ValidationIssue>,
28}
29
30impl ValidationReport {
31    /// Create a new empty validation report.
32    pub fn new(message_type: impl Into<String>, level: ValidationLevel) -> Self {
33        Self {
34            message_type: message_type.into(),
35            pruefidentifikator: None,
36            format_version: None,
37            level,
38            issues: Vec::new(),
39        }
40    }
41
42    /// Builder: set the Pruefidentifikator.
43    pub fn with_pruefidentifikator(mut self, pid: impl Into<String>) -> Self {
44        self.pruefidentifikator = Some(pid.into());
45        self
46    }
47
48    /// Builder: set the format version.
49    pub fn with_format_version(mut self, fv: impl Into<String>) -> Self {
50        self.format_version = Some(fv.into());
51        self
52    }
53
54    /// Add a validation issue.
55    pub fn add_issue(&mut self, issue: ValidationIssue) {
56        self.issues.push(issue);
57    }
58
59    /// Add multiple validation issues.
60    pub fn add_issues(&mut self, issues: impl IntoIterator<Item = ValidationIssue>) {
61        self.issues.extend(issues);
62    }
63
64    /// Returns `true` if there are no error-level issues.
65    pub fn is_valid(&self) -> bool {
66        !self.issues.iter().any(|i| i.severity == Severity::Error)
67    }
68
69    /// Returns the number of error-level issues.
70    pub fn error_count(&self) -> usize {
71        self.issues
72            .iter()
73            .filter(|i| i.severity == Severity::Error)
74            .count()
75    }
76
77    /// Returns the number of warning-level issues.
78    pub fn warning_count(&self) -> usize {
79        self.issues
80            .iter()
81            .filter(|i| i.severity == Severity::Warning)
82            .count()
83    }
84
85    /// Returns all error-level issues.
86    pub fn errors(&self) -> impl Iterator<Item = &ValidationIssue> {
87        self.issues.iter().filter(|i| i.severity == Severity::Error)
88    }
89
90    /// Returns all warning-level issues.
91    pub fn warnings(&self) -> impl Iterator<Item = &ValidationIssue> {
92        self.issues
93            .iter()
94            .filter(|i| i.severity == Severity::Warning)
95    }
96
97    /// Returns all info-level issues.
98    pub fn infos(&self) -> impl Iterator<Item = &ValidationIssue> {
99        self.issues.iter().filter(|i| i.severity == Severity::Info)
100    }
101
102    /// Returns issues filtered by category.
103    pub fn by_category(
104        &self,
105        category: ValidationCategory,
106    ) -> impl Iterator<Item = &ValidationIssue> {
107        self.issues.iter().filter(move |i| i.category == category)
108    }
109
110    /// Returns the total number of issues.
111    pub fn total_issues(&self) -> usize {
112        self.issues.len()
113    }
114
115    /// Enrich all issues that have a `field_path` by resolving BO4E paths.
116    ///
117    /// The `resolver` closure maps an EDIFACT field path (e.g., "SG4/SG5/LOC/C517/3225")
118    /// and an optional hint (e.g., codes from the validation message) to a BO4E field path
119    /// (e.g., "stammdaten.Marktlokation.marktlokationsId").
120    /// Issues without a `field_path` or where the resolver returns `None` are left unchanged.
121    pub fn enrich_bo4e_paths(&mut self, resolver: impl Fn(&str, Option<&str>) -> Option<String>) {
122        for issue in &mut self.issues {
123            if let Some(ref edifact_path) = issue.field_path {
124                // Extract a hint from the expected_value or the message for disambiguation.
125                // For missing qualifier fields, expected_value may contain the code (e.g., "93").
126                let hint = issue
127                    .expected_value
128                    .as_deref()
129                    .or(issue.rule.as_deref());
130                issue.bo4e_path = resolver(edifact_path, hint);
131            }
132        }
133    }
134}
135
136#[cfg(test)]
137mod tests {
138    use super::*;
139    use crate::validator::issue::ValidationCategory;
140
141    fn make_error(code: &str) -> ValidationIssue {
142        ValidationIssue::new(Severity::Error, ValidationCategory::Ahb, code, "test error")
143    }
144
145    fn make_warning(code: &str) -> ValidationIssue {
146        ValidationIssue::new(
147            Severity::Warning,
148            ValidationCategory::Structure,
149            code,
150            "test warning",
151        )
152    }
153
154    fn make_info(code: &str) -> ValidationIssue {
155        ValidationIssue::new(Severity::Info, ValidationCategory::Code, code, "test info")
156    }
157
158    #[test]
159    fn test_empty_report_is_valid() {
160        let report = ValidationReport::new("UTILMD", ValidationLevel::Full);
161        assert!(report.is_valid());
162        assert_eq!(report.error_count(), 0);
163        assert_eq!(report.warning_count(), 0);
164        assert_eq!(report.total_issues(), 0);
165    }
166
167    #[test]
168    fn test_report_with_errors_is_invalid() {
169        let mut report = ValidationReport::new("UTILMD", ValidationLevel::Full);
170        report.add_issue(make_error("AHB001"));
171
172        assert!(!report.is_valid());
173        assert_eq!(report.error_count(), 1);
174    }
175
176    #[test]
177    fn test_report_with_only_warnings_is_valid() {
178        let mut report = ValidationReport::new("UTILMD", ValidationLevel::Full);
179        report.add_issue(make_warning("STR001"));
180
181        assert!(report.is_valid());
182        assert_eq!(report.warning_count(), 1);
183        assert_eq!(report.error_count(), 0);
184    }
185
186    #[test]
187    fn test_report_mixed_issues() {
188        let mut report = ValidationReport::new("UTILMD", ValidationLevel::Full)
189            .with_pruefidentifikator("11001")
190            .with_format_version("FV2510");
191
192        report.add_issue(make_error("AHB001"));
193        report.add_issue(make_error("AHB003"));
194        report.add_issue(make_warning("STR002"));
195        report.add_issue(make_info("COD001"));
196
197        assert!(!report.is_valid());
198        assert_eq!(report.error_count(), 2);
199        assert_eq!(report.warning_count(), 1);
200        assert_eq!(report.total_issues(), 4);
201        assert_eq!(report.errors().count(), 2);
202        assert_eq!(report.warnings().count(), 1);
203        assert_eq!(report.infos().count(), 1);
204    }
205
206    #[test]
207    fn test_report_by_category() {
208        let mut report = ValidationReport::new("UTILMD", ValidationLevel::Full);
209        report.add_issue(make_error("AHB001"));
210        report.add_issue(make_warning("STR002"));
211
212        assert_eq!(report.by_category(ValidationCategory::Ahb).count(), 1);
213        assert_eq!(report.by_category(ValidationCategory::Structure).count(), 1);
214        assert_eq!(report.by_category(ValidationCategory::Format).count(), 0);
215    }
216
217    #[test]
218    fn test_report_add_issues() {
219        let mut report = ValidationReport::new("UTILMD", ValidationLevel::Full);
220        let issues = vec![make_error("AHB001"), make_warning("STR001")];
221        report.add_issues(issues);
222
223        assert_eq!(report.total_issues(), 2);
224    }
225
226    #[test]
227    fn test_enrich_bo4e_paths() {
228        let mut report = ValidationReport::new("UTILMD", ValidationLevel::Full);
229        report.add_issue(make_error("AHB001").with_field_path("SG4/SG5/LOC/C517/3225"));
230        report.add_issue(make_warning("STR001").with_field_path("SG2/NAD/3035"));
231        // Issue without field_path should be left alone
232        report.add_issue(make_error("AHB002"));
233
234        report.enrich_bo4e_paths(|path, _hint| match path {
235            "SG4/SG5/LOC/C517/3225" => Some("stammdaten.Marktlokation.marktlokationsId".into()),
236            "SG2/NAD/3035" => Some("stammdaten.Marktteilnehmer".into()),
237            _ => None,
238        });
239
240        assert_eq!(
241            report.issues[0].bo4e_path.as_deref(),
242            Some("stammdaten.Marktlokation.marktlokationsId")
243        );
244        assert_eq!(
245            report.issues[1].bo4e_path.as_deref(),
246            Some("stammdaten.Marktteilnehmer")
247        );
248        // No field_path → no bo4e_path
249        assert!(report.issues[2].bo4e_path.is_none());
250    }
251
252    #[test]
253    fn test_report_serialization() {
254        let mut report = ValidationReport::new("UTILMD", ValidationLevel::Conditions)
255            .with_pruefidentifikator("11001")
256            .with_format_version("FV2510");
257        report.add_issue(make_error("AHB001"));
258
259        let json = serde_json::to_string_pretty(&report).unwrap();
260        assert!(json.contains("UTILMD"));
261        assert!(json.contains("11001"));
262        assert!(json.contains("AHB001"));
263
264        let deserialized: ValidationReport = serde_json::from_str(&json).unwrap();
265        assert_eq!(deserialized.message_type, "UTILMD");
266        assert_eq!(deserialized.pruefidentifikator.as_deref(), Some("11001"));
267        assert_eq!(deserialized.total_issues(), 1);
268    }
269}
automapper_validation/validator/report.rs

automapper_validation/validator/
report.rs
