test: assert the repeating reference check instead of documenting its absence

Both example tests existed partly to record that the check never ran, and
forced it to execute with an invalid single-value cardinality to show what it
would do. They now exercise the list path directly.

Author: ryukzak

examples/python-r4-us-core/test_profile_provenance.py

@@ -11,18 +11,16 @@
 conformant type the generation did not emit is reported as an error. The
 TypeScript generator behaves the same way.
 
-The check still never runs, though: `target` is `1..*`, and the helper reads
-`reference` from the list itself rather than from each entry. The TypeScript
-generator has the same hole, so this mirrors
+`target` is `1..*`, so the element holds a list of References; the check reads
+every entry. Mirrors
 `examples/typescript-r4-us-core/profile-us-core-provenance.test.ts`.
 """
 
 from pathlib import Path
-from typing import Any, cast
 
 import pytest
 from fhir_types.hl7_fhir_r4_core.base import Reference
-from fhir_types.hl7_fhir_r4_core.provenance import Provenance, ProvenanceAgent
+from fhir_types.hl7_fhir_r4_core.provenance import ProvenanceAgent
 from fhir_types.hl7_fhir_us_core.profiles.provenance_uscore_provenance import (
     UscoreProvenanceProfile,
 )
@@ -63,41 +61,49 @@ def test_the_generated_validation_lists_the_member_resource_types() -> None:
     assert '"DomainResource"' not in GENERATED_SOURCE
 
 
-@pytest.mark.parametrize("reference", ["Patient/pt-1", "Practitioner/pr-1", "NotAResource/x"])
-def test_a_target_in_a_list_reports_no_error(reference: str) -> None:
-    # `target` is an array, so the emitted check cannot fail for any input — not
-    # even a reference to something that is not a FHIR resource at all.
+def test_an_allowed_target_passes() -> None:
     profile = UscoreProvenanceProfile.create(
-        target=[Reference(reference=reference)],
+        target=[Reference(reference="Patient/pt-1")],
         recorded=RECORDED,
         agent=_agent(),
     )
 
     assert profile.validate()["errors"] == []
 
 
-def _single_target(reference: str) -> Provenance:
-    # An invalid cardinality, used only to make the check execute.
-    resource: dict[str, Any] = {
-        "resourceType": "Provenance",
-        "recorded": RECORDED,
-        "agent": _agent(),
-        "target": {"reference": reference},
-    }
-    return cast(Provenance, resource)
-
-
-def test_the_check_accepts_an_allowed_resource_once_it_executes() -> None:
-    profile = UscoreProvenanceProfile(_single_target("Patient/pt-1"))
+@pytest.mark.parametrize("reference", ["Practitioner/pr-1", "NotAResource/x"])
+def test_a_target_outside_the_allowed_set_is_reported(reference: str) -> None:
+    profile = UscoreProvenanceProfile.create(
+        target=[Reference(reference=reference)],
+        recorded=RECORDED,
+        agent=_agent(),
+    )
 
-    assert profile.validate()["errors"] == []
+    reported = reference.split("/")[0]
+    assert profile.validate()["errors"] == [
+        f"UscoreProvenanceProfile: field 'target' references '{reported}' but only {ALLOWED} are allowed"
+    ]
 
 
-def test_the_check_rejects_a_type_outside_the_generated_closure_once_it_executes() -> None:
-    # Not "is this a FHIR resource" — the allowed set is this generation's
-    # closure, so a conformant Practitioner reference is reported here too.
-    profile = UscoreProvenanceProfile(_single_target("NotAResource/x"))
+def test_every_entry_of_the_list_is_checked() -> None:
+    profile = UscoreProvenanceProfile.create(
+        target=[Reference(reference="Patient/pt-1"), Reference(reference="NotAResource/x")],
+        recorded=RECORDED,
+        agent=_agent(),
+    )
 
     assert profile.validate()["errors"] == [
         f"UscoreProvenanceProfile: field 'target' references 'NotAResource' but only {ALLOWED} are allowed"
     ]
+
+
+def test_a_repeated_offending_type_is_reported_once() -> None:
+    # One error per offending type, so a long list does not bury the rest of
+    # validate()'s output.
+    profile = UscoreProvenanceProfile.create(
+        target=[Reference(reference="NotAResource/x"), Reference(reference="NotAResource/y")],
+        recorded=RECORDED,
+        agent=_agent(),
+    )
+
+    assert len(profile.validate()["errors"]) == 1

examples/typescript-r4-us-core/profile-us-core-provenance.test.ts

@@ -7,13 +7,12 @@
  * resources, so the emitted check lists the instantiable types a reference can
  * actually have — the abstract Resource and DomainResource are left out.
  *
- * The check still never runs, though: `target` is `1..*`, and the helper reads
- * `.reference` from the array itself rather than from each entry.
+ * `target` is `1..*`, so the element holds a list of References; the check reads
+ * every entry.
  */
 
 import { describe, expect, test } from "bun:test";
 import { readFileSync } from "node:fs";
-import type { Provenance } from "./fhir-types/hl7-fhir-r4-core/Provenance";
 import { USCoreProvenanceProfile } from "./fhir-types/hl7-fhir-us-core/profiles/Provenance_USCoreProvenance";
 
 const generatedSource = readFileSync(
@@ -38,38 +37,46 @@ describe("demo: record provenance for a resource", () => {
     });
 });
 
-describe("the generated reference check on target never runs", () => {
+describe("the generated reference check on target", () => {
     test("the generated validation lists the member resource types", () => {
         expect(generatedSource).toContain(
             'validateReference(res, profileName, "target", ["Bundle","CodeSystem","Observation","OperationOutcome","Patient","Provenance"])',
         );
     });
 
-    // `target` is an array, so the emitted check cannot fail for any input —
-    // not even a reference to something that is not a FHIR resource at all.
-    test.each(["Patient/pt-1", "Organization/org-1", "NotAResource/x"])(
-        "a target referencing %s reports no error",
-        (reference) => {
-            const profile = USCoreProvenanceProfile.create({ ...baseArgs, target: [{ reference }] });
+    test("an allowed target passes", () => {
+        const profile = USCoreProvenanceProfile.create({ ...baseArgs, target: [{ reference: "Patient/pt-1" }] });
 
-            expect(profile.validate().errors).toEqual([]);
-        },
-    );
+        expect(profile.validate().errors).toEqual([]);
+    });
 
-    // Reaching the same check with a single value instead of an array (an
-    // invalid cardinality, used here only to make the check execute) shows what
-    // it does when it runs: an allowed resource passes, a type that is not a
-    // resource does not.
-    const singleTarget = (reference: string) =>
-        ({ resourceType: "Provenance", ...baseArgs, target: { reference } }) as unknown as Provenance;
+    test.each(["Organization/org-1", "NotAResource/x"])("a target referencing %s is reported", (reference) => {
+        const profile = USCoreProvenanceProfile.create({ ...baseArgs, target: [{ reference }] });
 
-    test("the check accepts an allowed resource once it executes", () => {
-        expect(new USCoreProvenanceProfile(singleTarget("Patient/pt-1")).validate().errors).toEqual([]);
+        expect(profile.validate().errors).toEqual([
+            `USCoreProvenance: field 'target' references '${reference.split("/")[0]}' but only Bundle, CodeSystem, Observation, OperationOutcome, Patient, Provenance are allowed`,
+        ]);
     });
 
-    test("the check rejects a type that is not a resource once it executes", () => {
-        expect(new USCoreProvenanceProfile(singleTarget("NotAResource/x")).validate().errors).toEqual([
+    test("every entry of the list is checked, not just the first", () => {
+        const profile = USCoreProvenanceProfile.create({
+            ...baseArgs,
+            target: [{ reference: "Patient/pt-1" }, { reference: "NotAResource/x" }],
+        });
+
+        expect(profile.validate().errors).toEqual([
             "USCoreProvenance: field 'target' references 'NotAResource' but only Bundle, CodeSystem, Observation, OperationOutcome, Patient, Provenance are allowed",
         ]);
     });
+
+    // One error per offending type, so a list of many wrong references of the
+    // same type does not bury the rest of validate()'s output.
+    test("a repeated offending type is reported once", () => {
+        const profile = USCoreProvenanceProfile.create({
+            ...baseArgs,
+            target: [{ reference: "NotAResource/x" }, { reference: "NotAResource/y" }],
+        });
+
+        expect(profile.validate().errors).toHaveLength(1);
+    });
 });