cancer_registry_reporting_test_kit 0.9.0

data/lib/cancer_registry_reporting_test_kit/ehr_suite/mcode_data_access_resources/tnm_stage_group/tnm_stage_group_validation_test.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+require_relative '../../../validation_test'
+
+module CancerRegistryReportingTestKit
+  class TNMStageGroupValidationTest < Inferno::Test
+    include CancerRegistryReportingTestKit::ValidationTest
+
+    id :ccrr_tnm_stage_group_validation_test
+    title 'Observation resources returned during previous tests conform to the mCODE TNM Stage Group profile'
+    description %(
+        This test verifies resources returned from the first search conform to
+        the [mCODE TNM Stage Group Profile](https://hl7.org/fhir/us/mcode/STU3/StructureDefinition-mcode-tnm-stage-group.html).
+        Systems must demonstrate at least one valid example in order to pass this test.
+
+        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.
+
+      )
+
+    def resource_type
+      'Observation'
+    end
+
+    def scratch_resources
+      scratch[:tnm_stage_group_resources] ||= {}
+    end
+
+    run do
+      perform_validation_test(scratch_resources[:all] || [],
+                              'http://hl7.org/fhir/us/mcode/StructureDefinition/mcode-tnm-stage-group',
+                              '3.0.0',
+                              skip_if_empty: true)
+    end
+  end
+end

data/lib/cancer_registry_reporting_test_kit/ehr_suite/mcode_data_access_resources/tnm_stage_group_group.rb

@@ -0,0 +1,72 @@
+# frozen_string_literal: true
+
+require_relative 'tnm_stage_group/tnm_stage_group_search_test'
+require_relative 'tnm_stage_group/tnm_stage_group_must_support_test'
+require_relative 'tnm_stage_group/tnm_stage_group_validation_test'
+
+module CancerRegistryReportingTestKit
+  class EHRTNMStageGroupTests < Inferno::TestGroup
+    title 'mCODE TNM Stage Group'
+    description %(
+      # Background
+      The mCODE TNM Stage Group Profile group verifies that the system under test is
+      able to provide correct responses for TNM Stage Group Observation queries. These queries
+      return resources conforming to the [mCODE TNM Stage Group Profile](https://hl7.org/fhir/us/mcode/STU3/StructureDefinition-mcode-tnm-stage-group.html)
+      as specified in the mCODE v3.0.0 Implementation Guide.
+
+      # Testing Methodology
+      ## Searching
+      This test sequence will first perform each required search associated
+      with this resource. This sequence will perform searches with the
+      following parameters:
+
+      * patient + code
+
+      ### Search Parameters
+      The first search uses values from the **Patient IDs** and
+      **TNM Stage Group code** inputs as provided by the tester.
+      Any subsequent searches will look for its parameter values
+      from the results of the first search. For example, the `identifier`
+      search in the patient sequence is performed by looking for an existing
+      `Patient.identifier` from any of the resources returned in the first
+      search. If a value cannot be found this way, the search is skipped.
+
+      ### Search Validation
+      Inferno will retrieve up to the first 20 bundle pages of the reply for
+      Observation resources and save them for subsequent tests. Each of
+      these resources is then checked to see if it matches the searched
+      parameters in accordance with [FHIR search
+      guidelines](https://www.hl7.org/fhir/search.html). The test will fail,
+      for example, if a Patient search for `gender=male` returns a `female`
+      patient.
+
+
+      ## Must Support
+      Each profile contains elements marked as "must support". This test
+      sequence expects to see each of these elements at least once. If at
+      least one cannot be found, the test will fail. The test will look
+      through the Observation resources found in the first test for these
+      elements.
+
+      ## Profile Validation
+      Each resource returned from the first search is expected to conform to
+      the [mCODE TNM Stage Group Profile](https://hl7.org/fhir/us/mcode/STU3/StructureDefinition-mcode-tnm-stage-group.html).
+      Each element is checked against terminology binding and cardinality requirements.
+
+      Elements with a required binding are validated against their bound
+      ValueSet. If the code/system in the element is not part of the ValueSet,
+      then the test will fail.
+    )
+    id :ccrr_ehr_tnm_stage_group
+    run_as_group
+
+    def self.metadata
+      @metadata ||= HdeaGenerator::GroupMetadata.new(YAML.load_file(
+                                                       File.join(__dir__, 'tnm_stage_group', 'metadata.yml'), aliases: true
+                                                     ))
+    end
+    test from: :ccrr_tnm_stage_group_search_test
+    test from: :ccrr_tnm_stage_group_validation_test
+    test from: :ccrr_tnm_stage_group_must_support_test
+  end
+end

data/lib/cancer_registry_reporting_test_kit/ehr_suite.rb

@@ -0,0 +1,69 @@
+# frozen_string_literal: true
+
+require_relative 'ehr_suite/ehr_data_access_group'
+module CancerRegistryReportingTestKit
+  class EHRSuite < Inferno::TestSuite
+    id :ccrr_ehr
+    title 'Cancer Registry Reporting Electronic Health Record (EHR) Test Suite'
+    short_title 'EHR Cancer Registry Reporting'
+    description File.read(File.join(__dir__, 'docs', 'ehr_suite_description.md'))
+    links [
+      {
+        label: 'Report Issue',
+        url: 'https://github.com/inferno-framework/cancer-registry-reporting-test-kit/issues/'
+      },
+      {
+        label: 'Open Source',
+        url: 'https://github.com/inferno-framework/cancer-registry-reporting-test-kit/'
+      },
+      {
+        label: 'Download',
+        url: 'https://github.com/inferno-framework/cancer-registry-reporting-test-kit/releases'
+      },
+      {
+        label: 'Implementation Guide',
+        url: 'https://hl7.org/fhir/us/central-cancer-registry-reporting/STU1/'
+      }
+    ]
+
+    GENERAL_MESSAGE_FILTERS = [
+      %r{Sub-extension url 'introspect' is not defined by the Extension http://fhir-registry\.smarthealthit\.org/StructureDefinition/oauth-uris},
+      %r{Sub-extension url 'revoke' is not defined by the Extension http://fhir-registry\.smarthealthit\.org/StructureDefinition/oauth-uris},
+      /Observation\.effective\.ofType\(Period\): .*vs-1:/, # Invalid invariant in FHIR v4.0.1
+      /Observation\.effective\.ofType\(Period\): .*us-core-1:/, # Invalid invariant in US Core v3.1.1
+      /Provenance.agent\[\d*\]: Constraint failed: provenance-1/, # Invalid invariant in US Core v5.0.1
+      %r{Unknown Code System 'http://hl7.org/fhir/us/core/CodeSystem/us-core-tags'}, # Validator has an issue
+      # with this US Core 5 code system in US Core 6 resource
+      %r{URL value 'http://hl7.org/fhir/us/core/CodeSystem/us-core-tags' does not resolve}, # Validator has an issue with
+      # this US Core 5 code system in US Core 6 resource
+      /\A\S+: \S+: URL value '.*' does not resolve/,
+      %r{Observation.component\[\d+\].value.ofType\(Quantity\): The code provided \(http://unitsofmeasure.org#L/min\) was not found in the value set
+      'Vital Signs Units'} # Known issue with the Pulse Oximetry Profile
+    ].freeze
+
+    VERSION_SPECIFIC_MESSAGE_FILTERS = [].freeze
+
+    VALIDATION_MESSAGE_FILTERS = GENERAL_MESSAGE_FILTERS + VERSION_SPECIFIC_MESSAGE_FILTERS
+
+    def self.metadata
+      @metadata ||= YAML.load_file(File.join(__dir__, 'metadata.yml'), aliases: true)[:groups].map do |raw_metadata|
+        HdeaGenerator::GroupMetadata.new(raw_metadata)
+      end
+    end
+
+    fhir_resource_validator do
+      igs 'hl7.fhir.us.central-cancer-registry-reporting#1.0.0'
+      message_filters = VALIDATION_MESSAGE_FILTERS
+
+      exclude_message do |message|
+        message_filters.any? { |filter| filter.match? message.message }
+      end
+
+      perform_additional_validation do |resource, _profile_url|
+        USCoreTestKit::ProvenanceValidator.validate(resource) if resource.instance_of?(FHIR::Provenance)
+      end
+    end
+
+    group from: :ccrr_ehr_data_access
+  end
+end

data/lib/cancer_registry_reporting_test_kit/fhir_resource_navigation.rb

@@ -0,0 +1,174 @@
+# frozen_string_literal: true
+
+require_relative 'primitive_type'
+
+module CancerRegistryReportingTestKit
+  module FHIRResourceNavigation
+    DAR_EXTENSION_URL = 'http://hl7.org/fhir/StructureDefinition/data-absent-reason'
+    PRIMITIVE_DATA_TYPES = FHIR::PRIMITIVES.keys
+
+    def resolve_path(elements, path)
+      elements = Array.wrap(elements)
+      return elements if path.blank?
+
+      paths = path.split(/(?<!hl7)\./)
+      segment = paths.first
+      remaining_path = paths.drop(1).join('.')
+
+      elements.flat_map do |element|
+        child = get_next_value(element, segment)
+        resolve_path(child, remaining_path)
+      end.compact
+    end
+
+    def find_a_value_at(element, path, include_dar: false, &block)
+      return nil if element.nil?
+
+      elements = Array.wrap(element)
+      if path.empty?
+        unless include_dar
+          elements = elements.reject do |el|
+            el.respond_to?(:extension) && el.extension.any? { |ext| ext.url == DAR_EXTENSION_URL }
+          end
+        end
+
+        return elements.find(&block) if block_given?
+
+        return elements.first
+      end
+
+      path_segments = path.split(/(?<!hl7)\./)
+
+      ## special case: .gsub(':odh-UsualIndustry', '') 
+      # accounts for path traversal for Usual Work ODH profile
+      segment = path_segments.shift.delete_suffix('[x]').gsub(/^class$/, 'local_class').gsub(/^method$/, 'local_method').gsub(
+        '[x]:', ':').gsub(':odh-UsualIndustry', '').to_sym
+      no_elements_present =
+        elements.none? do |element|
+          child = get_next_value(element, segment)
+          child.present? || child == false
+        end
+      return nil if no_elements_present
+
+      remaining_path = path_segments.join('.')
+      elements.each do |element|
+        child = get_next_value(element, segment)
+        element_found =
+          if block_given?
+            find_a_value_at(child, remaining_path, include_dar: include_dar, &block)
+          else
+            find_a_value_at(child, remaining_path, include_dar: include_dar)
+          end
+        return element_found if element_found.present? || element_found == false
+      end
+
+      nil
+    end
+
+    def get_next_value(element, property)
+      extension_url = property[/(?<=where\(url=').*(?='\))/]
+      if extension_url.present?
+        element.url == extension_url ? element : nil
+      elsif property.to_s.include?(':') && !property.to_s.include?('url')
+        find_slice_via_discriminator(element, property)
+
+      else
+        value = element.send(property)
+        primitive_value = get_primitive_type_value(element, property, value)
+        primitive_value.present? ? primitive_value : value
+      end
+    rescue NoMethodError
+      nil
+    end
+
+    def get_primitive_type_value(element, property, value)
+      source_value = element.source_hash["_#{property}"]
+
+      return nil unless source_value.present?
+
+      primitive_value = CancerRegistryReportingTestKit::PrimitiveType.new(source_value)
+      primitive_value.value = value
+      primitive_value
+    end
+
+    def find_slice_via_discriminator(element, property)
+      element_name = property.to_s.split(':')[0].gsub(/^class$/, 'local_class').gsub(/^method$/, 'local_method')
+      slice_name = property.to_s.split(':')[1].gsub(/^class$/, 'local_class').gsub(/^method$/, 'local_method')
+      if metadata.present?
+        slice_by_name = metadata.must_supports[:slices].find { |slice| slice[:slice_name] == slice_name }
+        discriminator = slice_by_name[:discriminator]
+        slices = Array.wrap(element.send(element_name))
+        slices.find do |slice|
+          case discriminator[:type]
+          when 'patternCodeableConcept'
+            slice_value = discriminator[:path].present? ? slice.send(discriminator[:path].to_s)&.coding : slice.coding
+            slice_value&.any? do |coding|
+              coding.code == discriminator[:code] && coding.system == discriminator[:system]
+            end
+          when 'patternCoding'
+            slice_value = discriminator[:path].present? ? slice.send(discriminator[:path]) : slice
+            slice_value&.code == discriminator[:code] && slice_value&.system == discriminator[:system]
+          when 'patternIdentifier'
+            slice.identifier.system == discriminator[:system]
+          when 'value'
+            values = discriminator[:values].map { |value| value.merge(path: value[:path].split('.')) }
+            verify_slice_by_values(slice, values)
+          when 'type'
+            case discriminator[:code]
+            when 'Date'
+              begin
+                Date.parse(slice)
+              rescue ArgumentError
+                false
+              end
+            when 'DateTime'
+              begin
+                DateTime.parse(slice)
+              rescue ArgumentError
+                false
+              end
+            when 'String'
+              slice.is_a? String
+            else
+              if slice.is_a? FHIR::Bundle::Entry
+                slice.resource.is_a? FHIR.const_get(discriminator[:code])
+              else
+                slice.is_a? FHIR.const_get(discriminator[:code])
+              end
+            end
+          when 'requiredBinding'
+            discriminator[:path].present? ? slice.send(discriminator[:path].to_s).coding : slice.coding
+            slice_value { |coding| discriminator[:values].include?(coding.code) }
+          end
+        end
+      else
+        # TODO: Error handling for if this file doesn't have access to metadata for some reason (begin/rescue with StandardError?)
+      end
+    end
+
+    def verify_slice_by_values(element, value_definitions)
+      path_prefixes = value_definitions.map { |value_definition| value_definition[:path].first }.uniq
+      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(element, 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?
+              verify_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

data/lib/cancer_registry_reporting_test_kit/hdea_generator/group_generator.rb

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+require_relative 'naming'
+require_relative 'special_cases'
+
+module CancerRegistryReportingTestKit
+  class HdeaGenerator
+    class GroupGenerator
+      class << self
+        def generate(ig_metadata, base_output_dir)
+          ig_metadata.ordered_groups
+            .reject { |group| SpecialCases::IGNORE_FOR_GENERATION.include?(group.profile_url) }
+            .each { |group| new(group, base_output_dir).generate }
+        end
+      end
+
+      attr_accessor :group_metadata, :base_output_dir
+
+      def initialize(group_metadata, base_output_dir)
+        self.group_metadata = group_metadata
+        self.base_output_dir = base_output_dir
+      end
+
+      def base_metadata_file_name
+        'metadata.yml'
+      end
+
+      def metadata_file_name
+        File.join(base_output_dir, profile_identifier, base_metadata_file_name)
+      end
+
+      def profile_identifier
+        Naming.snake_case_for_profile(group_metadata)
+      end
+
+      def group_id
+        "ccrr_#{group_metadata.reformatted_version}_#{profile_identifier}"
+      end
+
+      def generate
+        FileUtils.mkdir_p(File.join(base_output_dir, profile_identifier))
+        group_metadata.id = group_id
+        File.write(metadata_file_name, YAML.dump(group_metadata.to_hash))
+      end
+    end
+  end
+end

data/lib/cancer_registry_reporting_test_kit/hdea_generator/group_metadata.rb

@@ -0,0 +1,86 @@
+# frozen_string_literal: true
+
+module CancerRegistryReportingTestKit
+  class HdeaGenerator
+    class GroupMetadata
+      ATTRIBUTES = %i[
+        name
+        class_name
+        version
+        reformatted_version
+        resource
+        profile_url
+        profile_name
+        profile_version
+        title
+        short_description
+        is_delayed
+        interactions
+        operations
+        searches
+        search_definitions
+        include_params
+        revincludes
+        required_concepts
+        must_supports
+        mandatory_elements
+        bindings
+        references
+        tests
+        id
+        file_name
+        delayed_references
+      ].freeze
+
+      ATTRIBUTES.each { |name| attr_accessor name }
+
+      def initialize(metadata)
+        metadata.each do |key, value|
+          raise "Unknown attribute #{key}" unless ATTRIBUTES.include? key
+
+          instance_variable_set(:"@#{key}", value)
+        end
+      end
+
+      def exclude_search_tests?
+        delayed? && !searchable_delayed_resource?
+      end
+
+      def add_test(id:, file_name:)
+        self.tests ||= []
+        test_metadata = {
+          id: id,
+          file_name: file_name
+        }
+        self.tests << test_metadata
+      end
+
+      def add_granular_scope_test(id:, file_name:)
+        self.granular_scope_tests ||= []
+
+        self.granular_scope_tests << {
+          id:,
+          file_name:
+        }
+      end
+
+      def to_hash
+        ATTRIBUTES.each_with_object({}) { |key, hash| hash[key] = send(key) unless send(key).nil? }
+      end
+
+      def add_delayed_references(delayed_profiles, ig_resources)
+        self.delayed_references =
+          references
+            .select { |reference| (reference[:profiles] & delayed_profiles).present? }
+            .map do |reference|
+            profile_urls = (reference[:profiles] & delayed_profiles)
+            delayed_resources = profile_urls.map { |url| ig_resources.resource_for_profile(url) }
+            {
+              path: reference[:path].gsub("#{resource}.", ''),
+              resources: delayed_resources
+            }
+          end
+      end
+    end
+  end
+end

data/lib/cancer_registry_reporting_test_kit/hdea_generator/group_metadata_extractor.rb

@@ -0,0 +1,205 @@
+# frozen_string_literal: true
+
+require_relative 'group_metadata'
+require_relative 'ig_metadata'
+require_relative 'must_support_metadata_extractor'
+require_relative 'terminology_binding_metadata_extractor'
+
+module CancerRegistryReportingTestKit
+  class HdeaGenerator
+    class GroupMetadataExtractor
+      attr_accessor :resource_capabilities, :profile_url, :ig_metadata, :ig_resources
+
+      def initialize(resource_capabilities, profile_url, ig_metadata, ig_resources)
+        self.resource_capabilities = resource_capabilities
+        self.profile_url = profile_url
+        self.ig_metadata = ig_metadata
+        self.ig_resources = ig_resources
+      end
+
+      def group_metadata
+        @group_metadata ||=
+          GroupMetadata.new(group_metadata_hash)
+      end
+
+      def group_metadata_hash
+        @group_metadata_hash ||=
+          {
+            name: name,
+            class_name: class_name,
+            version: version,
+            reformatted_version: reformatted_version,
+            resource: resource,
+            profile_url: profile_url,
+            profile_name: profile_name,
+            profile_version: profile_version,
+            title: title,
+            short_description: short_description,
+            must_supports: must_supports,
+            mandatory_elements: mandatory_elements
+          }
+
+        @group_metadata_hash
+      end
+
+      # def mark_mandatory_and_must_support_searches
+      #   searches.each do |search|
+      #     search[:names_not_must_support_or_mandatory] = search[:names].reject do |name|
+      #       full_paths = search_definitions[name.to_sym][:full_paths]
+      #       any_must_support_elements = (must_supports[:elements]).any? do |element|
+      #         full_must_support_paths = ["#{resource}.#{element[:original_path]}", "#{resource}.#{element[:path]}"]
+
+      #         full_paths.any? do |path|
+      #           # allow for non-choice, choice types, and _id
+      #           name == '_id' || full_must_support_paths.include?(path) || full_must_support_paths.include?("#{path}[x]")
+      #         end
+      #       end
+
+      #       any_must_support_slices = must_supports[:slices].any? do |slice|
+      #         # only handle type slices because that is all we need for now
+      #         # for a slice like Observation.effective[x]:effectiveDateTime, the search parameter's expression could be
+      #         # either Observation.effective or Observation.effectiveDateTime.
+      #         if slice[:discriminator] && slice[:discriminator][:type] == 'type'
+      #           full_must_support_path = "#{resource}.#{slice[:path].sub('[x]', slice[:discriminator][:code])}"
+      #           base_must_support_path = "#{resource}.#{slice[:path].sub('[x]', '')}"
+
+      #           full_paths.intersection([full_must_support_path,base_must_support_path]).present?
+      #         else
+      #           false
+      #         end
+      #       end
+
+      #       any_mandatory_elements = mandatory_elements.any? do |element|
+      #         full_paths.include?(element)
+      #       end
+
+      #       any_must_support_elements || any_must_support_slices || any_mandatory_elements
+      #     end
+
+      #     search[:must_support_or_mandatory] = search[:names_not_must_support_or_mandatory].empty?
+      #   end
+      # end
+
+      ### BEGIN SPECIAL CASES ###
+
+      ### END SPECIAL CASES ###
+
+      def profile
+        if resource_capabilities.title == 'Must Support'
+          SpecialCases.MUST_SUPPORT_GROUP_PROFILE
+        elsif resource_capabilities.title == 'Validation'
+          SpecialCases.VALIDATION_GROUP_PROFILE
+        else
+          @profile ||= ig_resources.profile_by_url(profile_url)
+        end
+      end
+
+      def profile_elements
+        @profile_elements ||= profile.snapshot.element
+      end
+
+      def base_name
+        profile_url.split('StructureDefinition/').last
+      end
+
+      def name
+        base_name.tr('-', '_')
+      end
+
+      def class_name
+        base_name
+          .split('-')
+          .map(&:capitalize)
+          .join
+          # .gsub('UsCore', "USCore#{ig_metadata.reformatted_version}")
+          .concat('Sequence')
+      end
+
+      def version
+        ig_metadata.ig_version
+      end
+
+      def reformatted_version
+        ig_metadata.reformatted_version
+      end
+
+      def resource
+        resource_capabilities.type
+      end
+
+      def profile_name
+        profile.title.gsub('  ', ' ')
+      end
+
+      def profile_version
+        profile.version
+      end
+
+      def title
+        title = profile.title.gsub(/\s*Profile/, '').strip
+
+        if Naming.resources_with_multiple_profiles.include?(resource) && !title.start_with?(resource) && version != 'v3.1.1'
+          title = "#{resource} #{title.split(resource).map(&:strip).join(' ')}"
+        end
+
+        title
+      end
+
+      def short_description
+        "Verify support for the server capabilities required by the #{profile_name}."
+      end
+
+      def required_concepts
+        # The base FHIR vital signs profile has a required binding that isn't
+        # relevant for any of its child profiles
+        return [] if resource == 'Observation'
+
+        profile_elements
+          .select { |element| element.type&.any? { |type| type.code == 'CodeableConcept' } }
+          .select { |element| element.binding&.strength == 'required' }
+          .map { |element| element.path.gsub("#{resource}.", '').gsub('[x]', 'CodeableConcept') }
+          .uniq
+      end
+
+      def terminology_binding_metadata_extractor
+        @terminology_binding_metadata_extractor ||=
+          TerminologyBindingMetadataExtractor.new(profile_elements, ig_resources, resource)
+      end
+
+      def bindings
+        @bindings ||=
+          terminology_binding_metadata_extractor.terminology_bindings
+      end
+
+      def must_support_metadata_extractor
+        @must_support_metadata_extractor ||=
+          MustSupportMetadataExtractor.new(profile_elements, profile, resource, ig_resources)
+      end
+
+      def must_supports
+        @must_supports ||=
+          must_support_metadata_extractor.must_supports
+      end
+
+      def mandatory_elements
+        @mandatory_elements ||=
+          profile_elements
+            .select { |element| element.min.positive? }
+            .map(&:path)
+            .uniq
+      end
+
+      def references
+        @references ||=
+          profile_elements
+            .select { |element| element.type&.first&.code == 'Reference' }
+            .map do |reference_definition|
+            {
+              path: reference_definition.path,
+              profiles: reference_definition.type.first.targetProfile
+            }
+          end
+      end
+    end
+  end
+end