us_quality_core_test_kit 0.1.0 → 0.1.2

data/lib/us_quality_core_test_kit/reference_resolution_test.rb

@@ -1,10 +1,171 @@
 # frozen_string_literal: true
 
-require 'us_core_test_kit/reference_resolution_test'
+require_relative 'fhir_resource_navigation'
 
 module USQualityCoreTestKit
   module ReferenceResolutionTest
-    include USCoreTestKit::ReferenceResolutionTest
-    extend USCoreTestKit::ReferenceResolutionTest
+    include Inferno::DSL::FHIRResourceNavigation
+    extend Forwardable
+
+    def_delegators 'self.class', :metadata
+
+    def perform_reference_resolution_test(resources)
+      skip_if resources.blank?, no_resources_skip_message
+
+      pass if unresolved_references(resources).empty?
+
+      skip "Could not resolve and validate any Must Support references for #{unresolved_references_strings.join(', ')}"
+    end
+
+    def unresolved_references_strings
+      unresolved_reference_hash =
+        unresolved_references.each_with_object(Hash.new { |hash, key| hash[key] = [] }) do |missing, hash|
+          hash[missing[:path]] << missing[:target_profile]
+        end
+      unresolved_reference_hash.map { |path, profiles| "#{path} element: Reference#{"(#{profiles.join('|')})" unless profiles.first.empty?}" }
+    end
+
+    def record_resolved_reference(reference, target_profile)
+      saved_reference = resolved_references.find { |item| item[:reference] == reference.reference }
+
+      if saved_reference.present?
+        saved_reference[:profiles] << target_profile if target_profile.present? && !saved_reference[:profiles].include?(target_profile)
+      else
+        saved_reference = {
+          reference: reference.reference,
+          profiles: []
+        }
+
+        saved_reference[:profiles] << target_profile if target_profile.present?
+        resolved_references.add(saved_reference)
+      end
+    end
+
+    def reference_resolved?(reference, target_profile)
+      resolved_references.any? do |item|
+        item[:reference] == reference.reference &&
+          (
+            target_profile.blank? || item[:profiles].include?(target_profile)
+          )
+      end
+    end
+
+    def resolved_references
+      scratch[:resolved_references] ||= Set.new
+    end
+
+    def no_resources_skip_message
+      "No #{resource_type} resources appear to be available. " \
+        'Please use patients with more information.'
+    end
+
+    def must_support_references
+      metadata.must_supports[:elements].select { |element_definition| element_definition[:types]&.include?('Reference') }
+    end
+
+    def must_support_references_with_target_profile
+      # mapping array of target_profiles to array of {path, target_profile} pair
+      must_support_references.map do |element_definition|
+        (element_definition[:target_profiles] || ['']).map do |target_profile|
+          {
+            path: element_definition[:path],
+            target_profile: target_profile
+          }
+        end
+      end.flatten
+    end
+
+    def unresolved_references(resources = [])
+      @unresolved_references ||=
+        must_support_references_with_target_profile.select do |reference_path_profile_pair|
+          path = reference_path_profile_pair[:path]
+          target_profile = reference_path_profile_pair[:target_profile]
+
+          found_one_reference = false
+
+          resolve_one_reference = resources.any? do |resource|
+            value_found = resolve_path(resource, path).select { |value| value.is_a?(FHIR::Reference) }
+            next if value_found.empty?
+
+            found_one_reference = true
+
+            value_found.any? do |reference|
+              validate_reference_resolution(resource, reference, target_profile)
+            end
+          end
+
+          found_one_reference && !resolve_one_reference
+        end
+
+      if metadata.must_supports[:choices].present?
+        @unresolved_references.delete_if do |reference|
+          choice_profiles = metadata.must_supports[:choices].find { |choice| choice[:target_profiles]&.include?(reference[:target_profile]) }
+
+          choice_profiles.present? &&
+            choice_profiles[:target_profiles]&.any? { |profile| @unresolved_references.none? { |element| element[:target_profile] == profile } }
+        end
+      end
+
+      @unresolved_references
+    end
+
+    def validate_reference_resolution(resource, reference, target_profile)
+      return true if reference_resolved?(reference, target_profile)
+
+      if reference.contained?
+        # if reference_id is blank it is referring to itself, so we know it exists
+        return true if reference.reference_id.blank?
+
+        return resource.contained.any? do |contained_resource|
+          contained_resource&.id == reference.reference_id &&
+          resource_is_valid_with_target_profile?(contained_resource, target_profile)
+        end
+      end
+
+      reference_type = reference.resource_type
+      reference_id = reference.reference_id
+
+      resolved_resource = resolve_reference(reference)
+
+      return false if resolved_resource.nil?
+
+      return false unless resolved_resource.resourceType == reference_type && resolved_resource.id == reference_id
+
+      return false unless resource_is_valid_with_target_profile?(resolved_resource, target_profile)
+
+      record_resolved_reference(reference, target_profile)
+      true
+    end
+
+    def resolve_reference(reference)
+      reference_type = reference.resource_type
+      reference_id = reference.reference_id
+
+      begin
+        if reference.relative?
+          begin
+            reference.resource_class
+          rescue NameError
+            return nil
+          end
+
+          fhir_read(reference_type, reference_id)&.resource
+        elsif reference.base_uri.chomp('/') == fhir_client.instance_variable_get(:@base_service_url).chomp('/')
+          fhir_read(reference_type, reference_id)&.resource
+        else
+          get(reference.reference)&.resource
+        end
+      rescue StandardError => e
+        Inferno::Application['logger'].error("Unable to resolve reference #{reference.reference}")
+        Inferno::Application['logger'].error(e.full_message)
+        nil
+      end
+    end
+
+    def resource_is_valid_with_target_profile?(resource, target_profile)
+      return true if target_profile.blank?
+
+      resource_is_valid?(resource:, profile_url: target_profile, add_messages_to_runnable: false)
+    end
   end
 end

data/lib/us_quality_core_test_kit/resource_search_param_checker.rb

@@ -0,0 +1,138 @@
+# frozen_string_literal: true
+
+require_relative 'fhir_resource_navigation'
+
+module USQualityCoreTestKit
+  module ResourceSearchParamChecker
+    include Inferno::DSL::FHIRResourceNavigation
+
+    def search_param_paths(name)
+      paths = metadata.search_definitions[name.to_sym][:paths]
+      paths[0] = 'local_class' if paths.first == 'class'
+
+      paths
+    end
+
+    def element_has_valid_value?(element, include_system)
+      case element
+      when FHIR::Reference
+        element.reference.present?
+      when FHIR::CodeableConcept
+        if include_system
+          coding =
+            find_a_value_at(element, 'coding') { |a_coding| a_coding.code.present? && a_coding.system.present? }
+          coding.present?
+        else
+          find_a_value_at(element, 'coding.code').present?
+        end
+      when FHIR::Identifier
+        include_system ? element.value.present? && element.system.present? : element.value.present?
+      when FHIR::Coding
+        include_system ? element.code.present? && element.system.present? : element.code.present?
+      when FHIR::HumanName
+        (element.family || element.given&.first || element.text).present?
+      when FHIR::Address
+        (element.text || element.city || element.state || element.postalCode || element.country).present?
+      when FHIR::Element
+        false
+      else
+        true
+      end
+    end
+
+    def resource_matches_param?(resource, search_param_name, escaped_search_value, values_found = [])
+      search_value = unescape_search_value(escaped_search_value)
+      paths = search_param_paths(search_param_name)
+
+      match_found = false
+
+      paths.each do |path|
+        type = metadata.search_definitions[search_param_name.to_sym][:type]
+        values_found =
+          resolve_path(resource, path)
+          .map do |value|
+            if value.is_a? FHIR::Reference
+              value.reference
+            else
+              value
+            end
+          end
+
+        match_found =
+          case type
+          when 'Period', 'date', 'instant', 'dateTime'
+            values_found.any? { |date| validate_date_search(search_value, date) }
+          when 'HumanName'
+            # When a string search parameter refers to the types HumanName and Address,
+            # the search covers the elements of type string, and does not cover elements such as use and period
+            # https://www.hl7.org/fhir/search.html#string
+            search_value_downcase = search_value.downcase
+            values_found.any? do |name|
+              name&.text&.downcase&.start_with?(search_value_downcase) ||
+                name&.family&.downcase&.start_with?(search_value_downcase) ||
+                name&.given&.any? { |given| given.downcase.start_with?(search_value_downcase) } ||
+                name&.prefix&.any? { |prefix| prefix.downcase.start_with?(search_value_downcase) } ||
+                name&.suffix&.any? { |suffix| suffix.downcase.start_with?(search_value_downcase) }
+            end
+          when 'Address'
+            search_value_downcase = search_value.downcase
+            values_found.any? do |address|
+              address&.text&.downcase&.start_with?(search_value_downcase) ||
+                address&.city&.downcase&.start_with?(search_value_downcase) ||
+                address&.state&.downcase&.start_with?(search_value_downcase) ||
+                address&.postalCode&.downcase&.start_with?(search_value_downcase) ||
+                address&.country&.downcase&.start_with?(search_value_downcase)
+            end
+          when 'CodeableConcept'
+            # FHIR token search (https://www.hl7.org/fhir/search.html#token): "When in doubt, servers SHOULD
+            # treat tokens in a case-insensitive manner, on the grounds that including undesired data has
+            # less safety implications than excluding desired behavior".
+            codings = values_found.flat_map(&:coding)
+            if search_value.include? '|'
+              system = search_value.split('|').first
+              code = search_value.split('|').last
+              codings&.any? { |coding| coding.system == system && coding.code&.casecmp?(code) }
+            else
+              codings&.any? { |coding| coding.code&.casecmp?(search_value) }
+            end
+          when 'Coding'
+            if search_value.include? '|'
+              system = search_value.split('|').first
+              code = search_value.split('|').last
+              values_found.any? { |coding| coding.system == system && coding.code&.casecmp?(code) }
+            else
+              values_found.any? { |coding| coding.code&.casecmp?(search_value) }
+            end
+          when 'Identifier'
+            if search_value.include? '|'
+              values_found.any? { |identifier| "#{identifier.system}|#{identifier.value}" == search_value }
+            else
+              values_found.any? { |identifier| identifier.value == search_value }
+            end
+          when 'string'
+            searched_values = search_value.downcase.split(/(?<!\\\\),/).map { |string| string.gsub('\\,', ',') }
+            values_found.any? do |value_found|
+              searched_values.any? { |searched_value| value_found.downcase.starts_with? searched_value }
+            end
+          else
+            # searching by patient requires special case because we are searching by a resource identifier
+            # references can also be URLs, so we may need to resolve those URLs
+            if %w[subject patient].include? search_param_name.to_s
+              id = search_value.split('Patient/').last
+              possible_values = [id, "Patient/#{id}", "#{url}/Patient/#{id}"]
+              values_found.any? do |reference|
+                possible_values.include? reference
+              end
+            else
+              search_values = search_value.split(/(?<!\\\\),/).map { |string| string.gsub('\\,', ',') }
+              values_found.any? { |value_found| search_values.include? value_found }
+            end
+          end
+
+        break if match_found
+      end
+
+      match_found
+    end
+  end
+end