automapper_validation/validator/

kind.rs

//! The machine-readable description of what a validation issue *is*.
//!
//! Wording lives in [`crate::display`]. A kind carries every fact the wording
//! needs, so a consumer can say something other than the sentence we ship.

use mig_assembly::StructureDiagnosticKind;
use serde::{Deserialize, Serialize};

use super::issue::ValidationCategory;

/// Why a condition could not be evaluated.
///
/// Any combination of these may be non-empty; each is a list of AHB condition ids.
#[derive(Debug, Clone, Default, PartialEq, Eq, Serialize, Deserialize)]
pub struct UnresolvedConditions {
    /// Need an external provider to answer.
    pub external: Vec<u32>,
    /// Not determinable from the message data.
    pub undetermined: Vec<u32>,
    /// Not present in the rulebook at all.
    pub missing: Vec<u32>,
}

impl UnresolvedConditions {
    /// True when nothing at all could be attributed — the issue has no detail.
    pub fn is_empty(&self) -> bool {
        self.external.is_empty() && self.undetermined.is_empty() && self.missing.is_empty()
    }
}

/// What kind of problem a [`ValidationIssue`](super::issue::ValidationIssue) reports.
///
/// One variant per problem the validator actually emits. `ErrorCodes` lists 22
/// code strings, but only these are ever constructed; adding a new check means
/// adding a variant, which the compiler then forces every narrator to handle.
#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
#[serde(tag = "type", rename_all = "camelCase")]
pub enum IssueKind {
    /// AHB001 — a field the AHB marks mandatory for this PID is absent.
    MissingRequiredField { field_name: String },
    /// AHB002 — a segment group is present although its AHB condition does not
    /// hold (`Muss [96]` without STS+7 ZAP). `group` is its path (`SG4/SG5`).
    GroupNotAllowed { group: String },
    /// AHB002 — a segment is present although its own AHB condition does not
    /// hold (`CAV+Z56` Wärmenutzung, `Muss [239]`, without CAV+Z65 in its
    /// SG10). `segment` is its path (`SG4/SG8/SG10/CAV`).
    SegmentNotAllowed { segment: String },
    /// AHB003 — the field is present but its AHB condition is not satisfied.
    FieldConditionNotSatisfied { field_name: String },
    /// AHB005 — the condition expression could not be fully evaluated.
    ConditionUnknown {
        field_name: String,
        unresolved: UnresolvedConditions,
    },
    /// AHB006 — number of codes present in a package is outside `min..max`.
    PackageCardinality {
        package_id: String,
        present: usize,
        min: usize,
        max: usize,
        codes: Vec<String>,
    },
    /// COD002 — the value is a valid code but not allowed for this PID.
    CodeNotAllowedForPid { value: String, allowed: Vec<String> },
    /// STR007 — UNT's declared segment count disagrees with the actual count.
    UntSegmentCountMismatch { declared: usize, actual: usize },
    /// STR007 — the input holds several messages, so the count is not checkable.
    UntCountNotVerifiable { unh_count: usize },
    /// STR003 / STR008 — a structure diagnostic raised during assembly.
    ///
    /// `detail` carries the diagnostic's own message verbatim: some
    /// diagnostics (e.g. `mig_assembly::Assembler::assemble_with_diagnostics`'s
    /// `"Assembly failed: {e}"` case) say something not derivable from
    /// `(kind, segment_id, position)` alone.
    StructureDiagnostic {
        kind: StructureDiagnosticKind,
        segment_id: String,
        position: usize,
        detail: String,
    },
}

impl IssueKind {
    /// The stable machine identifier, unchanged from the former `code` field.
    pub fn code(&self) -> &'static str {
        match self {
            Self::MissingRequiredField { .. } => "AHB001",
            Self::GroupNotAllowed { .. } | Self::SegmentNotAllowed { .. } => "AHB002",
            Self::FieldConditionNotSatisfied { .. } => "AHB003",
            Self::ConditionUnknown { .. } => "AHB005",
            Self::PackageCardinality { .. } => "AHB006",
            Self::CodeNotAllowedForPid { .. } => "COD002",
            Self::UntSegmentCountMismatch { .. } | Self::UntCountNotVerifiable { .. } => "STR007",
            // One code per kind (#81). An orphaned group segment is a skipped
            // segment too (its content is equally absent); the kind and
            // message tell the missing entry segment apart. A segment whose
            // qualifier no slot at its place accepts is unexpected there.
            Self::StructureDiagnostic { kind, .. } => match kind {
                StructureDiagnosticKind::MissingRequiredSegment => "STR001",
                StructureDiagnosticKind::MaxRepetitionsExceeded => "STR002",
                StructureDiagnosticKind::UnexpectedSegment
                | StructureDiagnosticKind::UnrecognizedQualifier => "STR003",
                StructureDiagnosticKind::MissingRequiredGroup => "STR005",
                StructureDiagnosticKind::GroupMaxRepetitionsExceeded => "STR006",
                StructureDiagnosticKind::SkippedUnknownSegment
                | StructureDiagnosticKind::OrphanedGroupSegment => "STR008",
            },
        }
    }

    /// The issue's category. Derived, so it can never disagree with the kind.
    pub fn category(&self) -> ValidationCategory {
        match self {
            Self::MissingRequiredField { .. }
            | Self::GroupNotAllowed { .. }
            | Self::SegmentNotAllowed { .. }
            | Self::FieldConditionNotSatisfied { .. }
            | Self::ConditionUnknown { .. }
            | Self::PackageCardinality { .. } => ValidationCategory::Ahb,
            Self::CodeNotAllowedForPid { .. } => ValidationCategory::Code,
            Self::UntSegmentCountMismatch { .. }
            | Self::UntCountNotVerifiable { .. }
            | Self::StructureDiagnostic { .. } => ValidationCategory::Structure,
        }
    }
}

#[cfg(test)]
mod tests {
    use super::*;
    use mig_assembly::StructureDiagnosticKind;

    #[test]
    fn code_matches_the_legacy_error_code_for_every_kind() {
        let cases: Vec<(IssueKind, &str)> = vec![
            (
                IssueKind::MissingRequiredField {
                    field_name: "f".into(),
                },
                "AHB001",
            ),
            (
                IssueKind::GroupNotAllowed {
                    group: "SG4/SG5".into(),
                },
                "AHB002",
            ),
            (
                IssueKind::SegmentNotAllowed {
                    segment: "SG4/SG8/SG10/CAV".into(),
                },
                "AHB002",
            ),
            (
                IssueKind::FieldConditionNotSatisfied {
                    field_name: "f".into(),
                },
                "AHB003",
            ),
            (
                IssueKind::ConditionUnknown {
                    field_name: "f".into(),
                    unresolved: UnresolvedConditions::default(),
                },
                "AHB005",
            ),
            (
                IssueKind::PackageCardinality {
                    package_id: "1P0..1".into(),
                    present: 2,
                    min: 0,
                    max: 1,
                    codes: vec![],
                },
                "AHB006",
            ),
            (
                IssueKind::CodeNotAllowedForPid {
                    value: "X".into(),
                    allowed: vec![],
                },
                "COD002",
            ),
            (
                IssueKind::UntSegmentCountMismatch {
                    declared: 30,
                    actual: 31,
                },
                "STR007",
            ),
            (IssueKind::UntCountNotVerifiable { unh_count: 2 }, "STR007"),
            (
                IssueKind::StructureDiagnostic {
                    kind: StructureDiagnosticKind::SkippedUnknownSegment,
                    segment_id: "CCI".into(),
                    position: 15,
                    detail: "irrelevant to the code".into(),
                },
                "STR008",
            ),
            (
                IssueKind::StructureDiagnostic {
                    kind: StructureDiagnosticKind::UnexpectedSegment,
                    segment_id: "CCI".into(),
                    position: 15,
                    detail: "irrelevant to the code".into(),
                },
                "STR003",
            ),
        ];
        for (kind, expected) in cases {
            assert_eq!(kind.code(), expected, "wrong code for {kind:?}");
        }
    }

    /// Every structure diagnostic keeps its own code (#81): a repetition
    /// overrun must not surface as "unexpected segment".
    #[test]
    fn each_structure_kind_has_its_own_code() {
        use StructureDiagnosticKind as K;
        for (kind, expected) in [
            (K::MissingRequiredSegment, "STR001"),
            (K::MaxRepetitionsExceeded, "STR002"),
            (K::UnexpectedSegment, "STR003"),
            (K::UnrecognizedQualifier, "STR003"),
            (K::MissingRequiredGroup, "STR005"),
            (K::GroupMaxRepetitionsExceeded, "STR006"),
            (K::SkippedUnknownSegment, "STR008"),
            (K::OrphanedGroupSegment, "STR008"),
        ] {
            let issue = IssueKind::StructureDiagnostic {
                kind,
                segment_id: "RFF".into(),
                position: 1,
                detail: String::new(),
            };
            assert_eq!(issue.code(), expected, "{kind:?}");
        }
    }

    #[test]
    fn category_is_derived_from_the_kind() {
        assert_eq!(
            IssueKind::MissingRequiredField {
                field_name: "f".into()
            }
            .category(),
            ValidationCategory::Ahb
        );
        assert_eq!(
            IssueKind::CodeNotAllowedForPid {
                value: "X".into(),
                allowed: vec![]
            }
            .category(),
            ValidationCategory::Code
        );
        assert_eq!(
            IssueKind::UntSegmentCountMismatch {
                declared: 1,
                actual: 2
            }
            .category(),
            ValidationCategory::Structure
        );
    }
}