validibot-shared 0.9.2__tar.gz → 0.11.0__tar.gz

{validibot_shared-0.9.2 → validibot_shared-0.11.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: validibot-shared
-Version: 0.9.2
+Version: 0.11.0
 Summary: Shared library for data interchange between Validibot and validator containers
 Project-URL: Homepage, https://validibot.com
 Project-URL: Documentation, https://docs.validibot.com
@@ -24,10 +24,11 @@ Classifier: Programming Language :: Python :: 3.13
 Classifier: Topic :: Scientific/Engineering
 Classifier: Topic :: Software Development :: Libraries :: Python Modules
 Requires-Python: >=3.10
+Requires-Dist: defusedxml<0.8,>=0.7.1
 Requires-Dist: pydantic<3.0,>=2.13
 Provides-Extra: dev
-Requires-Dist: pytest==9.0.3; extra == 'dev'
-Requires-Dist: ruff==0.15.15; extra == 'dev'
+Requires-Dist: pytest==9.1.1; extra == 'dev'
+Requires-Dist: ruff==0.15.18; extra == 'dev'
 Description-Content-Type: text/markdown
 
 <div align="center">

{validibot_shared-0.9.2 → validibot_shared-0.11.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "validibot-shared"
-version = "0.9.2"
+version = "0.11.0"
 description = "Shared library for data interchange between Validibot and validator containers"
 readme = "README.md"
 license = { text = "MIT" }
@@ -34,10 +34,10 @@ classifiers = [
     "Topic :: Software Development :: Libraries :: Python Modules",
     "Topic :: Scientific/Engineering",
 ]
-dependencies = ["pydantic>=2.13,<3.0"]
+dependencies = ["pydantic>=2.13,<3.0", "defusedxml>=0.7.1,<0.8"]
 
 [project.optional-dependencies]
-dev = ["pytest==9.0.3", "ruff==0.15.15"]
+dev = ["pytest==9.1.1", "ruff==0.15.18"]
 
 [project.urls]
 Homepage = "https://validibot.com"

{validibot_shared-0.9.2 → validibot_shared-0.11.0}/tests/test_evidence_manifest.py

@@ -25,6 +25,8 @@ from pydantic import ValidationError
 
 from validibot_shared.evidence import (
     SCHEMA_VERSION,
+    ContractConstant,
+    ContractSignalMapping,
     EvidenceManifest,
     ManifestPayloadDigests,
     ManifestRetentionInfo,
@@ -165,6 +167,116 @@ class TestOptionalFields:
         assert manifest.schema_version == "validibot.evidence.v1"
 
 
+# ──────────────────────────────────────────────────────────────────────
+# WorkflowContractSnapshot — constants, signal-mapping defs, definition hash
+# ──────────────────────────────────────────────────────────────────────
+#
+# ADR-2026-06-18. These three fields are additive and optional: a producer
+# predating them (or a workflow with none) leaves them empty, and the schema
+# stays ``validibot.evidence.v1``. Recording constants + signal-mapping
+# *definitions* + the definition hash is the transparency half of the constants
+# feature — it lets EVERY run (not just Pro-signed ones) carry "checked against
+# these constants". Resolved ``s.*`` values are deliberately NOT here (they are
+# submission-derived and retention-gated); only the definition is.
+
+
+class TestWorkflowContractPrimitives:
+    def test_new_fields_default_to_empty(self):
+        """A producer predating this change (or a bare workflow) leaves them empty.
+
+        Back-compat is the whole reason these are additive-optional: an older
+        manifest that never set them must still validate.
+        """
+        snap = WorkflowContractSnapshot(allowed_file_types=["json"])
+        assert snap.constants == []
+        assert snap.signal_mappings == []
+        assert snap.workflow_definition_hash == ""
+
+    def test_constant_value_is_preserved_verbatim(self):
+        """A NUMBER constant's decimal string is stored exactly (no float coercion).
+
+        The attested precision (``"0.40"``) must survive into the snapshot, or the
+        credential's "checked against c.energy_price = 0.40" claim would drift
+        from the value actually recorded.
+        """
+        snap = WorkflowContractSnapshot(
+            constants=[
+                ContractConstant(
+                    name="energy_price",
+                    data_type="NUMBER",
+                    value="0.40",
+                ),
+                ContractConstant(
+                    name="allowed_currencies",
+                    data_type="LIST",
+                    value=["EUR", "GBP"],
+                ),
+            ],
+        )
+        assert snap.constants[0].value == "0.40"
+        assert snap.constants[1].value == ["EUR", "GBP"]
+
+    def test_signal_mapping_records_definition_not_value(self):
+        """The snapshot carries a signal's DEFINITION, never a resolved value.
+
+        Publishing ``source_path``/``on_missing``/``default`` is safe; a resolved
+        ``s.*`` value is submission-derived and must not appear in the
+        always-publishable contract.
+        """
+        snap = WorkflowContractSnapshot(
+            signal_mappings=[
+                ContractSignalMapping(
+                    name="reported_total",
+                    source_path="$.total",
+                    on_missing="error",
+                ),
+            ],
+        )
+        mapping = snap.signal_mappings[0]
+        assert mapping.name == "reported_total"
+        assert mapping.source_path == "$.total"
+        # There is no place to smuggle a resolved value in — the model has no
+        # such field.
+        assert not hasattr(mapping, "resolved_value")
+
+    def test_primitives_survive_json_round_trip(self):
+        """The fields serialize and re-validate identically (canonical evidence).
+
+        The manifest is hashed and signed as JSON, so the new fields must
+        round-trip through ``model_dump``/``model_validate`` unchanged.
+        """
+        snap = WorkflowContractSnapshot(
+            constants=[ContractConstant(name="p", data_type="NUMBER", value="0.40")],
+            signal_mappings=[ContractSignalMapping(name="t", source_path="$.t")],
+            workflow_definition_hash="sha256:deadbeef",
+        )
+        restored = WorkflowContractSnapshot.model_validate(
+            snap.model_dump(mode="json"),
+        )
+        assert restored == snap
+
+    def test_additive_fields_preserve_v1_schema(self):
+        """A manifest carrying constants still reports schema_version v1.
+
+        Additive optional fields preserve v1 per the module's own policy;
+        bumping SCHEMA_VERSION here would be wrong.
+        """
+        manifest = EvidenceManifest(
+            **{
+                **_minimal_manifest_kwargs(),
+                "workflow_contract": WorkflowContractSnapshot(
+                    allowed_file_types=["json"],
+                    constants=[
+                        ContractConstant(name="p", data_type="NUMBER", value="0.40"),
+                    ],
+                    workflow_definition_hash="sha256:abc",
+                ),
+            },
+        )
+        assert manifest.schema_version == "validibot.evidence.v1"
+        assert manifest.workflow_contract.constants[0].name == "p"
+
+
 # ──────────────────────────────────────────────────────────────────────
 # StepValidatorRecord — semantic_digest can be None for legacy validators
 # ──────────────────────────────────────────────────────────────────────

validibot_shared-0.11.0/tests/test_schematron_envelopes.py

@@ -0,0 +1,183 @@
+"""Tests for the Schematron container contract (ADR-2026-07-01, D4b/D9).
+
+The Schematron validator ships an **artefact reference** (staged URI +
+checksums) rather than inlined rule text, and its outputs carry an
+``engine_status`` failure taxonomy where ``passed`` is *tri-state* —
+True/False when the engine ran, ``None`` (unknown) when it could not. These
+tests pin those contract properties so a refactor cannot silently weaken
+them: the Django side and the validator backend both program against exactly
+this shape.
+"""
+
+import pytest
+from pydantic import ValidationError
+
+from validibot_shared.schematron.envelopes import (
+    ENGINE_STATUS_OK,
+    ENGINE_STATUS_TIMEOUT,
+    SchematronFinding,
+    SchematronInputEnvelope,
+    SchematronInputs,
+    SchematronOutputEnvelope,
+    SchematronOutputs,
+    build_schematron_input_envelope,
+)
+from validibot_shared.validations.envelopes import (
+    SupportedMimeType,
+    ValidationStatus,
+    ValidatorType,
+)
+
+# Test constants to avoid magic values
+DEFAULT_MAX_FINDINGS = 500
+DEFAULT_XSLT_TIMEOUT = 60
+TEST_ERROR_COUNT = 3
+ARTIFACT_SHA = "b" * 64
+
+
+class _ValidatorStub:
+    """Duck-typed validator (id/validation_type/version) for the builder."""
+
+    id = "val-1"
+    validation_type = "SCHEMATRON"
+    version = "1"
+
+
+def _inputs(**overrides) -> SchematronInputs:
+    base = {
+        "pack_id": "en16931-ubl",
+        "pack_version": "1.3.16",
+        "artifact_uri": "gs://bucket/run-1/pack.xslt",
+        "artifact_sha256": ARTIFACT_SHA,
+        "query_binding": "xslt2",
+    }
+    base.update(overrides)
+    return SchematronInputs(**base)
+
+
+def test_schematron_inputs_carry_artifact_reference_and_limit_defaults():
+    """Inputs pin the staged artefact + checksum and default the D8 limits.
+
+    The container MUST be able to verify what it fetched before executing —
+    so the artefact URI and sha256 are required — while the resource limits
+    default to the ADR's table values for direct consumers.
+    """
+    inputs = _inputs()
+
+    assert inputs.artifact_uri == "gs://bucket/run-1/pack.xslt"
+    assert inputs.artifact_sha256 == ARTIFACT_SHA
+    assert inputs.max_findings == DEFAULT_MAX_FINDINGS
+    assert inputs.xslt_timeout_seconds == DEFAULT_XSLT_TIMEOUT
+
+
+def test_schematron_inputs_require_the_artifact_fields():
+    """Omitting the artefact reference is a validation error, not a default.
+
+    An input envelope without a verifiable artefact would force the container
+    to either refuse (good, but late) or trust an unpinned path (never).
+    """
+    with pytest.raises(ValidationError):
+        SchematronInputs(pack_id="x", pack_version="1")
+
+
+def test_outputs_default_to_unknown_passed_not_false():
+    """``passed`` defaults to None — unknown, not failed (D9).
+
+    A default of False would make an unpopulated envelope read as "the
+    invoice failed the rules"; None forces every consumer to distinguish
+    "engine didn't run" from "rules failed".
+    """
+    outputs = SchematronOutputs()
+    assert outputs.passed is None
+    assert outputs.engine_status == ENGINE_STATUS_OK
+
+
+def test_engine_failure_shape_round_trips():
+    """A timeout outputs object serializes and re-validates losslessly.
+
+    The callback path deserializes output.json with this model; the D9
+    fields must survive the JSON round trip exactly.
+    """
+    outputs = SchematronOutputs(
+        engine_status=ENGINE_STATUS_TIMEOUT,
+        engine_message="Transform exceeded 60s",
+        passed=None,
+        error_count=0,
+    )
+    envelope = SchematronOutputEnvelope(
+        run_id="run-1",
+        validator={"id": "v1", "type": ValidatorType.SCHEMATRON, "version": "1"},
+        status=ValidationStatus.FAILED_RUNTIME,
+        timing={},
+        outputs=outputs,
+    )
+
+    restored = SchematronOutputEnvelope.model_validate(
+        envelope.model_dump(mode="json"),
+    )
+    assert restored.outputs.engine_status == ENGINE_STATUS_TIMEOUT
+    assert restored.outputs.passed is None
+
+
+def test_findings_and_rule_id_map_round_trip():
+    """Findings keep native ids/locations and the map keeps its D2 shape."""
+    outputs = SchematronOutputs(
+        engine_status=ENGINE_STATUS_OK,
+        passed=False,
+        error_count=TEST_ERROR_COUNT,
+        finding_rule_ids_by_severity={"BR-CO-15": "ERROR", "BR-05": "WARNING"},
+        findings=[
+            SchematronFinding(
+                rule_id="BR-CO-15",
+                message="Totals must reconcile.",
+                severity="ERROR",
+                location_xpath="/Invoice/LegalMonetaryTotal",
+                flag="fatal",
+            ),
+        ],
+    )
+
+    restored = SchematronOutputs.model_validate(outputs.model_dump(mode="json"))
+    assert restored.finding_rule_ids_by_severity["BR-CO-15"] == "ERROR"
+    assert restored.findings[0].rule_id == "BR-CO-15"
+    assert restored.findings[0].location_xpath == "/Invoice/LegalMonetaryTotal"
+
+
+def test_outputs_forbid_unknown_fields():
+    """extra="forbid" holds — a typo'd field fails loudly, not silently.
+
+    Contract models must reject unknown keys so a mismatched backend/Django
+    version pair surfaces as an explicit error instead of dropped data.
+    """
+    with pytest.raises(ValidationError):
+        SchematronOutputs(engine_status="ok", not_a_field=1)
+
+
+def test_build_schematron_input_envelope_assembles_the_xml_submission():
+    """The builder produces a valid envelope with an XML primary input.
+
+    Pins the file-item conventions (name/mime/role) the container reads and
+    that ``ValidatorType.SCHEMATRON`` exists — the builder would crash
+    without the enum member.
+    """
+    envelope = build_schematron_input_envelope(
+        run_id="run-1",
+        validator=_ValidatorStub(),
+        org_id="org-1",
+        org_name="ValidiBot",
+        workflow_id="wf-1",
+        step_id="step-1",
+        step_name="Peppol rules",
+        submission_uri="gs://bucket/run-1/submission.xml",
+        inputs=_inputs(),
+        callback_url="https://example.com/callback",
+        execution_bundle_uri="gs://bucket/run-1/",
+    )
+
+    assert isinstance(envelope, SchematronInputEnvelope)
+    assert envelope.validator.type == ValidatorType.SCHEMATRON
+    file_item = envelope.input_files[0]
+    assert file_item.name == "submission.xml"
+    assert file_item.mime_type == SupportedMimeType.APPLICATION_XML
+    assert file_item.role == "primary-model"
+    assert envelope.inputs.pack_id == "en16931-ubl"

validibot_shared-0.11.0/tests/test_schematron_svrl.py

@@ -0,0 +1,290 @@
+"""Unit tests for the canonical SVRL parser (ADR-2026-07-01, D3/D10).
+
+``validibot_shared.schematron.svrl`` is the pure SVRL → findings/summary
+parser both consumers rely on — the validator backend container (parsing
+Saxon's SVRL into ``SchematronOutputs``) and the Django app (fixture and
+round-trip tests). These tests feed it canned SVRL documents and pin the
+D3/D10 contract:
+
+- ``svrl:failed-assert`` AND ``svrl:successful-report`` are active findings
+  handled identically — element type never drives severity.
+- Severity resolves ``@flag`` → ``@role`` → fail-closed ERROR, so nothing
+  publisher-authored is silently downgraded.
+- ``svrl:fired-rule`` counts rules/contexts evaluated, never assertions.
+- The ``finding_rule_ids_by_severity`` map is the pinned CEL contract
+  ({rule_id: severity}, most severe wins).
+- Truncation keeps ERROR findings first and is always explicit, while the
+  aggregate counts still reflect the FULL totals.
+
+Different Schematron compilers emit slightly different SVRL dialects, so the
+parser must be defensive — the un-namespaced-SVRL test guards that.
+"""
+
+from __future__ import annotations
+
+import pytest
+
+from validibot_shared.schematron.svrl import (
+    SEVERITY_ERROR,
+    SEVERITY_INFO,
+    SEVERITY_WARNING,
+    SvrlParseError,
+    parse_svrl,
+)
+
+# Named test values (avoid magic literals in assertions).
+TRUNCATION_CAP = 2
+TOTAL_FINDINGS_FOR_TRUNCATION = 5
+EXPECTED_SUPPRESSED = TOTAL_FINDINGS_FOR_TRUNCATION - TRUNCATION_CAP
+EXPECTED_FIRED_RULES = 2
+ERRORS_IN_TRUNCATION_BODY = 2
+WARNINGS_IN_TRUNCATION_BODY = 2
+
+
+def _svrl(body: str) -> str:
+    """Wrap finding elements in a minimal schematron-output document."""
+    return (
+        '<svrl:schematron-output xmlns:svrl="http://purl.oclc.org/dsdl/svrl">'
+        f"{body}"
+        "</svrl:schematron-output>"
+    )
+
+
+def _failed_assert(
+    *,
+    rule_id: str = "VB-X",
+    flag: str = "",
+    role: str = "",
+    location: str = "/Invoice",
+    text: str = "Something failed.",
+) -> str:
+    attrs = f' id="{rule_id}" location="{location}"'
+    if flag:
+        attrs += f' flag="{flag}"'
+    if role:
+        attrs += f' role="{role}"'
+    return (
+        f"<svrl:failed-assert{attrs}>"
+        f"<svrl:text>{text}</svrl:text>"
+        "</svrl:failed-assert>"
+    )
+
+
+# ── Severity resolution: @flag → @role → fail-closed ERROR ──────────────────
+
+
+def test_failed_assert_flag_fatal_maps_to_error():
+    """flag="fatal" resolves to ERROR and id/location survive the mapping.
+
+    The rule id and location are the whole value proposition (D10): they make
+    findings actionable and cross-referenceable against the published rules.
+    """
+    summary = parse_svrl(
+        _svrl(
+            _failed_assert(
+                rule_id="VB-CO-15",
+                flag="fatal",
+                location="/Invoice/LegalMonetaryTotal",
+            ),
+        ),
+    )
+
+    assert summary.error_count == 1
+    assert not summary.passed
+    finding = summary.findings[0]
+    assert finding.rule_id == "VB-CO-15"
+    assert finding.severity == SEVERITY_ERROR
+    assert finding.location == "/Invoice/LegalMonetaryTotal"
+    assert finding.flag == "fatal"
+
+
+def test_successful_report_is_an_active_finding_handled_identically():
+    """A svrl:successful-report with flag="fatal" is an ERROR finding.
+
+    This is the D3 rule the naive implementation gets wrong: a ``<report>``
+    can carry a publisher-authored *error*, so the element type must never
+    drive severity — only @flag/@role do.
+    """
+    summary = parse_svrl(
+        _svrl(
+            '<svrl:successful-report id="VB-R-01" flag="fatal" location="/a">'
+            "<svrl:text>Reported error.</svrl:text>"
+            "</svrl:successful-report>",
+        ),
+    )
+
+    assert summary.error_count == 1
+    assert summary.findings[0].severity == SEVERITY_ERROR
+    assert summary.findings[0].element == "successful-report"
+
+
+def test_role_is_the_fallback_when_flag_is_absent():
+    """@role maps warning→WARNING and information→INFO when @flag is missing.
+
+    The official packs use both spellings families (warn/warning,
+    info/information); the resolver accepts them all.
+    """
+    summary = parse_svrl(
+        _svrl(
+            _failed_assert(rule_id="VB-W", role="warning")
+            + _failed_assert(rule_id="VB-I", role="information"),
+        ),
+    )
+
+    by_id = {f.rule_id: f for f in summary.findings}
+    assert by_id["VB-W"].severity == SEVERITY_WARNING
+    assert by_id["VB-I"].severity == SEVERITY_INFO
+    assert summary.warning_count == 1
+    assert summary.info_count == 1
+    # Warnings/info alone never fail a Schematron step (D3).
+    assert summary.passed
+
+
+def test_flag_wins_over_role():
+    """When both attributes exist, @flag is authoritative (D3 resolution order)."""
+    summary = parse_svrl(
+        _svrl(_failed_assert(rule_id="VB-B", flag="fatal", role="warning")),
+    )
+    assert summary.findings[0].severity == SEVERITY_ERROR
+
+
+def test_fail_closed_to_error_when_neither_flag_nor_role_present():
+    """A finding with no severity attributes fail-closes to ERROR.
+
+    Fail-open (defaulting to INFO) would silently downgrade publisher-authored
+    rules whose pack relies on a default phase severity — the exact bug class
+    D3 forbids.
+    """
+    summary = parse_svrl(_svrl(_failed_assert(rule_id="VB-N")))
+    assert summary.findings[0].severity == SEVERITY_ERROR
+    assert summary.error_count == 1
+
+
+# ── Message text extraction ──────────────────────────────────────────────────
+
+
+def test_message_text_collapses_whitespace_and_inline_markup():
+    """svrl:text content survives inline markup and layout whitespace.
+
+    Publisher messages contain inline elements (emph/span) and authored
+    newlines; the human-readable message must come out flat and readable.
+    """
+    summary = parse_svrl(
+        _svrl(
+            '<svrl:failed-assert id="VB-T" flag="fatal" location="/a">'
+            "<svrl:text>Total \n   must <emph>equal</emph>\n sum.</svrl:text>"
+            "</svrl:failed-assert>",
+        ),
+    )
+    assert summary.findings[0].message == "Total must equal sum."
+
+
+# ── fired-rule counting ──────────────────────────────────────────────────────
+
+
+def test_fired_rule_count_counts_rules_not_assertions():
+    """svrl:fired-rule elements count evaluated rules/contexts — nothing else.
+
+    The review explicitly renamed this signal away from "assertion count":
+    a fired rule is a context the engine evaluated, not an assertion that
+    failed. Two fired rules + one failed assert must yield 2 / 1.
+    """
+    summary = parse_svrl(
+        _svrl(
+            '<svrl:fired-rule context="/Invoice"/>'
+            '<svrl:fired-rule context="/Invoice/Total"/>'
+            + _failed_assert(rule_id="VB-1", flag="fatal"),
+        ),
+    )
+    assert summary.fired_rule_count == EXPECTED_FIRED_RULES
+    assert summary.error_count == 1
+
+
+# ── The finding_rule_ids_by_severity map (CEL contract) ─────────────────────
+
+
+def test_rule_id_map_shape_and_most_severe_wins():
+    """The map is {rule_id: severity} and the most severe occurrence wins.
+
+    This is the pinned D2 CEL contract: key membership tests
+    (``"VB-D" in o.finding_rule_ids_by_severity``) and severity-aware gates
+    both depend on this exact shape. A rule firing at WARNING in one context
+    and ERROR in another must surface as ERROR.
+    """
+    summary = parse_svrl(
+        _svrl(
+            _failed_assert(rule_id="VB-D", role="warning")
+            + _failed_assert(rule_id="VB-D", flag="fatal")
+            + _failed_assert(rule_id="VB-W", role="warning"),
+        ),
+    )
+    assert summary.finding_rule_ids_by_severity == {
+        "VB-D": SEVERITY_ERROR,
+        "VB-W": SEVERITY_WARNING,
+    }
+
+
+# ── Truncation (D10: capped, never silent) ───────────────────────────────────
+
+
+def test_truncation_keeps_errors_first_and_counts_stay_full():
+    """Capping keeps ERROR findings first and records the suppressed count.
+
+    Two invariants: (1) the kept findings are ordered ERROR → WARNING → INFO
+    so the most actionable rows survive; (2) the aggregate counts reflect the
+    FULL document, so "clean-ish" and "thousands of errors, capped" can never
+    look the same to a CEL gate.
+    """
+    body = (
+        _failed_assert(rule_id="VB-I1", role="info")
+        + _failed_assert(rule_id="VB-W1", role="warning")
+        + _failed_assert(rule_id="VB-E1", flag="fatal")
+        + _failed_assert(rule_id="VB-E2", flag="error")
+        + _failed_assert(rule_id="VB-W2", role="warning")
+    )
+    summary = parse_svrl(_svrl(body), max_findings=TRUNCATION_CAP)
+
+    assert summary.findings_truncated
+    assert summary.findings_suppressed_count == EXPECTED_SUPPRESSED
+    assert len(summary.findings) == TRUNCATION_CAP
+    # ERROR findings survive the cap ahead of warnings/info.
+    assert {f.rule_id for f in summary.findings} == {"VB-E1", "VB-E2"}
+    # Aggregates are computed pre-cap.
+    assert summary.error_count == ERRORS_IN_TRUNCATION_BODY
+    assert summary.warning_count == WARNINGS_IN_TRUNCATION_BODY
+    assert summary.info_count == 1
+    assert len(summary.finding_rule_ids_by_severity) == TOTAL_FINDINGS_FOR_TRUNCATION
+
+
+# ── Dialect tolerance + input guards ─────────────────────────────────────────
+
+
+def test_unnamespaced_svrl_is_tolerated():
+    """SVRL without the namespace still parses (compiler-dialect defensiveness).
+
+    Some Schematron toolchains emit un-namespaced SVRL; the parser matches on
+    local names so those reports still map to findings.
+    """
+    summary = parse_svrl(
+        "<schematron-output>"
+        '<fired-rule context="/a"/>'
+        '<failed-assert id="VB-U" flag="fatal" location="/a">'
+        "<text>Unnamespaced.</text>"
+        "</failed-assert>"
+        "</schematron-output>",
+    )
+    assert summary.fired_rule_count == 1
+    assert summary.findings[0].rule_id == "VB-U"
+
+
+def test_empty_and_malformed_svrl_raise():
+    """Empty or non-XML input raises SvrlParseError rather than passing.
+
+    Silently returning an empty summary for garbage input would read as
+    "zero findings" — i.e. a pass — which is exactly the fail-open behaviour
+    the D9 taxonomy exists to prevent.
+    """
+    with pytest.raises(SvrlParseError):
+        parse_svrl("")
+    with pytest.raises(SvrlParseError):
+        parse_svrl("this is not XML <")

{validibot_shared-0.9.2 → validibot_shared-0.11.0}/validibot_shared/__init__.py

@@ -9,6 +9,8 @@ from validibot_shared.evidence import (
     SCHEMA_VERSION as EVIDENCE_SCHEMA_VERSION,
 )
 from validibot_shared.evidence import (
+    ContractConstant,
+    ContractSignalMapping,
     EvidenceManifest,
     ManifestPayloadDigests,
     ManifestRetentionInfo,
@@ -26,6 +28,8 @@ from validibot_shared.shacl.envelopes import (
 
 __all__ = [
     "EVIDENCE_SCHEMA_VERSION",
+    "ContractConstant",
+    "ContractSignalMapping",
     "EnergyPlusSimulationLogs",
     "EnergyPlusSimulationMetrics",
     "EnergyPlusSimulationOutputs",

{validibot_shared-0.9.2 → validibot_shared-0.11.0}/validibot_shared/evidence/__init__.py

@@ -9,6 +9,8 @@ manifest without pulling in the application stack.
 
 from validibot_shared.evidence.manifest import (
     SCHEMA_VERSION,
+    ContractConstant,
+    ContractSignalMapping,
     EvidenceManifest,
     ManifestPayloadDigests,
     ManifestRetentionInfo,
@@ -18,6 +20,8 @@ from validibot_shared.evidence.manifest import (
 
 __all__ = [
     "SCHEMA_VERSION",
+    "ContractConstant",
+    "ContractSignalMapping",
     "EvidenceManifest",
     "ManifestPayloadDigests",
     "ManifestRetentionInfo",