davinci_crd_test_kit 0.12.2 → 0.14.0

data/lib/davinci_crd_test_kit/cross_suite/prefetch_contents_validation.rb

@@ -0,0 +1,81 @@
+require_relative 'replace_tokens'
+require_relative 'fhirpath_on_cds_request'
+
+module DaVinciCRDTestKit
+  module PrefetchContentsValidation
+    include ReplaceTokens
+    include FhirpathOnCDSRequest
+
+    def request_number
+      if @request_number.blank?
+        ''
+      else
+        "Request #{@request_number}: "
+      end
+    end
+
+    def prefetched_data?(requests)
+      requests.any? do |request|
+        JSON.parse(request.request_body)['prefetch']&.keys.present?
+      end
+    end
+
+    def check_prefetch_data_against_query(hook_request, advertized_prefetch_queries)
+      request_body = JSON.parse(hook_request.request_body)
+      request_body['prefetch']&.each do |key, value|
+        next unless advertized_prefetch_queries[key].present?
+
+        instantiated_query = replace_tokens_in_string(advertized_prefetch_queries[key], request_body)
+
+        queried_resource_list = query_for_data(instantiated_query)
+        prefetched_resource_list = prefetched_data_to_resource_list(value)
+
+        next if prefetched_data_equals_queried_data?(prefetched_resource_list, queried_resource_list)
+
+        add_message('error', "#{request_number}Prefetched data `#{key}` was different than " \
+                             "data returned from requested query `#{instantiated_query}`.")
+      end
+    end
+
+    def query_for_data(prefetch_query)
+      is_search = prefetch_query.include?('?')
+
+      split_query = is_search ? prefetch_query.split('?') : prefetch_query.split('/')
+      resource_type = split_query.first
+
+      query_result =
+        if is_search
+          fhir_search(resource_type, params: Rack::Utils.parse_nested_query(split_query.last))
+        else
+          fhir_read(resource_type, split_query.last)
+        end
+
+      return [] unless query_result.status.to_s.starts_with?('2')
+      return [] unless query_result.resource.present?
+
+      if is_search
+        fetch_all_bundled_resources(resource_type:, bundle: query_result.resource)
+      else
+        [query_result.resource]
+      end
+    end
+
+    def prefetched_data_equals_queried_data?(prefetched_data, queried_data)
+      prefetched_id_list = prefetched_data.map { |resource| "#{resource.resourceType}/#{resource.id}" }.sort
+      queried_id_list = queried_data.map { |resource| "#{resource.resourceType}/#{resource.id}" }.sort
+
+      prefetched_id_list == queried_id_list
+    end
+
+    def prefetched_data_to_resource_list(prefetched_data)
+      return [] unless prefetched_data.present?
+
+      fhir_data = FHIR.from_contents(prefetched_data.to_json)
+      if fhir_data.is_a?(FHIR::Bundle)
+        fhir_data.entry.map(&:resource)
+      else
+        [fhir_data]
+      end
+    end
+  end
+end

data/lib/davinci_crd_test_kit/cross_suite/prefetch_profile_validation.rb

@@ -0,0 +1,48 @@
+require_relative 'hook_request_field_validation'
+
+module DaVinciCRDTestKit
+  module PrefetchProfileValidation
+    include HookRequestFieldValidation
+
+    def check_prefetch_profiles(prefetch, request_index)
+      prefetch.each do |key, prefetched_resource|
+        next unless prefetched_resource.present? # prefetch must be null if no data matches the template
+
+        @prefetch_template = key
+        check_resource_profile(prefetched_resource, request_index, nil)
+      end
+    end
+
+    private
+
+    def check_resource_profile(prefetched_resource, request_index, bundle_entry_index)
+      if prefetched_resource['resourceType'] == 'Bundle'
+        prefetched_resource['entry']&.each_with_index do |entry, entry_index|
+          check_resource_profile(entry['resource'], request_index, entry_index) if entry['resource'].present?
+        end
+      elsif prefetched_resource['resourceType'].present?
+        check_non_bundle_resource_profile(prefetched_resource, request_index, bundle_entry_index)
+      end
+    end
+
+    def check_non_bundle_resource_profile(prefetched_resource, request_index, bundle_entry_index)
+      target_crd_profile = structure_definition_map('v221')[prefetched_resource['resourceType']]
+      return unless target_crd_profile.present?
+
+      validation_details = []
+      resource_is_valid?(resource: FHIR.from_contents(prefetched_resource.to_json),
+                         profile_url: target_crd_profile,
+                         validator_response_details: validation_details, add_messages_to_runnable: false)
+      validation_details.each do |issue|
+        prefix = prefetch_profile_error_prefix(request_index, bundle_entry_index)
+        add_message(issue.severity, "#{prefix}#{issue.message}")
+      end
+    end
+
+    def prefetch_profile_error_prefix(request_index, bundle_entry_index)
+      prefix = "(Request #{request_index + 1}) Prefetch Template '#{@prefetch_template}'"
+      prefix = "#{prefix} Bundle entry #{bundle_entry_index + 1}" if bundle_entry_index.present?
+      "#{prefix} validation issue - "
+    end
+  end
+end

data/lib/davinci_crd_test_kit/cross_suite/profiles_and_resource_types.rb

@@ -0,0 +1,63 @@
+module DaVinciCRDTestKit
+  module ProfilesAndResourceTypes
+    ORDER_RESOURCE_CLASSES = [
+      FHIR::CommunicationRequest, FHIR::DeviceRequest, FHIR::MedicationRequest,
+      FHIR::NutritionOrder, FHIR::ServiceRequest, FHIR::VisionPrescription
+    ].freeze
+    ORDER_OR_ENCOUNTER_RESOURCE_CLASSES = (ORDER_RESOURCE_CLASSES + [FHIR::Encounter]).freeze
+    ORDER_RESOURCE_TYPES = ORDER_RESOURCE_CLASSES.map { |c| c.name.split('::').last }.freeze
+
+    def structure_definition_map(ig_version)
+      case ig_version
+      when 'v221', '2.2.1'
+        structure_definition_map_v221
+      when 'v201', '2.0.1'
+        structure_definition_map_v201
+      end
+    end
+
+    def structure_definition_map_v201
+      {
+        'Practitioner' => 'http://hl7.org/fhir/us/davinci-crd/StructureDefinition/profile-practitioner|2.0.1',
+        'PractitionerRole' => 'http://hl7.org/fhir/us/core/StructureDefinition/us-core-practitionerrole|3.1.1',
+        'Patient' => 'http://hl7.org/fhir/us/davinci-crd/StructureDefinition/profile-patient|2.0.1',
+        'Encounter' => 'http://hl7.org/fhir/us/davinci-crd/StructureDefinition/profile-encounter|2.0.1',
+        'Appointment' => 'http://hl7.org/fhir/us/davinci-crd/StructureDefinition/profile-appointment|2.0.1',
+        'DeviceRequest' => 'http://hl7.org/fhir/us/davinci-crd/StructureDefinition/profile-devicerequest|2.0.1',
+        'MedicationRequest' => 'http://hl7.org/fhir/us/davinci-crd/StructureDefinition/profile-medicationrequest|2.0.1',
+        'NutritionOrder' => 'http://hl7.org/fhir/us/davinci-crd/StructureDefinition/profile-nutritionorder|2.0.1',
+        'ServiceRequest' => 'http://hl7.org/fhir/us/davinci-crd/StructureDefinition/profile-servicerequest|2.0.1',
+        'VisionPrescription' => 'http://hl7.org/fhir/us/davinci-crd/StructureDefinition/profile-visionprescription|2.0.1',
+        'Medication' => 'http://hl7.org/fhir/us/core/StructureDefinition/us-core-medication|3.1.1',
+        'Device' => 'http://hl7.org/fhir/us/davinci-crd/StructureDefinition/profile-device|2.0.1',
+        'CommunicationRequest' => 'http://hl7.org/fhir/us/davinci-crd/StructureDefinition/profile-communicationrequest|2.0.1',
+        'Task' => 'http://hl7.org/fhir/us/davinci-crd/StructureDefinition/profile-taskquestionnaire|2.0.1',
+        'Coverage' => 'http://hl7.org/fhir/us/davinci-crd/StructureDefinition/profile-coverage|2.0.1',
+        'Location' => 'http://hl7.org/fhir/us/davinci-crd/StructureDefinition/profile-location|2.0.1',
+        'Organization' => 'http://hl7.org/fhir/us/davinci-crd/StructureDefinition/profile-organization|2.0.1'
+      }.freeze
+    end
+
+    def structure_definition_map_v221
+      {
+        'Practitioner' => 'http://hl7.org/fhir/us/davinci-crd/StructureDefinition/profile-practitioner|2.2.1',
+        'PractitionerRole' => 'http://hl7.org/fhir/us/davinci-hrex/StructureDefinition/hrex-practitionerrole|1.2.0',
+        'Patient' => 'http://hl7.org/fhir/us/davinci-crd/StructureDefinition/profile-patient|2.2.1',
+        'Encounter' => 'http://hl7.org/fhir/us/davinci-crd/StructureDefinition/profile-encounter|2.2.1',
+        'Appointment' => 'http://hl7.org/fhir/us/davinci-crd/StructureDefinition/profile-appointment-no-order|2.2.1',
+        'DeviceRequest' => 'http://hl7.org/fhir/us/davinci-crd/StructureDefinition/profile-devicerequest|2.2.1',
+        'MedicationRequest' => 'http://hl7.org/fhir/us/davinci-crd/StructureDefinition/profile-medicationrequest|2.2.1',
+        'NutritionOrder' => 'http://hl7.org/fhir/us/davinci-crd/StructureDefinition/profile-nutritionorder|2.2.1',
+        'ServiceRequest' => 'http://hl7.org/fhir/us/davinci-crd/StructureDefinition/profile-servicerequest|2.2.1',
+        'VisionPrescription' => 'http://hl7.org/fhir/us/davinci-crd/StructureDefinition/profile-visionprescription|2.2.1',
+        'Medication' => 'http://hl7.org/fhir/us/core/StructureDefinition/us-core-medication|3.1.1',
+        'Device' => 'http://hl7.org/fhir/us/davinci-crd/StructureDefinition/profile-device|2.2.1',
+        'CommunicationRequest' => 'http://hl7.org/fhir/us/davinci-crd/StructureDefinition/profile-communicationrequest|2.2.1',
+        'Task' => 'http://hl7.org/fhir/us/davinci-crd/StructureDefinition/profile-taskquestionnaire|2.2.1',
+        'Coverage' => 'http://hl7.org/fhir/us/davinci-crd/StructureDefinition/profile-coverage|2.2.1',
+        'Location' => 'http://hl7.org/fhir/us/davinci-crd/StructureDefinition/profile-location|2.2.1',
+        'Organization' => 'http://hl7.org/fhir/us/davinci-crd/StructureDefinition/profile-organization|2.2.1'
+      }.freeze
+    end
+  end
+end

data/lib/davinci_crd_test_kit/cross_suite/replace_tokens.rb

@@ -0,0 +1,38 @@
+module DaVinciCRDTestKit
+  # Replace "prefetch" tokens (fhirpath surrounded by {{}}) in json object representation
+  # requires execute_fhirpath_on_cds_request (from the FhirpathOnCDSRequest module)
+  module ReplaceTokens
+    def replace_tokens(value, request)
+      case value
+      when Hash
+        value.each_value { |sub_value| replace_tokens(sub_value, request) }
+      when Array
+        value.map! { |entry| replace_tokens(entry, request) }
+      else
+        replace_tokens_in_string(value.to_s, request)
+      end
+    end
+
+    def replace_tokens_in_string(string, request)
+      return string unless string.include?('{{')
+
+      tokens_to_replace = string.scan(/\{\{([^}]+)\}\}/).flatten
+      replacements = tokens_to_replace.each_with_object({}) do |expression, dictionary|
+        next if dictionary["{{#{expression}}}"].present?
+
+        dictionary["{{#{expression}}}"] = calculate_expression_value(request, expression)
+      end
+
+      string.gsub!(/\{\{.*?\}\}/, replacements)
+    end
+
+    private
+
+    def calculate_expression_value(request, expression)
+      results = expression.split('|').map do |sub_expression|
+        execute_fhirpath_on_cds_request(request, sub_expression)
+      end.flatten
+      results.map { |res| res.is_a?(Array) || res.is_a?(Hash) ? nil : res }.compact.join(',')
+    end
+  end
+end

data/lib/davinci_crd_test_kit/cross_suite/requests_logical_model_validation.rb

@@ -0,0 +1,202 @@
+require_relative 'logical_models_override_helper'
+
+module DaVinciCRDTestKit
+  module RequestsLogicalModelValidation
+    include LogicalModelsOverrideHelper
+
+    CRD_CDS_HOOK_REQUEST_MODEL_URL = 'http://hl7.org/fhir/us/davinci-crd/StructureDefinition/CRDHooksRequest'.freeze
+    USER_ID_ALLOWED_RESOURCE_TYPES = [
+      'Practitioner', 'PractitionerRole', 'Patient', 'RelatedPerson'
+    ].freeze
+
+    PERFORMER_ALLOWED_RESOURCE_TYPES = [
+      'Practitioner', 'PractitionerRole'
+    ].freeze
+
+    def validate_request_against_logical_model(request_body, request_index, ig_semver)
+      if ig_semver == '2.2.1'
+        check_logical_model_conformance_no_resource_checks(request_body, request_index, ig_semver)
+      else
+        conforms_to_logical_model?(request_body, "#{CRD_CDS_HOOK_REQUEST_MODEL_URL}|#{ig_semver}",
+                                   message_prefix: "(Request #{request_index + 1}) ")
+      end
+
+      perform_version_specific_additional_verification(request_body, request_index, ig_semver)
+    end
+
+    private
+
+    # -------------------------------------------------------------------------
+    # Additional Validation to cover areas not checked or checked incorrectly by the logical models
+    # -------------------------------------------------------------------------
+
+    def perform_version_specific_additional_verification(request_body, request_index, ig_semver)
+      case ig_semver
+      when '2.2.1'
+        perform_v221_additional_verification(request_body, request_index)
+      end
+    end
+
+    def perform_v221_additional_verification(request_body, request_index)
+      check_context_resources_for_ids(request_body, request_index)
+      check_relative_references(request_body, request_index)
+      check_context_resource_profiles(request_body, request_index, '2.2.1')
+    end
+
+    # -------------------------------------------------------------------------
+    # Context resources profile check (not working in v2.2.1 logical models)
+    # -------------------------------------------------------------------------
+
+    def check_logical_model_conformance_no_resource_checks(request_body, request_index, ig_semver)
+      validation_issues = []
+      conforms_to_logical_model?(request_body, "#{CRD_CDS_HOOK_REQUEST_MODEL_URL}|#{ig_semver}",
+                                 add_messages_to_runnable: false, validator_response_details: validation_issues)
+
+      reject_resource_issues(validation_issues).each do |issue|
+        next if issue.filtered
+
+        add_message(issue.severity, "(Request #{request_index + 1}) #{issue.message}")
+      end
+    end
+
+    def check_context_resource_profiles(request_body, request_index, ig_semver)
+      case request_body['hook']
+      when 'order-sign', 'order-select'
+        draft_orders_conform_to_profiles?(request_body, request_index, ig_semver)
+      when 'order-dispatch'
+        request_body.dig('context', 'fulfillmentTasks')&.each_with_index do |task, index|
+          resource = FHIR.from_contents(task.to_json)
+          resource_is_valid?(resource:, profile_url: "http://hl7.org/fhir/us/davinci-crd/StructureDefinition/profile-task-dispatch|#{ig_semver}",
+                             message_prefix: "(Request #{request_index + 1}) " \
+                                             "context.fulfillmentTasks entry #{index + 1} - ")
+        end
+      when 'appointment-book'
+        check_appointments_profiles(request_body, request_index, ig_semver)
+      end
+    rescue JSON::ParserError
+      nil # no resource to validate - error found elsewhere
+    end
+
+    def draft_orders_conform_to_profiles?(request_body, request_index, ig_semver)
+      resource = FHIR.from_contents(request_body.dig('context', 'draftOrders')&.to_json)
+      resource_is_valid?(resource:, profile_url: "http://hl7.org/fhir/us/davinci-crd/StructureDefinition/profile-bundle-request|#{ig_semver}",
+                         message_prefix: "(Request #{request_index + 1}) context.draftOrders - ")
+    end
+
+    # -------------------------------------------------------------------------
+    # Appointment conformance (requires extra help to decide profile and check profile-based slicing)
+    # -------------------------------------------------------------------------
+
+    def check_appointments_profiles(request_body, request_index, ig_semver)
+      resource = FHIR.from_contents(request_body.dig('context', 'appointments')&.to_json)
+      return unless resource.is_a?(FHIR::Bundle)
+
+      check_bundle_non_entry_resource_conformance(resource,
+                                                  "(Request #{request_index + 1}) context.appointments - ",
+                                                  ig_semver)
+
+      resource.entry.each_with_index do |entry, entry_index|
+        next unless entry.resource.present? # error caught on Bundle validation
+
+        error_prefix = "(Request #{request_index + 1}) context.appointments entry #{entry_index + 1} - "
+        check_appointment_conformance(entry.resource, request_body, error_prefix, ig_semver)
+      end
+    end
+
+    def check_bundle_non_entry_resource_conformance(bundle, error_prefix, ig_semver)
+      validation_issues = []
+      resource_is_valid?(resource: bundle, profile_url: "http://hl7.org/fhir/us/davinci-crd/StructureDefinition/profile-bundle-base|#{ig_semver}",
+                         add_messages_to_runnable: false, validator_response_details: validation_issues)
+
+      reject_entry_resource_issues(validation_issues).each do |issue|
+        add_message(issue.severity, "#{error_prefix}#{issue.message}")
+      end
+    end
+
+    def reject_entry_resource_issues(issues)
+      issues.reject do |issue|
+        issue.filtered || issue.location&.match?(/\ABundle\.entry\[\d+\]\.resource/)
+      end
+    end
+
+    # -------------------------------------------------------------------------
+    # Context relative reference checks
+    # -------------------------------------------------------------------------
+
+    # verify that context fields required to contain local references (resourceType/id)
+    # do contain them and that the resourceType is in the list of expected types.
+    def check_relative_references(request_body, request_index)
+      # unless order-dispatch, check userId
+      # if order-dispatch, check performer and dispatchedOrders list
+      # if order-select, check selections
+
+      if request_body['hook'] == 'order-dispatch'
+        local_reference?(request_body['context']['performer'],
+                         "(Request #{request_index + 1}) context.performer",
+                         allowed_resource_types: PERFORMER_ALLOWED_RESOURCE_TYPES)
+        request_body['context']['dispatchedOrders'].each_with_index do |order_reference, index|
+          local_reference?(order_reference,
+                           "(Request #{request_index + 1}) context.dispatchedOrders entry #{index + 1}",
+                           allowed_resource_types: ProfilesAndResourceTypes::ORDER_RESOURCE_TYPES)
+        end
+      else
+        local_reference?(request_body['context']['userId'],
+                         "(Request #{request_index + 1}) context.userId",
+                         allowed_resource_types: USER_ID_ALLOWED_RESOURCE_TYPES)
+        if request_body['hook'] == 'order-select'
+          request_body['context']['selections'].each_with_index do |order_reference, index|
+            error_prefix = "(Request #{request_index + 1}) context.selections entry #{index + 1}"
+            next unless local_reference?(order_reference,
+                                         error_prefix,
+                                         allowed_resource_types: ProfilesAndResourceTypes::ORDER_RESOURCE_TYPES)
+
+            referenced_resource_present_in_bundle?(request_body['context']['draftOrders'], order_reference,
+                                                   error_prefix, 'draftOrders')
+          end
+        end
+      end
+    end
+
+    # -------------------------------------------------------------------------
+    # Context resources include ids
+    # -------------------------------------------------------------------------
+
+    # logical models don't explicitly check for resource ids
+    def check_context_resources_for_ids(request_body, request_index)
+      hook_name = request_body['hook']
+      context = request_body['context']
+      return unless context.present?
+
+      case hook_name
+      when 'appointment-book'
+        check_bundle_resources_for_ids(context['appointments'], request_index, 'appointments')
+      when 'order-sign', 'order-select'
+        check_bundle_resources_for_ids(context['draftOrders'], request_index, 'draftOrders')
+      when 'order-dispatch'
+        context['fulfillmentTasks']&.each_with_index do |task, index|
+          check_resource_for_id(FHIR.from_contents(task.to_json), request_index, 'fulfillmentTasks', index)
+        end
+      end
+    end
+
+    def check_bundle_resources_for_ids(parsed_bundle, request_index, context_field_name)
+      return unless parsed_bundle.present?
+
+      bundle = FHIR.from_contents(parsed_bundle.to_json)
+      return unless bundle.present?
+
+      bundle.entry&.each_with_index do |entry, index|
+        check_resource_for_id(entry.resource, request_index, context_field_name, index)
+      end
+    end
+
+    def check_resource_for_id(resource, request_index, context_field_name, entry_index = nil)
+      return if resource.present? && resource.id.present?
+
+      message = "(Request #{request_index + 1}) " \
+                'FHIR resources provided in the hook context must have an id, none found for ' \
+                "`context.#{context_field_name}`#{" entry #{entry_index + 1}" if entry_index.present?}."
+      add_message('error', message)
+    end
+  end
+end