davinci_crd_test_kit 0.13.0 → 0.14.1

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,203 @@
+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)
+      draft_orders = request_body.dig('context', 'draftOrders').to_json
+      resource = FHIR.from_contents(draft_orders)
+      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

data/lib/davinci_crd_test_kit/cross_suite/response_logical_model_validation.rb

@@ -0,0 +1,435 @@
+require_relative 'cards_identification'
+require_relative 'logical_models_override_helper'
+
+module DaVinciCRDTestKit
+  module ResponseLogicalModelValidation
+    include DaVinciCRDTestKit::CardsIdentification
+    include LogicalModelsOverrideHelper
+
+    CRD_LOGICAL_MODEL_BASE = 'http://hl7.org/fhir/us/davinci-crd/StructureDefinition'.freeze
+    CRD_RESPONSE_BASE_LOGICAL_MODEL = 'CRDHooksResponseBase'.freeze
+
+    CARD_TYPE_TO_LOGICAL_MODEL = {
+      DaVinciCRDTestKit::CardsIdentification::ADDITIONAL_ORDERS_RESPONSE_TYPE =>
+        'CRDHooksResponse-additionalOrders',
+      DaVinciCRDTestKit::CardsIdentification::CREATE_OR_UPDATE_COVERAGE_RESPONSE_TYPE =>
+        'CRDHooksResponse-adjustCoverage',
+      DaVinciCRDTestKit::CardsIdentification::EXTERNAL_REFERENCE_RESPONSE_TYPE =>
+        'CRDHooksResponse-externalReference',
+      DaVinciCRDTestKit::CardsIdentification::FORM_COMPLETION_RESPONSE_TYPE =>
+        'CRDHooksResponse-formCompletion',
+      DaVinciCRDTestKit::CardsIdentification::INSTRUCTIONS_RESPONSE_TYPE =>
+        'CRDHooksResponse-instructions',
+      DaVinciCRDTestKit::CardsIdentification::LAUNCH_SMART_APP_RESPONSE_TYPE =>
+        'CRDHooksResponse-launchSMART',
+      DaVinciCRDTestKit::CardsIdentification::PROPOSE_ALTERNATIVE_REQUEST_RESPONSE_TYPE =>
+        'CRDHooksResponse-alternateRequest'
+    }.freeze
+
+    ACTION_TYPE_TO_LOGICAL_MODEL = {
+      DaVinciCRDTestKit::CardsIdentification::COVERAGE_INFORMATION_RESPONSE_TYPE =>
+        'CRDHooksResponse-coverageInformation',
+      DaVinciCRDTestKit::CardsIdentification::CREATE_OR_UPDATE_COVERAGE_RESPONSE_TYPE =>
+        'CRDHooksResponse-adjustCoverage',
+      DaVinciCRDTestKit::CardsIdentification::FORM_COMPLETION_RESPONSE_TYPE =>
+        'CRDHooksResponse-formCompletion'
+    }.freeze
+
+    def logical_model_url(profile_name)
+      "#{CRD_LOGICAL_MODEL_BASE}/#{profile_name}"
+    end
+
+    def perform_response_logical_model_validation(cards, system_actions, request_body, response_index, ig_semver)
+      if cards.is_a?(Array)
+        cards.each_with_index do |card, card_index|
+          validate_card_against_logical_model(card, response_index, request_body, card_index, ig_semver)
+        end
+      end
+
+      return unless system_actions.is_a?(Array)
+
+      system_actions.each_with_index do |action, action_index|
+        validate_system_action_against_logical_model(action, response_index, request_body, action_index, ig_semver)
+      end
+    end
+
+    def validate_card_against_logical_model(card, response_index, request_body, card_index, ig_semver)
+      label = logical_model_entity_label(response_index, card_index, 'card')
+      unless card.is_a?(Hash)
+        add_message('error', "#{label} is not a JSON object; skipping logical model validation.")
+        return
+      end
+
+      card_type = identify_card_type(card)
+      profile_name = CARD_TYPE_TO_LOGICAL_MODEL[card_type]
+      unless profile_name
+        add_message('warning',
+                    "#{label} could not be categorized as a known CRD response type; " \
+                    'validating against the base CRD response logical model.')
+        profile_name = CRD_RESPONSE_BASE_LOGICAL_MODEL
+      end
+
+      validation_issues = []
+      conforms_to_logical_model?({ 'cards' => [card] }, logical_model_url(profile_name),
+                                 add_messages_to_runnable: false, validator_response_details: validation_issues)
+
+      validate_summary_length(card, label)
+      validate_suggestion_uuid_presence(card, label) unless ['v201', '2.0.1'].include? ig_semver
+      validate_no_smart_suggestions(card, label) if card_type == CardsIdentification::LAUNCH_SMART_APP_RESPONSE_TYPE
+
+      error_prefix = "#{label} (#{card_type || 'uncategorized'}): "
+      filtered_issues = manually_check_card_specific_errors(card, validation_issues, card_type,
+                                                            request_body, error_prefix, ig_semver)
+      add_messages_not_excluded(filtered_issues, error_prefix)
+    end
+
+    def validate_summary_length(card, label)
+      return unless card['summary'].is_a? String
+
+      summary_length = card['summary'].length
+
+      return if summary_length < 140
+
+      add_message(
+        'error',
+        "#{label} summary length of #{summary_length} characters is longer than " \
+        'the maximum allowed of 139 characters.'
+      )
+    end
+
+    def validate_suggestion_uuid_presence(card, label)
+      return unless card['suggestions'].presence.is_a? Array
+      return unless card['suggestions'].all?(Hash)
+
+      card['suggestions'].each_with_index do |suggestion, index|
+        next if suggestion['uuid'].present?
+
+        add_message(
+          'error',
+          "#{label} suggestion #{index + 1} does not contain a `uuid`"
+        )
+      end
+    end
+
+    def validate_no_smart_suggestions(card, label)
+      suggestion_count = card['suggestions']&.length || 0
+
+      return if suggestion_count.zero?
+
+      add_message(
+        'error',
+        "#{label} CDSHooksResponse.cards.suggestions: max allowed = 0, but found #{suggestion_count} " \
+        '(from http://hl7.org/fhir/us/davinci-crd/StructureDefinition/CRDHooksResponse-launchSMART|2.2.1)'
+      )
+    end
+
+    def validate_system_action_against_logical_model(action, response_index, request_body, action_index, ig_semver)
+      label = logical_model_entity_label(response_index, action_index, 'systemAction')
+      unless action.is_a?(Hash)
+        add_message('error', "#{label} is not a JSON object; skipping logical model validation.")
+        return
+      end
+
+      action_type = identify_action_type(action)
+      profile_name = ACTION_TYPE_TO_LOGICAL_MODEL[action_type]
+      unless profile_name
+        add_message('warning',
+                    "#{label} could not be categorized as a known CRD response type; " \
+                    'validating against the base CRD response logical model.')
+        profile_name = CRD_RESPONSE_BASE_LOGICAL_MODEL
+      end
+      if [DaVinciCRDTestKit::CardsIdentification::CREATE_OR_UPDATE_COVERAGE_RESPONSE_TYPE,
+          DaVinciCRDTestKit::CardsIdentification::FORM_COMPLETION_RESPONSE_TYPE]
+          .include?(action_type)
+        profile_name = CRD_RESPONSE_BASE_LOGICAL_MODEL
+      end
+
+      validation_issues = []
+      conforms_to_logical_model?({ 'systemActions' => [action] }, logical_model_url(profile_name),
+                                 add_messages_to_runnable: false, validator_response_details: validation_issues)
+
+      validation_issues
+        .reject! do |issue|
+          issue.message.match?(%r{The extension definition http://hl7\.org/fhir/us/davinci-crd/StructureDefinition/CDSHookServiceResponseExtensionIfNoneExist|2\.2\.1 defines the contexts of use as.*CDSHooksResponse.systemActions.extension\z}) # rubocop:disable Layout/LineLength
+        end
+
+      if action_type == CardsIdentification::COVERAGE_INFORMATION_RESPONSE_TYPE
+        check_multiple_coverage_info_extension_conformance(action)
+      end
+      error_prefix = "#{label} (#{action_type || 'uncategorized'}): "
+      filtered_issues = manually_check_action_specific_errors(action, validation_issues, action_type,
+                                                              request_body, error_prefix, ig_semver)
+      add_messages_not_excluded(filtered_issues, error_prefix)
+    end
+
+    def check_multiple_coverage_info_extension_conformance(action)
+      resource = FHIR.from_contents(action['resource'].to_json)
+
+      grouped_coverage_info = extract_and_group_coverage_info(resource)
+      multiple_extensions_conformance_check(grouped_coverage_info, resource)
+    end
+
+    def extract_and_group_coverage_info(resource)
+      resource.extension.each_with_object({}) do |extension, grouped_extensions|
+        next unless extension.url == COVERAGE_INFO_EXT_URL
+
+        coverage_key = find_extension_value(extension, 'coverage', 'valueReference', 'reference')
+        grouped_extensions[coverage_key] ||= []
+        grouped_extensions[coverage_key] << extension
+      end
+    end
+
+    # For the same coverage, ensure coverage-assertion-ids and satisfied-pa-ids are the same.
+    # For different coverages, ensure coverage-assertion-ids and satisfied-pa-ids are distinct.
+    def multiple_extensions_conformance_check(grouped_coverage_info, resource)
+      resource_ref = "#{resource.resourceType}/#{resource.id}"
+      assertion_ids_across_coverages = Set.new
+      pa_ids_across_coverages = Set.new
+
+      grouped_coverage_info.each do |coverage, extensions|
+        coverage_assertion_ids = collect_extensions_id(extensions, 'coverage-assertion-id', 'valueString').uniq
+        satisfied_pa_ids = collect_extensions_id(extensions, 'satisfied-pa-id', 'valueString').uniq.compact
+        if coverage_assertion_ids.length != 1
+          add_message(
+            'error',
+            same_coverage_conformance_error_msg(resource_ref, coverage, 'coverage-assertion-ids')
+          )
+        end
+
+        if satisfied_pa_ids.length > 1
+          add_message(
+            'error',
+            same_coverage_conformance_error_msg(resource_ref, coverage, 'satisfied-pa-ids')
+          )
+        end
+
+        assertion_id = coverage_assertion_ids.first
+        if assertion_ids_across_coverages.include?(assertion_id)
+          add_message(
+            'error',
+            different_coverage_conformance_error_msg(resource_ref, 'coverage-assertion-ids')
+          )
+        end
+
+        assertion_ids_across_coverages.add(assertion_id)
+        pa_id = satisfied_pa_ids.first
+        next unless pa_id
+
+        if pa_ids_across_coverages.include?(pa_id)
+          add_message(
+            'error',
+            different_coverage_conformance_error_msg(resource_ref, 'satisfied-pa-ids')
+          )
+        end
+
+        pa_ids_across_coverages.add(pa_id)
+      end
+    end
+
+    def collect_extensions_id(extensions, url, *properties)
+      extensions.map do |extension|
+        find_extension_value(extension, url, *properties)
+      end
+    end
+
+    def find_extension_value(extension, url, *properties)
+      found_extension = extension.extension.find { |ext| ext.url == url }
+      return nil unless found_extension
+
+      properties.reduce(found_extension) do |current, prop|
+        return current unless current.respond_to?(prop)
+
+        current.send(prop)
+      end
+    end
+
+    def same_coverage_conformance_error_msg(resource_ref, coverage, id_name)
+      "#{resource_ref}: extension has multiple repetitions of coverage `#{coverage}` with different #{id_name}."
+    end
+
+    def different_coverage_conformance_error_msg(resource_ref, id_name)
+      "#{resource_ref}: extensions referencing differing coverage SHALL have distinct #{id_name}."
+    end
+
+    def add_messages_not_excluded(issues, error_prefix)
+      issues.each do |issue|
+        next if issue.filtered || logical_model_extension_issue?(issue)
+
+        add_message(issue.severity, "#{error_prefix}#{issue.message}")
+      end
+    end
+
+    def logical_model_entity_label(response_index, entity_index, kind)
+      "Server response #{response_index + 1}, #{kind} #{entity_index + 1}"
+    end
+
+    # -------------------------------------------------------------------------
+    # Validator Filtering and Manual Checks Depending on the Card Type
+    # -------------------------------------------------------------------------
+
+    def logical_model_extension_issue?(issue)
+      issue.message.match(/\.extension: Unrecognized property/).present?
+    end
+
+    def manually_check_card_specific_errors(card, validation_issues, card_type, request_body, error_prefix,
+                                            ig_semver)
+      case card_type
+      when CardsIdentification::FORM_COMPLETION_RESPONSE_TYPE
+        manually_check_form_completion_errors(card, validation_issues, error_prefix)
+      when CardsIdentification::PROPOSE_ALTERNATIVE_REQUEST_RESPONSE_TYPE
+        manually_check_propose_alternative_errors(card, validation_issues, request_body,
+                                                  error_prefix, ig_semver)
+      when CardsIdentification::ADDITIONAL_ORDERS_RESPONSE_TYPE
+        manually_check_additional_orders_errors(card, validation_issues, request_body,
+                                                error_prefix, ig_semver)
+      when CardsIdentification::LAUNCH_SMART_APP_RESPONSE_TYPE
+        manually_check_launch_smart_app_errors(validation_issues)
+      else
+        validation_issues
+      end
+    end
+
+    def manually_check_action_specific_errors(action, validation_issues, action_type, request_body,
+                                              error_prefix, ig_semver)
+      case action_type
+      when DaVinciCRDTestKit::CardsIdentification::COVERAGE_INFORMATION_RESPONSE_TYPE
+        manually_check_coverage_information_errors(action, validation_issues, request_body,
+                                                   error_prefix, ig_semver)
+      when DaVinciCRDTestKit::CardsIdentification::CREATE_OR_UPDATE_COVERAGE_RESPONSE_TYPE
+        manually_check_update_coverage_action_errors(action, validation_issues,
+                                                     error_prefix, ig_semver)
+      when DaVinciCRDTestKit::CardsIdentification::FORM_COMPLETION_RESPONSE_TYPE
+        manually_check_form_completion_action_errors(action, validation_issues,
+                                                     error_prefix, ig_semver)
+      else
+        validation_issues
+      end
+    end
+
+    def manually_check_form_completion_errors(card, validation_issues, error_prefix)
+      validation_issues.reject do |issue|
+        if issue.message.match?(/The type 'Questionnaire' is not valid - must be Task/)
+          check_questionnaire_actions(card, issue.message, error_prefix)
+          true
+        else
+          false
+        end
+      end
+    end
+
+    def check_questionnaire_actions(card, error_message, error_prefix)
+      extracted_indexes =
+        error_message.match(/CDSHooksResponse\.cards\[0\]\.suggestions\[(\d+)\]\.actions\[(\d+)\]\.resource/)
+      unless extracted_indexes
+        raise 'Unexpected validator error message format in check_questionnaire_actions: ' \
+              "'#{error_message}'. This indicates an implementation problem in the test kit — please log a ticket."
+      end
+
+      suggestion_index = extracted_indexes[1].to_i
+      action_index = extracted_indexes[2].to_i
+
+      message_prefix = "#{error_prefix} suggestion #{suggestion_index + 1}, action #{action_index + 1} - "
+      resource = FHIR.from_contents(card['suggestions'][suggestion_index]['actions'][action_index]['resource'].to_json)
+      resource_is_valid?(resource:, message_prefix:) # no questionnaire profile applied per CRD
+
+      return if resource.id.present?
+
+      add_message('error', "#{message_prefix}Questionnaire must have an id.")
+    end
+
+    def manually_check_launch_smart_app_errors(validation_issues)
+      validation_issues.reject do |issue|
+        issue.message.match?(/CDSHooksResponse.cards.suggestions: minimum required = 1, but only found 0/)
+      end
+    end
+
+    def manually_check_propose_alternative_errors(card, validation_issues, request_body,
+                                                  error_prefix, ig_semver)
+      no_resource_issues = manually_check_action_resources_for_order_profile_conformance(card,
+                                                                                         validation_issues,
+                                                                                         request_body,
+                                                                                         error_prefix,
+                                                                                         ig_semver)
+
+      no_resource_issues.each do |issue|
+        next unless issue.message.match?(/Constraint failed: crd-respar-1/)
+
+        new_message =
+          "#{issue.message}. In some cases [additional create " \
+          'actions](https://hl7.org/fhir/us/davinci-crd/2.2.1/en/cards.html#propose-alternate-request-response-type) ' \
+          'are permitted. Manually check the suggestion to verify whether this is an actual error.'
+        issue.instance_variable_set(:@severity, 'warning')
+        issue.instance_variable_set(:@message, new_message)
+      end
+
+      no_resource_issues.reject do |issue|
+        issue.message.match?(/but is fixed to 'create' in the profile/)
+      end
+    end
+
+    def manually_check_additional_orders_errors(card, validation_issues, request_body,
+                                                error_prefix, ig_semver)
+      manually_check_action_resources_for_order_profile_conformance(card,
+                                                                    validation_issues,
+                                                                    request_body,
+                                                                    error_prefix,
+                                                                    ig_semver)
+    end
+
+    def manually_check_action_resources_for_order_profile_conformance(card, validation_issues, request_body,
+                                                                      error_prefix, ig_semver)
+      if card['suggestions'].present?
+        card['suggestions'].each_with_index do |suggestion, suggestion_index|
+          next unless suggestion['actions'].present?
+
+          suggestion['actions'].each_with_index do |action, action_index|
+            action_error_prefix = "#{error_prefix}suggestion #{suggestion_index + 1}, action #{action_index + 1} - "
+            check_action_target(action, request_body, action_error_prefix, ig_semver)
+          end
+        end
+      end
+
+      reject_resource_issues(validation_issues)
+    end
+
+    def check_action_target(action, request_body, error_prefix, ig_semver)
+      local_reference?(action['resourceId'], error_prefix) if action['resourceId'].present?
+      return unless action['resource'].present?
+
+      check_resource_conformance_to_order_profile(action['resource'], request_body, error_prefix, ig_semver)
+    end
+
+    def manually_check_coverage_information_errors(action, validation_issues, request_body,
+                                                   error_prefix, ig_semver)
+      if action['resource'].present?
+        check_resource_conformance_to_order_or_encounter_profile(action['resource'], request_body,
+                                                                 error_prefix, ig_semver)
+      end
+      reject_resource_issues(validation_issues)
+    end
+
+    def manually_check_update_coverage_action_errors(action, validation_issues,
+                                                     error_prefix, ig_semver)
+      check_required_action_type(action, 'update', error_prefix, 'coverage update action response type')
+      if action['resource'].present?
+        check_resource_conformance_to_coverage_profile(action['resource'], error_prefix, ig_semver)
+      end
+      reject_resource_issues(validation_issues)
+    end
+
+    def manually_check_form_completion_action_errors(action, validation_issues,
+                                                     error_prefix, ig_semver)
+      check_required_action_type(action, 'create', error_prefix, 'form completion action response type')
+      if action['resource'].present?
+        check_resource_conformance_to_questionnaire_task_profile(action['resource'], error_prefix, ig_semver)
+      end
+      reject_resource_issues(validation_issues)
+    end
+
+    def check_required_action_type(action, required_type, error_prefix, description)
+      return if action['type'] == required_type
+
+      add_message('error', "#{error_prefix}action type must be '#{required_type}' for a #{description}.")
+    end
+  end
+end