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.expected_value.as_deref().or(issue.rule.as_deref());
127                issue.bo4e_path = resolver(edifact_path, hint);
128            }
129        }
130    }
131}
132
133#[cfg(test)]
134mod tests {
135    use super::*;
136    use crate::validator::issue::ValidationCategory;
137
138    fn make_error(code: &str) -> ValidationIssue {
139        ValidationIssue::new(Severity::Error, ValidationCategory::Ahb, code, "test error")
140    }
141
142    fn make_warning(code: &str) -> ValidationIssue {
143        ValidationIssue::new(
144            Severity::Warning,
145            ValidationCategory::Structure,
146            code,
147            "test warning",
148        )
149    }
150
151    fn make_info(code: &str) -> ValidationIssue {
152        ValidationIssue::new(Severity::Info, ValidationCategory::Code, code, "test info")
153    }
154
155    #[test]
156    fn test_empty_report_is_valid() {
157        let report = ValidationReport::new("UTILMD", ValidationLevel::Full);
158        assert!(report.is_valid());
159        assert_eq!(report.error_count(), 0);
160        assert_eq!(report.warning_count(), 0);
161        assert_eq!(report.total_issues(), 0);
162    }
163
164    #[test]
165    fn test_report_with_errors_is_invalid() {
166        let mut report = ValidationReport::new("UTILMD", ValidationLevel::Full);
167        report.add_issue(make_error("AHB001"));
168
169        assert!(!report.is_valid());
170        assert_eq!(report.error_count(), 1);
171    }
172
173    #[test]
174    fn test_report_with_only_warnings_is_valid() {
175        let mut report = ValidationReport::new("UTILMD", ValidationLevel::Full);
176        report.add_issue(make_warning("STR001"));
177
178        assert!(report.is_valid());
179        assert_eq!(report.warning_count(), 1);
180        assert_eq!(report.error_count(), 0);
181    }
182
183    #[test]
184    fn test_report_mixed_issues() {
185        let mut report = ValidationReport::new("UTILMD", ValidationLevel::Full)
186            .with_pruefidentifikator("11001")
187            .with_format_version("FV2510");
188
189        report.add_issue(make_error("AHB001"));
190        report.add_issue(make_error("AHB003"));
191        report.add_issue(make_warning("STR002"));
192        report.add_issue(make_info("COD001"));
193
194        assert!(!report.is_valid());
195        assert_eq!(report.error_count(), 2);
196        assert_eq!(report.warning_count(), 1);
197        assert_eq!(report.total_issues(), 4);
198        assert_eq!(report.errors().count(), 2);
199        assert_eq!(report.warnings().count(), 1);
200        assert_eq!(report.infos().count(), 1);
201    }
202
203    #[test]
204    fn test_report_by_category() {
205        let mut report = ValidationReport::new("UTILMD", ValidationLevel::Full);
206        report.add_issue(make_error("AHB001"));
207        report.add_issue(make_warning("STR002"));
208
209        assert_eq!(report.by_category(ValidationCategory::Ahb).count(), 1);
210        assert_eq!(report.by_category(ValidationCategory::Structure).count(), 1);
211        assert_eq!(report.by_category(ValidationCategory::Format).count(), 0);
212    }
213
214    #[test]
215    fn test_report_add_issues() {
216        let mut report = ValidationReport::new("UTILMD", ValidationLevel::Full);
217        let issues = vec![make_error("AHB001"), make_warning("STR001")];
218        report.add_issues(issues);
219
220        assert_eq!(report.total_issues(), 2);
221    }
222
223    #[test]
224    fn test_enrich_bo4e_paths() {
225        let mut report = ValidationReport::new("UTILMD", ValidationLevel::Full);
226        report.add_issue(make_error("AHB001").with_field_path("SG4/SG5/LOC/C517/3225"));
227        report.add_issue(make_warning("STR001").with_field_path("SG2/NAD/3035"));
228        // Issue without field_path should be left alone
229        report.add_issue(make_error("AHB002"));
230
231        report.enrich_bo4e_paths(|path, _hint| match path {
232            "SG4/SG5/LOC/C517/3225" => Some("stammdaten.Marktlokation.marktlokationsId".into()),
233            "SG2/NAD/3035" => Some("stammdaten.Marktteilnehmer".into()),
234            _ => None,
235        });
236
237        assert_eq!(
238            report.issues[0].bo4e_path.as_deref(),
239            Some("stammdaten.Marktlokation.marktlokationsId")
240        );
241        assert_eq!(
242            report.issues[1].bo4e_path.as_deref(),
243            Some("stammdaten.Marktteilnehmer")
244        );
245        // No field_path → no bo4e_path
246        assert!(report.issues[2].bo4e_path.is_none());
247    }
248
249    #[test]
250    fn test_report_serialization() {
251        let mut report = ValidationReport::new("UTILMD", ValidationLevel::Conditions)
252            .with_pruefidentifikator("11001")
253            .with_format_version("FV2510");
254        report.add_issue(make_error("AHB001"));
255
256        let json = serde_json::to_string_pretty(&report).unwrap();
257        assert!(json.contains("UTILMD"));
258        assert!(json.contains("11001"));
259        assert!(json.contains("AHB001"));
260
261        let deserialized: ValidationReport = serde_json::from_str(&json).unwrap();
262        assert_eq!(deserialized.message_type, "UTILMD");
263        assert_eq!(deserialized.pruefidentifikator.as_deref(), Some("11001"));
264        assert_eq!(deserialized.total_issues(), 1);
265    }
266}
automapper_validation/validator/report.rs

automapper_validation/validator/
report.rs
