Skip to content

gds_software.component.checks

Component diagram verification checks (CP-001..CP-004).

CP-001: Every required interface is satisfied by a connector.

Source code in packages/gds-software/gds_software/component/checks.py 
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
def check_cp001_interface_satisfaction(model: ComponentModel) -> list[Finding]:
    """CP-001: Every required interface is satisfied by a connector."""
    findings: list[Finding] = []
    # Collect all satisfied required interfaces
    satisfied: set[tuple[str, str]] = set()
    for conn in model.connectors:
        satisfied.add((conn.target, conn.target_interface))

    for comp in model.components:
        for req in comp.requires:
            is_satisfied = (comp.name, req) in satisfied
            findings.append(
                Finding(
                    check_id="CP-001",
                    severity=Severity.ERROR,
                    message=(
                        f"Component {comp.name!r} required interface {req!r} "
                        f"{'is' if is_satisfied else 'is NOT'} satisfied"
                    ),
                    source_elements=[comp.name, req],
                    passed=is_satisfied,
                )
            )
    return findings

CP-002: Connector source/target reference declared components and interfaces.

Source code in packages/gds-software/gds_software/component/checks.py 
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
def check_cp002_connector_validity(model: ComponentModel) -> list[Finding]:
    """CP-002: Connector source/target reference declared components and interfaces."""
    findings: list[Finding] = []
    comp_map = {c.name: c for c in model.components}

    for conn in model.connectors:
        src_valid = (
            conn.source in comp_map
            and conn.source_interface in comp_map[conn.source].provides
        )
        findings.append(
            Finding(
                check_id="CP-002",
                severity=Severity.ERROR,
                message=(
                    f"Connector {conn.name!r} source {conn.source!r}."
                    f"{conn.source_interface!r} "
                    f"{'is' if src_valid else 'is NOT'} valid"
                ),
                source_elements=[conn.name, conn.source],
                passed=src_valid,
            )
        )

        tgt_valid = (
            conn.target in comp_map
            and conn.target_interface in comp_map[conn.target].requires
        )
        findings.append(
            Finding(
                check_id="CP-002",
                severity=Severity.ERROR,
                message=(
                    f"Connector {conn.name!r} target {conn.target!r}."
                    f"{conn.target_interface!r} "
                    f"{'is' if tgt_valid else 'is NOT'} valid"
                ),
                source_elements=[conn.name, conn.target],
                passed=tgt_valid,
            )
        )
    return findings

CP-003: Every provided interface is consumed by a connector or is external.

Source code in packages/gds-software/gds_software/component/checks.py 
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
def check_cp003_dangling_interfaces(model: ComponentModel) -> list[Finding]:
    """CP-003: Every provided interface is consumed by a connector or is external."""
    findings: list[Finding] = []
    consumed: set[tuple[str, str]] = set()
    for conn in model.connectors:
        consumed.add((conn.source, conn.source_interface))

    for comp in model.components:
        for prov in comp.provides:
            is_consumed = (comp.name, prov) in consumed
            findings.append(
                Finding(
                    check_id="CP-003",
                    severity=Severity.WARNING,
                    message=(
                        f"Component {comp.name!r} provided interface {prov!r} "
                        f"{'is' if is_consumed else 'is NOT'} consumed by a connector"
                    ),
                    source_elements=[comp.name, prov],
                    passed=is_consumed,
                )
            )
    return findings

CP-004: No duplicate component names.

Source code in packages/gds-software/gds_software/component/checks.py 
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
def check_cp004_component_naming(model: ComponentModel) -> list[Finding]:
    """CP-004: No duplicate component names."""
    findings: list[Finding] = []
    seen: set[str] = set()
    for comp in model.components:
        is_unique = comp.name not in seen
        findings.append(
            Finding(
                check_id="CP-004",
                severity=Severity.ERROR,
                message=(
                    f"Component name {comp.name!r} "
                    f"{'is' if is_unique else 'is NOT'} unique"
                ),
                source_elements=[comp.name],
                passed=is_unique,
            )
        )
        seen.add(comp.name)
    return findings