cancer_pathology_data_sharing_test_kit 0.9.0

data/lib/cancer_pathology_data_sharing_test_kit/must_support_test.rb

@@ -0,0 +1,239 @@
+require_relative 'fhir_resource_navigation'
+
+module CancerPathologyDataSharingTestKit
+  module MustSupportTest
+    extend Forwardable
+    include FHIRResourceNavigation
+
+    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?
+
+      assert (missing_elements + missing_slices + missing_extensions).empty?, "Could not find #{missing_must_support_strings.join(', ')} " \
+                                                                              "in the #{resources.length} " \
+                                                                              "provided #{resource_type} resource(s)"
+    end
+
+    def handle_must_support_choices # rubocop:disable Metrics/CyclomaticComplexity
+      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) # rubocop:disable Metrics/CyclomaticComplexity,Naming/PredicateName
+      choices.present? &&
+        (
+          choices[:paths]&.any? { |path| missing_elements.none? { |element| element[:path] == path } } ||
+          choices[:extension_ids]&.any? { |extension_id| missing_extensions.none? { |extension| extension[:id] == extension_id } } ||
+          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) # rubocop:disable Metrics/CyclomaticComplexity
+      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?(CancerPathologyDataSharingTestKit::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?(CancerPathologyDataSharingTestKit::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) # rubocop:disable Metrics/CyclomaticComplexity
+      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.resourceType == discriminator[:code]
+            else
+              element.is_a? FHIR.const_get(discriminator[:code])
+            end
+          end
+        when 'requiredBinding'
+          coding_path = discriminator[:path].present? ? "#{discriminator[:path]}.coding" : 'coding'
+
+          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
+
+    def find_slice_by_values(element, value_definitions) # rubocop:disable Metrics/CyclomaticComplexity
+      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] == el_found }
+
+            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_pathology_data_sharing_test_kit/primitive_type.rb

@@ -0,0 +1,5 @@
+module CancerPathologyDataSharingTestKit
+  class PrimitiveType < FHIR::Element
+    attr_accessor :value
+  end
+end

data/lib/cancer_pathology_data_sharing_test_kit/report_generation_suite/data_absent/data_absent_reason_code_system.rb

@@ -0,0 +1,22 @@
+module CancerPathologyDataSharingTestKit
+  class DataAbsentReasonCodeSystem < Inferno::Test
+    id :cpds_data_absent_reason_code_system
+    title 'Server represents missing data with the DataAbsentReason CodeSystem'
+    description %(
+            For coded data elements with example, preferred, or extensible binding
+            strengths to ValueSets which do not include an appropriate "unknown"
+            code, servers SHALL use the "unknown" code from the DataAbsentReason
+            CodeSystem.
+        )
+    input :dar_code_found,
+          title: 'Data Absent Reason CodeSystem Found',
+          locked: true,
+          optional: true,
+          default: 'false'
+
+    run do
+      assert dar_code_found == 'true',
+             'No resources using the DataAbsentReason CodeSystem have been found'
+    end
+  end
+end

data/lib/cancer_pathology_data_sharing_test_kit/report_generation_suite/data_absent/data_absent_reason_extension.rb

@@ -0,0 +1,20 @@
+module CancerPathologyDataSharingTestKit
+  class DataAbsentReasonExtension < Inferno::Test
+    id :cpds_data_absent_reason_extension
+    title 'Server represents missing data with the DataAbsentReason Extension'
+    description %(
+            For non-coded data elements, servers SHALL use the DataAbsentReason
+            Extension to represent missing data in a required field
+        )
+    input :dar_extension_found,
+          title: 'Data Absent Reason Extension Found',
+          locked: true,
+          optional: true,
+          default: 'false'
+
+    run do
+      assert dar_extension_found == 'true',
+             'No resources using the DataAbsentReason Extension have been found'
+    end
+  end
+end

data/lib/cancer_pathology_data_sharing_test_kit/report_generation_suite/data_absent/sending_hide_missing.rb

@@ -0,0 +1,28 @@
+module CancerPathologyDataSharingTestKit
+  class SendingHideMissing < Inferno::Test
+    id :cpds_data_absent_sending_hide_missing
+    title 'Sender does not send data element(s) with missing information'
+    description %(
+        In situations where information on a particular data element is not present, the Sender SHALL NOT include the data element
+       in the resource instance if the cardinality is 0..n.
+      )
+
+    run do
+      identifier = SecureRandom.hex(32)
+      wait(
+        identifier:,
+        message: <<~MESSAGE
+          The system under test has demonstrated that it meets the following [requirement](https://hl7.org/fhir/us/cancer-reporting/STU1.0.1/specification.html#must-support-and-missing-data):
+
+          [Specifically](https://hl7.org/fhir/us/cancer-reporting/STU1.0.1/specification.html#must-support-and-missing-data)
+
+          > Sending Systems [of the [US Pathology Bundle](https://hl7.org/fhir/us/cancer-reporting/STU1.0.1/StructureDefinition-us-pathology-exchange-bundle.html)] In situations where information on a particular data element is not present, the Sender SHALL NOT include the data element in the resource instance if the cardinality is 0..n.
+
+          [Click here](#{resume_pass_url}?token=#{identifier}) if the system **meets** this requirement.
+
+          [Click here](#{resume_fail_url}?token=#{identifier}) if the system **does not meet** this requirement.
+        MESSAGE
+      )
+    end
+  end
+end

data/lib/cancer_pathology_data_sharing_test_kit/report_generation_suite/data_absent_group.rb

@@ -0,0 +1,27 @@
+require_relative 'data_absent/sending_hide_missing'
+require_relative 'data_absent/data_absent_reason_extension'
+require_relative 'data_absent/data_absent_reason_code_system'
+
+module CancerPathologyDataSharingTestKit
+  class DataAbsentGroup < Inferno::TestGroup
+    id :cpds_data_absent_reason
+    title 'Missing Data Tests'
+    short_description 'Verify that the server is capable of representing missing data.'
+
+    description %(
+      The [CPDS Missing Data
+      Guidance](https://hl7.org/fhir/us/cancer-reporting/STU1.0.1/specification.html#must-support-and-missing-data)
+      gives instructions on how to represent various types of missing data.
+
+      In the previous resource tests, each resource returned from the server was
+      checked for the presence of missing data. These tests will pass if the
+      specified method of representing missing data was observed in the earlier
+      tests.
+    )
+    run_as_group
+
+    test from: :cpds_data_absent_sending_hide_missing
+    test from: :cpds_data_absent_reason_extension
+    test from: :cpds_data_absent_reason_code_system
+  end
+end

data/lib/cancer_pathology_data_sharing_test_kit/report_generation_suite/exchange_bundle/encounter/encounter_must_support_test.rb

@@ -0,0 +1,53 @@
+require_relative '../../../must_support_test'
+require_relative '../../../group_metadata'
+
+module CancerPathologyDataSharingTestKit
+  module V101
+    class EncounterMustSupportTest < Inferno::Test
+      include CancerPathologyDataSharingTestKit::MustSupportTest
+
+      title 'All must support elements are provided in the US Core Encounter resources'
+      description %(
+        Report generators SHALL be capable of populating all must support data elements
+        defined in the [US Pathology ExchangeBundle profile](https://hl7.org/fhir/us/cancer-reporting/STU1.0.1/StructureDefinition-us-pathology-exchange-bundle.html)
+        and profiles it references. This test will look through the Encounter resources
+        found in the provided report Bundles for the following must support elements:
+
+        * Encounter.class
+        * Encounter.hospitalization
+        * Encounter.hospitalization.dischargeDisposition
+        * Encounter.identifier
+        * Encounter.identifier.system
+        * Encounter.identifier.value
+        * Encounter.location
+        * Encounter.location.location
+        * Encounter.participant
+        * Encounter.participant.individual
+        * Encounter.participant.period
+        * Encounter.participant.type
+        * Encounter.period
+        * Encounter.reasonCode
+        * Encounter.status
+        * Encounter.subject
+        * Encounter.type
+      )
+
+      id :cpds_v101_us_core_v311_encounter_must_support_test
+
+      def resource_type
+        'Encounter'
+      end
+
+      def self.metadata
+        @metadata ||= GroupMetadata.new(YAML.load_file(File.join(__dir__, 'metadata.yml'), aliases: true))
+      end
+
+      run do
+        all_resources = scratch[:cpds_resources]&.values&.map do |bundle_resources|
+          bundle_resources['Encounter'] || []
+        end
+        perform_must_support_test(all_resources&.flatten)
+      end
+    end
+  end
+end

data/lib/cancer_pathology_data_sharing_test_kit/report_generation_suite/exchange_bundle/encounter/encounter_validation_test.rb

@@ -0,0 +1,48 @@
+require_relative '../../../bundle_parse'
+require_relative '../../../validation_test'
+
+module CancerPathologyDataSharingTestKit
+  class EncounterValidationTest < Inferno::Test
+    include CancerPathologyDataSharingTestKit::ValidationTest
+    include CancerPathologyDataSharingTestKit::BundleParse
+
+    title 'Encounter resource in each bundle conforms to the US Core Encounter profile'
+    description %(
+    This test verifies that any Encounter resource returned from each bundle conforms to
+    the [US Core Encounter Profile](http://hl7.org/fhir/us/core/StructureDefinition/us-core-encounter).
+
+    It verifies the presence of mandatory elements and that elements with
+    required bindings contain appropriate values. CodeableConcept element
+    bindings will fail if none of their codings have a code/system belonging
+    to the bound ValueSet. Quantity, Coding, and code element bindings will
+    fail if their code/system are not found in the valueset.
+    )
+
+    id :cpds_encounter_validation_test
+
+    def resource_type
+      'Encounter'
+    end
+
+    output :dar_code_found, :dar_extension_found
+
+    run do
+      invalid_bundles = []
+      total_resources = 0
+      scratch[:cpds_resources].each do |bundle_id, bundle_resources|
+        resources = bundle_resources['Encounter'] || []
+        total_resources += resources.length
+
+        profile_url = PE_BUNDLE_SLICE_RESOURCES['Encounter']
+        invalid_bundles << bundle_id if perform_strict_validation_test('Encounter', bundle_id, resources, profile_url,
+                                                                       '5.0.1', skip_if_empty: false,
+                                                                                restriction: 'no_more_than_one')
+      end
+
+      skip_if total_resources.zero?,
+              "No #{resource_type} resources found in any of the given bundles"
+
+      check_for_errors(invalid_bundles)
+    end
+  end
+end