cancer_registry_reporting_test_kit 0.9.0

data/lib/cancer_registry_reporting_test_kit/igs/package/xml/StructureDefinition-us-ph-patient.sch

@@ -0,0 +1,217 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<sch:schema xmlns:sch="http://purl.oclc.org/dsdl/schematron" queryBinding="xslt2">
+  <sch:ns prefix="f" uri="http://hl7.org/fhir"/>
+  <sch:ns prefix="h" uri="http://www.w3.org/1999/xhtml"/>
+  <!-- 
+    This file contains just the constraints for the profile USCorePatientProfile
+    It includes the base constraints for the resource as well.
+    Because of the way that schematrons and containment work, 
+    you may need to use this schematron fragment to build a, 
+    single schematron that validates contained resources (if you have any) 
+  -->
+  <sch:pattern>
+    <sch:title>f:Patient</sch:title>
+    <sch:rule context="f:Patient">
+      <sch:assert test="count(f:extension[@url = 'http://hl7.org/fhir/us/core/StructureDefinition/us-core-race']) &lt;= 1">extension with URL = 'http://hl7.org/fhir/us/core/StructureDefinition/us-core-race': maximum cardinality of 'extension' is 1</sch:assert>
+      <sch:assert test="count(f:extension[@url = 'http://hl7.org/fhir/us/core/StructureDefinition/us-core-ethnicity']) &lt;= 1">extension with URL = 'http://hl7.org/fhir/us/core/StructureDefinition/us-core-ethnicity': maximum cardinality of 'extension' is 1</sch:assert>
+      <sch:assert test="count(f:extension[@url = 'http://hl7.org/fhir/us/core/StructureDefinition/us-core-birthsex']) &lt;= 1">extension with URL = 'http://hl7.org/fhir/us/core/StructureDefinition/us-core-birthsex': maximum cardinality of 'extension' is 1</sch:assert>
+      <sch:assert test="count(f:extension[@url = 'http://hl7.org/fhir/StructureDefinition/patient-birthPlace']) &lt;= 1">extension with URL = 'http://hl7.org/fhir/StructureDefinition/patient-birthPlace': maximum cardinality of 'extension' is 1</sch:assert>
+      <sch:assert test="count(f:birthDate) &gt;= 1">birthDate: minimum cardinality of 'birthDate' is 1</sch:assert>
+      <sch:assert test="count(f:address) &gt;= 1">address: minimum cardinality of 'address' is 1</sch:assert>
+    </sch:rule>
+  </sch:pattern>
+  <sch:pattern>
+    <sch:title>f:Patient/f:identifier</sch:title>
+    <sch:rule context="f:Patient/f:identifier">
+      <sch:assert test="count(f:extension[@url = 'http://hl7.org/fhir/StructureDefinition/data-absent-reason']) &lt;= 1">extension with URL = 'http://hl7.org/fhir/StructureDefinition/data-absent-reason': maximum cardinality of 'extension' is 1</sch:assert>
+    </sch:rule>
+  </sch:pattern>
+  <sch:pattern>
+    <sch:title>f:Patient/f:identifier/f:extension</sch:title>
+    <sch:rule context="f:Patient/f:identifier/f:extension">
+      <sch:assert test="count(f:id) &lt;= 1">id: maximum cardinality of 'id' is 1</sch:assert>
+      <sch:assert test="count(f:url) &gt;= 1">url: minimum cardinality of 'url' is 1</sch:assert>
+      <sch:assert test="count(f:url) &lt;= 1">url: maximum cardinality of 'url' is 1</sch:assert>
+      <sch:assert test="count(f:value[x]) &gt;= 1">value[x]: minimum cardinality of 'value[x]' is 1</sch:assert>
+      <sch:assert test="count(f:value[x]) &lt;= 1">value[x]: maximum cardinality of 'value[x]' is 1</sch:assert>
+    </sch:rule>
+  </sch:pattern>
+  <sch:pattern>
+    <sch:title>f:Patient/f:name</sch:title>
+    <sch:rule context="f:Patient/f:name">
+      <sch:assert test="count(f:extension[@url = 'http://hl7.org/fhir/StructureDefinition/data-absent-reason']) &lt;= 1">extension with URL = 'http://hl7.org/fhir/StructureDefinition/data-absent-reason': maximum cardinality of 'extension' is 1</sch:assert>
+    </sch:rule>
+  </sch:pattern>
+  <sch:pattern>
+    <sch:title>f:Patient/f:name/f:extension</sch:title>
+    <sch:rule context="f:Patient/f:name/f:extension">
+      <sch:assert test="count(f:id) &lt;= 1">id: maximum cardinality of 'id' is 1</sch:assert>
+      <sch:assert test="count(f:url) &gt;= 1">url: minimum cardinality of 'url' is 1</sch:assert>
+      <sch:assert test="count(f:url) &lt;= 1">url: maximum cardinality of 'url' is 1</sch:assert>
+      <sch:assert test="count(f:value[x]) &gt;= 1">value[x]: minimum cardinality of 'value[x]' is 1</sch:assert>
+      <sch:assert test="count(f:value[x]) &lt;= 1">value[x]: maximum cardinality of 'value[x]' is 1</sch:assert>
+    </sch:rule>
+  </sch:pattern>
+  <sch:pattern>
+    <sch:title>f:Patient/f:telecom</sch:title>
+    <sch:rule context="f:Patient/f:telecom">
+      <sch:assert test="count(f:extension[@url = 'http://hl7.org/fhir/StructureDefinition/data-absent-reason']) &lt;= 1">extension with URL = 'http://hl7.org/fhir/StructureDefinition/data-absent-reason': maximum cardinality of 'extension' is 1</sch:assert>
+    </sch:rule>
+  </sch:pattern>
+  <sch:pattern>
+    <sch:title>f:Patient/f:telecom/f:extension</sch:title>
+    <sch:rule context="f:Patient/f:telecom/f:extension">
+      <sch:assert test="count(f:id) &lt;= 1">id: maximum cardinality of 'id' is 1</sch:assert>
+      <sch:assert test="count(f:url) &gt;= 1">url: minimum cardinality of 'url' is 1</sch:assert>
+      <sch:assert test="count(f:url) &lt;= 1">url: maximum cardinality of 'url' is 1</sch:assert>
+      <sch:assert test="count(f:value[x]) &gt;= 1">value[x]: minimum cardinality of 'value[x]' is 1</sch:assert>
+      <sch:assert test="count(f:value[x]) &lt;= 1">value[x]: maximum cardinality of 'value[x]' is 1</sch:assert>
+    </sch:rule>
+  </sch:pattern>
+  <sch:pattern>
+    <sch:title>f:Patient/f:gender</sch:title>
+    <sch:rule context="f:Patient/f:gender">
+      <sch:assert test="count(f:id) &lt;= 1">id: maximum cardinality of 'id' is 1</sch:assert>
+      <sch:assert test="count(f:extension[@url = 'http://hl7.org/fhir/StructureDefinition/data-absent-reason']) &lt;= 1">extension with URL = 'http://hl7.org/fhir/StructureDefinition/data-absent-reason': maximum cardinality of 'extension' is 1</sch:assert>
+      <sch:assert test="count(f:value) &lt;= 1">value: maximum cardinality of 'value' is 1</sch:assert>
+    </sch:rule>
+  </sch:pattern>
+  <sch:pattern>
+    <sch:title>f:Patient/f:gender/f:extension</sch:title>
+    <sch:rule context="f:Patient/f:gender/f:extension">
+      <sch:assert test="count(f:id) &lt;= 1">id: maximum cardinality of 'id' is 1</sch:assert>
+      <sch:assert test="count(f:url) &gt;= 1">url: minimum cardinality of 'url' is 1</sch:assert>
+      <sch:assert test="count(f:url) &lt;= 1">url: maximum cardinality of 'url' is 1</sch:assert>
+      <sch:assert test="count(f:value[x]) &gt;= 1">value[x]: minimum cardinality of 'value[x]' is 1</sch:assert>
+      <sch:assert test="count(f:value[x]) &lt;= 1">value[x]: maximum cardinality of 'value[x]' is 1</sch:assert>
+    </sch:rule>
+  </sch:pattern>
+  <sch:pattern>
+    <sch:title>f:Patient/f:birthDate</sch:title>
+    <sch:rule context="f:Patient/f:birthDate">
+      <sch:assert test="count(f:id) &lt;= 1">id: maximum cardinality of 'id' is 1</sch:assert>
+      <sch:assert test="count(f:extension[@url = 'http://hl7.org/fhir/StructureDefinition/data-absent-reason']) &lt;= 1">extension with URL = 'http://hl7.org/fhir/StructureDefinition/data-absent-reason': maximum cardinality of 'extension' is 1</sch:assert>
+      <sch:assert test="count(f:value) &lt;= 1">value: maximum cardinality of 'value' is 1</sch:assert>
+    </sch:rule>
+  </sch:pattern>
+  <sch:pattern>
+    <sch:title>f:Patient/f:birthDate/f:extension</sch:title>
+    <sch:rule context="f:Patient/f:birthDate/f:extension">
+      <sch:assert test="count(f:id) &lt;= 1">id: maximum cardinality of 'id' is 1</sch:assert>
+      <sch:assert test="count(f:url) &gt;= 1">url: minimum cardinality of 'url' is 1</sch:assert>
+      <sch:assert test="count(f:url) &lt;= 1">url: maximum cardinality of 'url' is 1</sch:assert>
+      <sch:assert test="count(f:value[x]) &gt;= 1">value[x]: minimum cardinality of 'value[x]' is 1</sch:assert>
+      <sch:assert test="count(f:value[x]) &lt;= 1">value[x]: maximum cardinality of 'value[x]' is 1</sch:assert>
+    </sch:rule>
+  </sch:pattern>
+  <sch:pattern>
+    <sch:title>f:Patient/f:address</sch:title>
+    <sch:rule context="f:Patient/f:address">
+      <sch:assert test="count(f:extension[@url = 'http://hl7.org/fhir/StructureDefinition/data-absent-reason']) &lt;= 1">extension with URL = 'http://hl7.org/fhir/StructureDefinition/data-absent-reason': maximum cardinality of 'extension' is 1</sch:assert>
+    </sch:rule>
+  </sch:pattern>
+  <sch:pattern>
+    <sch:title>f:Patient/f:address/f:extension</sch:title>
+    <sch:rule context="f:Patient/f:address/f:extension">
+      <sch:assert test="count(f:id) &lt;= 1">id: maximum cardinality of 'id' is 1</sch:assert>
+      <sch:assert test="count(f:url) &gt;= 1">url: minimum cardinality of 'url' is 1</sch:assert>
+      <sch:assert test="count(f:url) &lt;= 1">url: maximum cardinality of 'url' is 1</sch:assert>
+      <sch:assert test="count(f:value[x]) &gt;= 1">value[x]: minimum cardinality of 'value[x]' is 1</sch:assert>
+      <sch:assert test="count(f:value[x]) &lt;= 1">value[x]: maximum cardinality of 'value[x]' is 1</sch:assert>
+    </sch:rule>
+  </sch:pattern>
+  <sch:pattern>
+    <sch:title>f:Patient/f:contact</sch:title>
+    <sch:rule context="f:Patient/f:contact">
+      <sch:assert test="count(f:relationship) &gt;= 1">relationship: minimum cardinality of 'relationship' is 1</sch:assert>
+      <sch:assert test="count(f:relationship) &lt;= 1">relationship: maximum cardinality of 'relationship' is 1</sch:assert>
+    </sch:rule>
+  </sch:pattern>
+  <sch:pattern>
+    <sch:title>f:Patient/f:contact/f:name</sch:title>
+    <sch:rule context="f:Patient/f:contact/f:name">
+      <sch:assert test="count(f:id) &lt;= 1">id: maximum cardinality of 'id' is 1</sch:assert>
+      <sch:assert test="count(f:extension[@url = 'http://hl7.org/fhir/StructureDefinition/data-absent-reason']) &lt;= 1">extension with URL = 'http://hl7.org/fhir/StructureDefinition/data-absent-reason': maximum cardinality of 'extension' is 1</sch:assert>
+      <sch:assert test="count(f:use) &lt;= 1">use: maximum cardinality of 'use' is 1</sch:assert>
+      <sch:assert test="count(f:text) &lt;= 1">text: maximum cardinality of 'text' is 1</sch:assert>
+      <sch:assert test="count(f:family) &lt;= 1">family: maximum cardinality of 'family' is 1</sch:assert>
+      <sch:assert test="count(f:period) &lt;= 1">period: maximum cardinality of 'period' is 1</sch:assert>
+    </sch:rule>
+  </sch:pattern>
+  <sch:pattern>
+    <sch:title>f:Patient/f:contact/f:name/f:extension</sch:title>
+    <sch:rule context="f:Patient/f:contact/f:name/f:extension">
+      <sch:assert test="count(f:id) &lt;= 1">id: maximum cardinality of 'id' is 1</sch:assert>
+      <sch:assert test="count(f:url) &gt;= 1">url: minimum cardinality of 'url' is 1</sch:assert>
+      <sch:assert test="count(f:url) &lt;= 1">url: maximum cardinality of 'url' is 1</sch:assert>
+      <sch:assert test="count(f:value[x]) &gt;= 1">value[x]: minimum cardinality of 'value[x]' is 1</sch:assert>
+      <sch:assert test="count(f:value[x]) &lt;= 1">value[x]: maximum cardinality of 'value[x]' is 1</sch:assert>
+    </sch:rule>
+  </sch:pattern>
+  <sch:pattern>
+    <sch:title>f:Patient/f:contact/f:telecom</sch:title>
+    <sch:rule context="f:Patient/f:contact/f:telecom">
+      <sch:assert test="count(f:id) &lt;= 1">id: maximum cardinality of 'id' is 1</sch:assert>
+      <sch:assert test="count(f:extension[@url = 'http://hl7.org/fhir/StructureDefinition/data-absent-reason']) &lt;= 1">extension with URL = 'http://hl7.org/fhir/StructureDefinition/data-absent-reason': maximum cardinality of 'extension' is 1</sch:assert>
+      <sch:assert test="count(f:system) &lt;= 1">system: maximum cardinality of 'system' is 1</sch:assert>
+      <sch:assert test="count(f:value) &lt;= 1">value: maximum cardinality of 'value' is 1</sch:assert>
+      <sch:assert test="count(f:use) &lt;= 1">use: maximum cardinality of 'use' is 1</sch:assert>
+      <sch:assert test="count(f:rank) &lt;= 1">rank: maximum cardinality of 'rank' is 1</sch:assert>
+      <sch:assert test="count(f:period) &lt;= 1">period: maximum cardinality of 'period' is 1</sch:assert>
+    </sch:rule>
+  </sch:pattern>
+  <sch:pattern>
+    <sch:title>f:Patient/f:contact/f:telecom/f:extension</sch:title>
+    <sch:rule context="f:Patient/f:contact/f:telecom/f:extension">
+      <sch:assert test="count(f:id) &lt;= 1">id: maximum cardinality of 'id' is 1</sch:assert>
+      <sch:assert test="count(f:url) &gt;= 1">url: minimum cardinality of 'url' is 1</sch:assert>
+      <sch:assert test="count(f:url) &lt;= 1">url: maximum cardinality of 'url' is 1</sch:assert>
+      <sch:assert test="count(f:value[x]) &gt;= 1">value[x]: minimum cardinality of 'value[x]' is 1</sch:assert>
+      <sch:assert test="count(f:value[x]) &lt;= 1">value[x]: maximum cardinality of 'value[x]' is 1</sch:assert>
+    </sch:rule>
+  </sch:pattern>
+  <sch:pattern>
+    <sch:title>f:Patient/f:contact/f:address</sch:title>
+    <sch:rule context="f:Patient/f:contact/f:address">
+      <sch:assert test="count(f:id) &lt;= 1">id: maximum cardinality of 'id' is 1</sch:assert>
+      <sch:assert test="count(f:extension[@url = 'http://hl7.org/fhir/StructureDefinition/data-absent-reason']) &lt;= 1">extension with URL = 'http://hl7.org/fhir/StructureDefinition/data-absent-reason': maximum cardinality of 'extension' is 1</sch:assert>
+      <sch:assert test="count(f:use) &lt;= 1">use: maximum cardinality of 'use' is 1</sch:assert>
+      <sch:assert test="count(f:type) &lt;= 1">type: maximum cardinality of 'type' is 1</sch:assert>
+      <sch:assert test="count(f:text) &lt;= 1">text: maximum cardinality of 'text' is 1</sch:assert>
+      <sch:assert test="count(f:city) &lt;= 1">city: maximum cardinality of 'city' is 1</sch:assert>
+      <sch:assert test="count(f:district) &lt;= 1">district: maximum cardinality of 'district' is 1</sch:assert>
+      <sch:assert test="count(f:state) &lt;= 1">state: maximum cardinality of 'state' is 1</sch:assert>
+      <sch:assert test="count(f:postalCode) &lt;= 1">postalCode: maximum cardinality of 'postalCode' is 1</sch:assert>
+      <sch:assert test="count(f:country) &lt;= 1">country: maximum cardinality of 'country' is 1</sch:assert>
+      <sch:assert test="count(f:period) &lt;= 1">period: maximum cardinality of 'period' is 1</sch:assert>
+    </sch:rule>
+  </sch:pattern>
+  <sch:pattern>
+    <sch:title>f:Patient/f:contact/f:address/f:extension</sch:title>
+    <sch:rule context="f:Patient/f:contact/f:address/f:extension">
+      <sch:assert test="count(f:id) &lt;= 1">id: maximum cardinality of 'id' is 1</sch:assert>
+      <sch:assert test="count(f:url) &gt;= 1">url: minimum cardinality of 'url' is 1</sch:assert>
+      <sch:assert test="count(f:url) &lt;= 1">url: maximum cardinality of 'url' is 1</sch:assert>
+      <sch:assert test="count(f:value[x]) &gt;= 1">value[x]: minimum cardinality of 'value[x]' is 1</sch:assert>
+      <sch:assert test="count(f:value[x]) &lt;= 1">value[x]: maximum cardinality of 'value[x]' is 1</sch:assert>
+    </sch:rule>
+  </sch:pattern>
+  <sch:pattern>
+    <sch:title>f:Patient/f:communication/f:language</sch:title>
+    <sch:rule context="f:Patient/f:communication/f:language">
+      <sch:assert test="count(f:id) &lt;= 1">id: maximum cardinality of 'id' is 1</sch:assert>
+      <sch:assert test="count(f:extension[@url = 'http://hl7.org/fhir/StructureDefinition/data-absent-reason']) &lt;= 1">extension with URL = 'http://hl7.org/fhir/StructureDefinition/data-absent-reason': maximum cardinality of 'extension' is 1</sch:assert>
+      <sch:assert test="count(f:text) &lt;= 1">text: maximum cardinality of 'text' is 1</sch:assert>
+    </sch:rule>
+  </sch:pattern>
+  <sch:pattern>
+    <sch:title>f:Patient/f:communication/f:language/f:extension</sch:title>
+    <sch:rule context="f:Patient/f:communication/f:language/f:extension">
+      <sch:assert test="count(f:id) &lt;= 1">id: maximum cardinality of 'id' is 1</sch:assert>
+      <sch:assert test="count(f:url) &gt;= 1">url: minimum cardinality of 'url' is 1</sch:assert>
+      <sch:assert test="count(f:url) &lt;= 1">url: maximum cardinality of 'url' is 1</sch:assert>
+      <sch:assert test="count(f:value[x]) &gt;= 1">value[x]: minimum cardinality of 'value[x]' is 1</sch:assert>
+      <sch:assert test="count(f:value[x]) &lt;= 1">value[x]: maximum cardinality of 'value[x]' is 1</sch:assert>
+    </sch:rule>
+  </sch:pattern>
+</sch:schema>

data/lib/cancer_registry_reporting_test_kit/igs/package/xml/StructureDefinition-us-ph-tribal-affiliation-extension.sch

@@ -0,0 +1,36 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<sch:schema xmlns:sch="http://purl.oclc.org/dsdl/schematron" queryBinding="xslt2">
+  <sch:ns prefix="f" uri="http://hl7.org/fhir"/>
+  <sch:ns prefix="h" uri="http://www.w3.org/1999/xhtml"/>
+  <!-- 
+    This file contains just the constraints for the profile Extension
+    It includes the base constraints for the resource as well.
+    Because of the way that schematrons and containment work, 
+    you may need to use this schematron fragment to build a, 
+    single schematron that validates contained resources (if you have any) 
+  -->
+  <sch:pattern>
+    <sch:title>f:Extension</sch:title>
+    <sch:rule context="f:Extension">
+      <sch:assert test="count(f:extension[@url = 'TribeName']) &gt;= 1">extension with URL = 'TribeName': minimum cardinality of 'extension' is 1</sch:assert>
+      <sch:assert test="count(f:extension[@url = 'TribeName']) &lt;= 1">extension with URL = 'TribeName': maximum cardinality of 'extension' is 1</sch:assert>
+      <sch:assert test="count(f:extension[@url = 'EnrolledTribeMember']) &lt;= 1">extension with URL = 'EnrolledTribeMember': maximum cardinality of 'extension' is 1</sch:assert>
+      <sch:assert test="count(f:value[x]) &lt;= 0">value[x]: maximum cardinality of 'value[x]' is 0</sch:assert>
+    </sch:rule>
+  </sch:pattern>
+  <sch:pattern>
+    <sch:title>f:Extension/f:extension</sch:title>
+    <sch:rule context="f:Extension/f:extension">
+      <sch:assert test="count(f:id) &lt;= 1">id: maximum cardinality of 'id' is 1</sch:assert>
+      <sch:assert test="count(f:url) &gt;= 1">url: minimum cardinality of 'url' is 1</sch:assert>
+      <sch:assert test="count(f:url) &lt;= 1">url: maximum cardinality of 'url' is 1</sch:assert>
+      <sch:assert test="count(f:value[x]) &gt;= 1">value[x]: minimum cardinality of 'value[x]' is 1</sch:assert>
+      <sch:assert test="count(f:value[x]) &lt;= 1">value[x]: maximum cardinality of 'value[x]' is 1</sch:assert>
+      <sch:assert test="count(f:id) &lt;= 1">id: maximum cardinality of 'id' is 1</sch:assert>
+      <sch:assert test="count(f:url) &gt;= 1">url: minimum cardinality of 'url' is 1</sch:assert>
+      <sch:assert test="count(f:url) &lt;= 1">url: maximum cardinality of 'url' is 1</sch:assert>
+      <sch:assert test="count(f:value[x]) &gt;= 1">value[x]: minimum cardinality of 'value[x]' is 1</sch:assert>
+      <sch:assert test="count(f:value[x]) &lt;= 1">value[x]: maximum cardinality of 'value[x]' is 1</sch:assert>
+    </sch:rule>
+  </sch:pattern>
+</sch:schema>

data/lib/cancer_registry_reporting_test_kit/metadata.rb

@@ -0,0 +1,71 @@
+require_relative 'version'
+
+module CancerRegistryReportingTestKit
+  class Metadata < Inferno::TestKit
+    id :cancer_registry_reporting_test_kit
+    title 'Central Cancer Registry Reporting IG Test Kit'
+    description <<~DESCRIPTION
+
+      The Central Cancer Registry Reporting (CCRR) Test Kit is a testing tool for Health IT systems
+      seeking to meet the requirements of the STU 1.0.0 version of the HL7® FHIR®
+      [Central Cancer Registry Reporting IG](https://hl7.org/fhir/us/central-cancer-registry-reporting/STU1/).
+
+      <!-- break -->
+
+      This test kit currently contains suites that verify the conformance of systems playing the following roles:
+      - **Health Data Exchange App (HDEA) Report Generator**: Verifies that the Health IT system can generate
+        conformant and complete reports to send to a cancer registry.
+      - **Electronic Health Record (EHR) Data Source**: Verifies that the Health IT system can respond to queries
+        for the data needed to create a cancer registry report.
+
+      ## Status
+
+      These tests are a **DRAFT** intended to allow CCRR IG implementers to
+      perform preliminary checks of their implementations against the IG's requirements and provide feedback
+      on the tests. Future versions of these tests may validate other requirements and may change how these
+      are tested.
+
+      ## Known Limitations
+
+      This test kit does not currently include test suites for all actors and all capabilities defined by the CCRR IG.
+      Out of scope areas of the IG include the Cancer Registry and Trusted Third Party actors and details related to the use of the
+      [MedMorph framework](https://hl7.org/fhir/us/medmorph/STU1/) by all actors to coordinate reporting triggering,
+      report content, and report delivery requirements.
+
+      The existing HDEA and EHR suites focus on report content and do not currently test most details of
+      the report exchange workflow. The following areas are not tested:
+      - EHR requirements around authentication and authorization and the use of Subscriptions to provide
+        notifications to HDEAs.
+      - HDEA requirements around the gathering of report contents from EHRs and the delivery of completed reports
+        using FHIR APIs.
+
+      For additional details on suite-specific limitations, see the suite documention in the running tests or the
+      corresponding content in the source repository ([EHR suite limitations](https://github.com/inferno-framework/cancer-registry-reporting-test-kit/blob/main/lib/cancer_registry_reporting_test_kit/docs/ehr_suite_description.md#current-limitations),
+      [HDEA suite limitations](https://github.com/inferno-framework/cancer-registry-reporting-test-kit/blob/main/lib/cancer_registry_reporting_test_kit/docs/hdea_suite_description.md#current-limitations))
+
+      ## Repository and Resources
+
+      The Central Cancer Registry Reporting Test Kit can be [downloaded](https://github.com/inferno-framework/cancer-registry-reporting-test-kit/releases)
+      from its [GitHub repository](https://github.com/inferno-framework/cancer-registry-reporting-test-kit).
+
+      ## Providing Feedback and Reporting Issues
+
+      We welcome feedback on the tests, including but not limited to the following areas:
+      - Validation logic, such as potential bugs, lax checks, and unexpected failures.
+      - Requirements coverage, such as requirements that have been missed, tests that necessitate features that the
+        IG does not require, or other issues with the interpretation of the IG’s requirements.
+      - User experience, such as confusing or missing information in the test UI.
+
+      Please report any issues with this set of tests in the [issues section](https://github.com/inferno-framework/cancer-registry-reporting-test-kit/issues)
+      of the repository.
+
+    DESCRIPTION
+    suite_ids [:ccrr_v100_report_generation, :ccrr_ehr]
+    tags []
+    last_updated LAST_UPDATED
+    version VERSION
+    maturity 'Low'
+    authors ['MITRE Inferno Team']
+    repo 'https://github.com/inferno-framework/cancer-registry-reporting-test-kit'
+  end
+end

data/lib/cancer_registry_reporting_test_kit/must_support_test.rb

@@ -0,0 +1,263 @@
+# frozen_string_literal: true
+
+require_relative 'fhir_resource_navigation'
+require_relative 'bundle_parse'
+
+module CancerRegistryReportingTestKit
+  module MustSupportTest
+    extend Forwardable
+    include FHIRResourceNavigation
+    include HDEABundleParse
+
+    def_delegators 'self.class', :metadata
+
+    def all_scratch_resources
+      scratch_resources[:all]
+    end
+
+    def perform_must_support_test(resources)
+      skip_if resources.blank?, "No #{resource_type} resources were found"
+
+      missing_elements(resources)
+      missing_slices(resources)
+      missing_extensions(resources)
+
+      handle_must_support_choices if metadata.must_supports[:choices].present?
+
+      skip_if (missing_elements + missing_slices + missing_extensions).present?, 
+        "Could not find #{missing_must_support_strings.join(', ')} in the #{resources.length} " \
+        "provided #{resource_type} resource(s)"
+    end
+
+    def handle_must_support_choices
+      missing_elements.delete_if do |element|
+        choices = metadata.must_supports[:choices].find { |choice| choice[:paths]&.include?(element[:path]) }
+        is_any_choice_supported?(choices)
+      end
+
+      missing_extensions.delete_if do |extension|
+        choices = metadata.must_supports[:choices].find { |choice| choice[:extension_ids]&.include?(extension[:id]) }
+        is_any_choice_supported?(choices)
+      end
+
+      missing_slices.delete_if do |slice|
+        choices = metadata.must_supports[:choices].find { |choice| choice[:slice_names]&.include?(slice[:name]) }
+        is_any_choice_supported?(choices)
+      end
+    end
+
+    def is_any_choice_supported?(choices)
+      choices.present? &&
+        (
+          choices[:paths]&.any? { |path| missing_elements.none? { |element| element[:path] == path } } ||
+          choices[:extension_ids]&.any? do |extension_id|
+            missing_extensions.none? do |extension|
+              extension[:id] == extension_id
+            end
+          end ||
+          choices[:slice_names]&.any? { |slice_name| missing_slices.none? { |slice| slice[:name] == slice_name } }
+        )
+    end
+
+    def missing_must_support_strings
+      missing_elements.map { |element_definition| missing_element_string(element_definition) } +
+        missing_slices.map { |slice_definition| slice_definition[:slice_id] } +
+        missing_extensions.map { |extension_definition| extension_definition[:id] }
+    end
+
+    def missing_element_string(element_definition)
+      if element_definition[:fixed_value].present?
+        "#{element_definition[:path]}:#{element_definition[:fixed_value]}"
+      else
+        element_definition[:path]
+      end
+    end
+
+    def exclude_uscdi_only_test?
+      config.options[:exclude_uscdi_only_test] == true
+    end
+
+    def must_support_extensions
+      if exclude_uscdi_only_test?
+        metadata.must_supports[:extensions].reject { |extension| extension[:uscdi_only] }
+      else
+        metadata.must_supports[:extensions]
+      end
+    end
+
+    def missing_extensions(resources = [])
+      @missing_extensions ||=
+        must_support_extensions.select do |extension_definition|
+          resources.none? do |resource|
+            path = extension_definition[:path]
+
+            if path == 'extension'
+              resource.extension.any? { |extension| extension.url == extension_definition[:url] }
+            else
+              extension = find_a_value_at(resource, path) do |el|
+                el.url == extension_definition[:url]
+              end
+
+              extension.present?
+            end
+          end
+        end
+    end
+
+    def must_support_elements
+      if exclude_uscdi_only_test?
+        metadata.must_supports[:elements].reject { |element| element[:uscdi_only] }
+      else
+        metadata.must_supports[:elements]
+      end
+    end
+
+    def missing_elements(resources = [])
+      @missing_elements ||= find_missing_elements(resources, must_support_elements)
+      @missing_elements
+    end
+
+    def find_missing_elements(resources, must_support_elements)
+      must_support_elements.select do |element_definition|
+        resources.none? do |resource|
+          path = element_definition[:path]
+          ms_extension_urls = must_support_extensions.select { |ex| ex[:path] == "#{path}.extension" }
+            .map { |ex| ex[:url] }
+
+          value_found = find_a_value_at(resource, path) do |value|
+            if value.instance_of?(CancerRegistryReportingTestKit::PrimitiveType) && ms_extension_urls.present?
+              urls = value.extension&.map(&:url)
+              has_ms_extension = (urls & ms_extension_urls).present?
+            end
+
+            unless has_ms_extension
+              value = value.value if value.instance_of?(CancerRegistryReportingTestKit::PrimitiveType)
+              value_without_extensions =
+                value.respond_to?(:to_hash) ? value.to_hash.except('extension') : value
+            end
+
+            (has_ms_extension || value_without_extensions.present? || value_without_extensions == false) &&
+              (element_definition[:fixed_value].blank? || value == element_definition[:fixed_value])
+          end
+          # Note that false.present? => false, which is why we need to add this extra check
+          value_found.present? || value_found == false
+        end
+      end
+    end
+
+    def must_support_slices
+      if exclude_uscdi_only_test?
+        metadata.must_supports[:slices].reject { |slice| slice[:uscdi_only] }
+      else
+        metadata.must_supports[:slices]
+      end
+    end
+
+    def missing_slices(resources = [])
+      @missing_slices ||=
+        must_support_slices.select do |slice|
+          resources.none? do |resource|
+            path = slice[:path] # .delete_suffix('[x]')
+            find_slice(resource, path, slice[:discriminator]).present?
+          end
+        end
+    end
+
+    def find_slice(resource, path, discriminator)
+      find_a_value_at(resource, path) do |element|
+        case discriminator[:type]
+        when 'patternCodeableConcept'
+          coding_path = discriminator[:path].present? ? "#{discriminator[:path]}.coding" : 'coding'
+          find_a_value_at(element, coding_path) do |coding|
+            coding.code == discriminator[:code] && coding.system == discriminator[:system]
+          end
+        when 'patternCoding'
+          coding_path = discriminator[:path].present? ? discriminator[:path] : ''
+          find_a_value_at(element, coding_path) do |coding|
+            coding.code == discriminator[:code] && coding.system == discriminator[:system]
+          end
+        when 'patternIdentifier'
+          find_a_value_at(element, discriminator[:path]) { |identifier| identifier.system == discriminator[:system] }
+        when 'value'
+          values = discriminator[:values].map { |value| value.merge(path: value[:path].split('.')) }
+          find_slice_by_values(element, values)
+        when 'type'
+          case discriminator[:code]
+          when 'Date'
+            begin
+              Date.parse(element)
+            rescue ArgumentError
+              false
+            end
+          when 'DateTime'
+            begin
+              DateTime.parse(element)
+            rescue ArgumentError
+              false
+            end
+          when 'String'
+            element.is_a? String
+          else
+            if element.is_a? FHIR::Bundle::Entry
+              element.resource.is_a? FHIR.const_get(discriminator[:code])
+            else
+              element.is_a? FHIR.const_get(discriminator[:code])
+            end
+          end
+        when 'requiredBinding'
+          coding_path = discriminator[:path].present? ? "#{discriminator[:path]}.coding" : 'coding'
+
+          ## SPECIAL CASE ##
+          # only checking ODH MS slices for codesystem, not codes, given large number of codes
+          if metadata.profile_url == 'http://hl7.org/fhir/us/odh/StructureDefinition/odh-UsualWork'
+            get_slice_by_codesystem(element, discriminator)
+          else
+            find_a_value_at(element, coding_path) do |coding|
+              discriminator[:values].any? { |value| value[:system] == coding.system && value[:code] == coding.code }
+            end
+          end
+        end
+      end
+    end
+
+    ## special case ##
+
+    def get_slice_by_codesystem(element, discriminator)
+      find_a_value_at(element, '') do |coding|
+        discriminator[:values].any? { |value| coding.system.include? value[:system] }
+      end
+    end
+
+    ## end special case ##
+
+    def find_slice_by_values(element, value_definitions)
+      path_prefixes = value_definitions.map { |value_definition| value_definition[:path].first }.uniq
+      Array.wrap(element).find do |el|
+        path_prefixes.all? do |path_prefix|
+          value_definitions_for_path =
+            value_definitions
+              .select { |value_definition| value_definition[:path].first == path_prefix }
+              .each { |value_definition| value_definition[:path].shift }
+
+          find_a_value_at(el, path_prefix) do |el_found|
+            child_element_value_definitions, current_element_value_definitions =
+              value_definitions_for_path.partition { |value_definition| value_definition[:path].present? }
+
+            current_element_values_match =
+              current_element_value_definitions
+                .all? { |value_definition| value_definition[:value].to_s == el_found.to_s }
+
+            child_element_values_match =
+              if child_element_value_definitions.present?
+                find_slice_by_values(el_found, child_element_value_definitions)
+              else
+                true
+              end
+
+            current_element_values_match && child_element_values_match
+          end
+        end
+      end
+    end
+  end
+end

data/lib/cancer_registry_reporting_test_kit/primitive_type.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+module CancerRegistryReportingTestKit
+  class PrimitiveType < FHIR::Element
+    attr_accessor :value
+  end
+end