us_quality_core_test_kit 0.1.1 → 0.2.0

data/lib/us_quality_core_test_kit/must_support_test.rb

@@ -1,10 +1,22 @@
 # frozen_string_literal: true
 
-require 'us_core_test_kit/must_support_test'
+require_relative 'fhir_resource_navigation'
 
 module USQualityCoreTestKit
   module MustSupportTest
-    include USCoreTestKit::MustSupportTest
-    extend USCoreTestKit::MustSupportTest
+    include Inferno::DSL::FHIRResourceNavigation
+    extend Forwardable
+
+    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"
+
+      skip { assert_must_support_elements_present(resources, nil, metadata:) }
+    end
   end
 end

data/lib/us_quality_core_test_kit/practitioner_address_test.rb

@@ -0,0 +1,86 @@
+# frozen_string_literal: true
+
+module USQualityCoreTestKit
+  module PractitionerAddressTest
+    include SearchTest
+    include ReferenceResolutionTest
+    include MustSupportTest
+
+    MUST_SUPPORT_ELEMENTS = [
+      { path: 'address' },
+      { path: 'address.line' },
+      { path: 'address.city' },
+      { path: 'address.state' },
+      { path: 'address.postalCode' },
+      { path: 'address.country' }
+    ].freeze
+
+    def resource_type
+      'Practitioner'
+    end
+
+    def scratch_resources
+      scratch[:practitioner_resource] ||= {}
+    end
+
+    def verify_practitioner_address
+      references = scratch.dig(:references, 'Practitioner')
+      assert references&.any?, 'No Practitioner references found.'
+
+      @missing_elements = MUST_SUPPORT_ELEMENTS
+      practitioners = []
+
+      references.each do |reference_info|
+        reference = reference_info[:reference]
+        resolved_resource = resolve_reference(reference)
+
+        if resolved_resource.nil? ||
+           resolved_resource.resourceType != resource_type ||
+           resolved_resource.id != reference.reference_id
+          next
+        end
+
+        practitioners << resolved_resource
+
+        some_missing_elements = find_missing_elements([resolved_resource], MUST_SUPPORT_ELEMENTS)
+        @missing_elements &= some_missing_elements
+
+        break if @missing_elements.empty?
+      end
+
+      missing_elements_string = @missing_elements.map { |element| missing_element_string(element) }
+      support_practitioner_role = false
+
+      if @missing_elements.any?
+        resource_type = 'PractitionerRole'
+        support_practitioner_role = practitioners.any? do |practitioner|
+          search_params = { practitioner: practitioner.id }
+
+          search_and_check_response(search_params, resource_type)
+
+          practitioner_roles = fetch_all_bundled_resources(resource_type:)
+                               .select { |resource| resource.resourceType == resource_type }
+
+          next false if practitioner_roles.empty?
+          next true if config.options[:skip_practitioner_role_validation]
+
+          target_profile_with_version =
+            "http://hl7.org/fhir/us/quality-core/StructureDefinition/us-quality-core-practitionerrole|#{metadata.profile_version}"
+
+          practitioner_roles.any? { |pr| resource_is_valid_with_target_profile?(pr, target_profile_with_version) }
+        end
+      end
+
+      missing_must_support_message = 'Could not find US Quality Core PractitionerRole Profile resources and ' \
+                                     "these MustSupport elements #{missing_elements_string.join(', ')} " \
+                                     'in US Core Quality Practitioner Profile resources. ' \
+                                     'Please use patients with more information.'
+
+      assert (support_practitioner_role || @missing_elements.blank?), missing_must_support_message
+    end
+
+    def get_practitioner_ids(references)
+      references.map { |reference| reference.reference&.split('/')&.last }.compact.uniq
+    end
+  end
+end

data/lib/us_quality_core_test_kit/primitive_type.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+module USQualityCoreTestKit
+  # This functionality has been moved to Inferno Core, but this reference is
+  # retained to avoid a breaking change.
+  PrimitiveType = Inferno::DSL::PrimitiveType
+end

data/lib/us_quality_core_test_kit/read_test.rb

@@ -1,10 +1,105 @@
 # frozen_string_literal: true
 
-require 'us_core_test_kit/read_test'
-
 module USQualityCoreTestKit
   module ReadTest
-    include USCoreTestKit::ReadTest
-    extend USCoreTestKit::ReadTest
+    def all_scratch_resources
+      scratch_resources[:all] ||= []
+    end
+
+    def perform_read_test(resources, _reply_handler = nil, delayed_reference: false)
+      skip_if resources.blank?, no_resources_skip_message
+
+      resources_to_read = if delayed_reference
+                            readable_references(resources)
+                          else
+                            readable_resources(resources)
+                          end
+
+      assert resources_to_read.present?, "No #{resource_type} id found."
+
+      if config.options[:read_all_resources]
+        if delayed_reference
+          all_referencing_resources = referencing_resources(resources_to_read)
+          info %(
+            The #{resource_type} references used for this test were pulled from the following resources:
+            #{all_referencing_resources}
+          )
+
+          resources_to_read.map! { |resource| resource[:reference] }
+        end
+
+        resources_to_read.each do |resource|
+          read_and_validate(resource)
+        end
+      else
+        first_resource = resources_to_read.first
+        if delayed_reference.present?
+          info %(
+            The #{resource_type} reference used for this test was pulled from resource
+            #{first_resource[:referencing_resource]}
+          )
+          first_resource = first_resource[:reference]
+        end
+        read_and_validate(first_resource)
+      end
+    end
+
+    def referencing_resources(readable_resources)
+      readable_resources
+        .map { |resource| resource[:referencing_resource] }
+        .join(', ')
+    end
+
+    def readable_references(resources)
+      references = resources.filter_map do |resource|
+        next unless resource[:reference].present? && resource[:reference].is_a?(FHIR::Reference)
+
+        reference_id = resource[:reference].reference&.split('/')&.last
+        next unless reference_id&.present?
+
+        resource
+      end
+
+      references.uniq { |resource| resource[:reference].reference.split('/').last }
+    end
+
+    def readable_resources(resources)
+      resources
+        .select { |resource| resource.is_a?(resource_class) || resource.is_a?(FHIR::Reference) }
+        .select { |resource| (resource.is_a?(FHIR::Reference) ? resource.reference.split('/').last : resource.id).present? }
+        .compact
+        .uniq { |resource| resource.is_a?(FHIR::Reference) ? resource.reference.split('/').last : resource.id }
+    end
+
+    def read_and_validate(resource_to_read)
+      id = resource_id(resource_to_read)
+
+      fhir_read resource_type, id
+
+      assert_response_status(200)
+      assert_resource_type(resource_type)
+      assert resource.id.present? && resource.id == id, bad_resource_id_message(id)
+
+      return unless resource_to_read.is_a? FHIR::Reference
+
+      all_scratch_resources << resource
+    end
+
+    def resource_id(resource)
+      resource.is_a?(FHIR::Reference) ? resource.reference.split('/').last : resource.id
+    end
+
+    def no_resources_skip_message
+      "No #{resource_type} resources appear to be available. " \
+        'Please use patients with more information.'
+    end
+
+    def bad_resource_id_message(expected_id)
+      "Expected resource to have id: `#{expected_id.inspect}`, but found `#{resource.id.inspect}`"
+    end
+
+    def resource_class
+      FHIR.const_get(resource_type)
+    end
   end
 end

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