davinci_crd_test_kit 0.13.0 → 0.14.1

data/lib/davinci_crd_test_kit/cross_suite/cards_identification.rb

@@ -0,0 +1,321 @@
+require_relative 'hook_request_field_validation'
+require_relative 'suggestion_actions_validation'
+
+module DaVinciCRDTestKit
+  module CardsIdentification
+    include DaVinciCRDTestKit::SuggestionActionsValidation
+    include DaVinciCRDTestKit::HookRequestFieldValidation
+
+    COVERAGE_INFO_EXT_URL = 'http://hl7.org/fhir/us/davinci-crd/StructureDefinition/ext-coverage-information'.freeze
+
+    ADDITIONAL_ORDERS_RESPONSE_TYPE = 'companions_prerequisites'.freeze
+    COVERAGE_INFORMATION_RESPONSE_TYPE = 'coverage_information'.freeze
+    CREATE_OR_UPDATE_COVERAGE_RESPONSE_TYPE = 'create_update_coverage_info'.freeze
+    EXTERNAL_REFERENCE_RESPONSE_TYPE = 'external_reference'.freeze
+    FORM_COMPLETION_RESPONSE_TYPE = 'request_form_completion'.freeze
+    INSTRUCTIONS_RESPONSE_TYPE = 'instructions'.freeze
+    LAUNCH_SMART_APP_RESPONSE_TYPE = 'launch_smart_app'.freeze
+    PROPOSE_ALTERNATIVE_REQUEST_RESPONSE_TYPE = 'propose_alternate_request'.freeze
+    COVERAGE_INFO_CONFIGURATION_CODE = 'coverage-info'.freeze
+
+    ADDITIONAL_ORDERS_EXPECTED_RESOURCE_TYPES = %w[
+      CommunicationRequest Device DeviceRequest Medication
+      MedicationRequest NutritionOrder ServiceRequest
+      VisionPrescription
+    ].freeze
+
+    PROPOSE_ALTERNATIVE_REQUEST_EXPECTED_RESOURCE_TYPES = %w[
+      CommunicationRequest Device DeviceRequest Encounter Medication
+      MedicationRequest NutritionOrder ServiceRequest
+      VisionPrescription
+    ].freeze
+
+    COVERAGE_INFO_EXPECTED_RESOURCE_TYPES = %w[
+      Appointment CommunicationRequest DeviceRequest Encounter MedicationRequest
+      NutritionOrder ServiceRequest VisionPrescription
+    ].freeze
+
+    def identify_card_type(card) # rubocop:disable Metrics/CyclomaticComplexity
+      return nil if card['type'].present? # action, not a card
+      return ADDITIONAL_ORDERS_RESPONSE_TYPE if additional_orders_response_type?(card)
+      return CREATE_OR_UPDATE_COVERAGE_RESPONSE_TYPE if create_or_update_coverage_card_response_type?(card)
+      return EXTERNAL_REFERENCE_RESPONSE_TYPE if external_reference_response_type?(card)
+      return FORM_COMPLETION_RESPONSE_TYPE if form_completion_card_response_type?(card)
+      return INSTRUCTIONS_RESPONSE_TYPE if instructions_response_type?(card)
+      return LAUNCH_SMART_APP_RESPONSE_TYPE if launch_smart_app_response_type?(card)
+      return PROPOSE_ALTERNATIVE_REQUEST_RESPONSE_TYPE if propose_alternative_request_response_type?(card)
+
+      nil
+    end
+
+    def identify_action_type(action)
+      return nil unless action['type'].present? # card, not an action
+      return COVERAGE_INFORMATION_RESPONSE_TYPE if coverage_information_response_type?(action)
+      return CREATE_OR_UPDATE_COVERAGE_RESPONSE_TYPE if create_or_update_coverage_action_response_type?(action)
+      return FORM_COMPLETION_RESPONSE_TYPE if form_completion_action_response_type?(action)
+
+      nil
+    end
+
+    def coverage_info_card_type?(card)
+      return false unless card.respond_to?(:dig)
+
+      card.dig('source', 'topic', 'code') == COVERAGE_INFO_CONFIGURATION_CODE
+    end
+
+    def coverage_info_system_action_type?(action)
+      return false unless action.respond_to?(:[])
+
+      [COVERAGE_INFORMATION_RESPONSE_TYPE, FORM_COMPLETION_RESPONSE_TYPE].include?(identify_action_type(action))
+    end
+
+    def coverage_info_content(response_body)
+      return [[], []] unless response_body.is_a?(Hash)
+
+      cards =
+        if response_body['cards'].is_a?(Array)
+          response_body['cards'].select { |card| coverage_info_card_type?(card) }
+        else
+          []
+        end
+      actions =
+        if response_body['systemActions'].is_a?(Array)
+          response_body['systemActions'].select { |action| coverage_info_system_action_type?(action) }
+        else
+          []
+        end
+
+      [cards, actions]
+    end
+
+    def coverage_info_system_action_response?(response_body)
+      return false unless response_body.is_a?(Hash)
+
+      return false unless response_body['systemActions'].is_a?(Array)
+
+      response_body['systemActions'].any? { |action| coverage_information_response_type?(action) }
+    end
+
+    def coverage_info_response?(response_body)
+      cards, actions = coverage_info_content(response_body)
+
+      cards.present? || actions.present?
+    end
+
+    def coverage_info_configuration_disabled?(request_body)
+      request_body.is_a?(Hash) &&
+        request_body.dig('extension', 'davinci-crd.configuration', COVERAGE_INFO_CONFIGURATION_CODE) == false
+    end
+
+    def disable_coverage_info_configuration!(request_body)
+      request_body['extension'] = {} unless request_body['extension'].is_a?(Hash)
+      unless request_body['extension']['davinci-crd.configuration'].is_a?(Hash)
+        request_body['extension']['davinci-crd.configuration'] = {}
+      end
+      request_body['extension']['davinci-crd.configuration'][COVERAGE_INFO_CONFIGURATION_CODE] = false
+
+      request_body
+    end
+
+    def additional_orders_response_type?(card, expected_resource_types: ADDITIONAL_ORDERS_EXPECTED_RESOURCE_TYPES)
+      return false if card['suggestions'].blank?
+
+      card['suggestions'].all? do |suggestion|
+        actions = suggestion['actions']
+        actions&.all? do |action|
+          action['type'] == 'create' &&
+            (expected_resource_types.blank? || action_resource_type_check(action, expected_resource_types))
+        end
+      end
+    end
+
+    def coverage_information_response_type?(action) # rubocop:disable Metrics/CyclomaticComplexity
+      return false unless action.respond_to?(:[])
+      return false unless action['type'] == 'update'
+
+      resource = action['resource']&.to_hash
+      return false unless COVERAGE_INFO_EXPECTED_RESOURCE_TYPES.include? resource&.dig('resourceType')
+
+      unless resource&.dig('extension')&.any? { |extension| extension_url(extension) == COVERAGE_INFO_EXT_URL }
+        return false
+      end
+
+      true
+    end
+
+    def extension_url(extension)
+      return extension.url if extension.respond_to?(:url)
+      return extension['url'] if extension.respond_to?(:[])
+
+      nil
+    end
+
+    def create_or_update_coverage_card_response_type?(card)
+      card['suggestions']&.one? && card['suggestions'].first['actions']&.one? do |action|
+        create_or_update_coverage_action_response_type?(action)
+      end
+    end
+
+    def create_or_update_coverage_action_response_type?(action)
+      ['create', 'update'].include?(action['type']) && action_resource_type_check(action, ['Coverage'])
+    end
+
+    def create_questionnaire_action_response_type?(action)
+      action['type'] == 'create' && action_resource_type_check(action, ['Questionnaire'])
+    end
+
+    def external_reference_response_type?(card)
+      links = card['links']
+      return false if links.blank?
+
+      links.all? { |link| link['type'] == 'absolute' }
+    end
+
+    def form_completion_card_response_type?(card)
+      card['suggestions']&.all? do |suggestion|
+        suggestion['actions']&.one? { |action| form_completion_action_response_type?(action) }
+      end
+    end
+
+    def form_completion_action_response_type?(action)
+      action['type'] == 'create' &&
+        action_resource_type_check(action, ['Task']) &&
+        form_completion_task_questionnaire?(action['resource'])
+    end
+
+    def form_completion_task_questionnaire?(task_action)
+      task_action.dig('code', 'coding')&.any? { |code| code['code'] == 'complete-questionnaire' } &&
+        task_action['input']&.any? do |input|
+          input.dig('type', 'text') == 'questionnaire' && valid_url?(input['valueCanonical'])
+        end
+    end
+
+    def instructions_response_type?(card)
+      card['links'].blank? && card['suggestions'].blank?
+    end
+
+    def launch_smart_app_response_type?(card)
+      links = card['links']
+      return false if links.blank?
+
+      links.all? { |link| link['type'] == 'smart' }
+    end
+
+    def propose_alternative_request_response_type?(
+      card,
+      expected_resource_types: PROPOSE_ALTERNATIVE_REQUEST_EXPECTED_RESOURCE_TYPES
+    )
+      card['suggestions']&.any? do |suggestion|
+        actions = suggestion['actions']
+        has_update = check_action_type(actions, 'update', expected_resource_types)
+        has_delete = check_action_type(actions, 'delete', expected_resource_types)
+        has_create = check_action_type(actions, 'create', expected_resource_types)
+
+        has_update || (has_delete && has_create)
+      end
+    end
+
+    def check_action_type(actions, action_type, expected_resource_types)
+      actions&.any? do |action|
+        action['type'] == action_type &&
+          (expected_resource_types.blank? || action_resource_type_check(action, expected_resource_types))
+      end
+    end
+
+    def list_card_types_in_requests(hooks_requests)
+      sorted_cards = sorted_cards_from_requests(hooks_requests)
+
+      present_card_types = sorted_cards['cards'].select { |key, value| key.present? && value.present? }.keys
+      present_action_types = sorted_cards['actions'].select { |key, value| key.present? && value.present? }.keys
+
+      present_card_types.map { |type| "#{type}_card" } + present_action_types.map { |type| "#{type}_action" }
+    end
+
+    def sorted_cards_from_requests(hooks_requests)
+      return sorted_cards_from_cache if sorted_cards_cached?(hooks_requests)
+
+      sorted_cards = initialize_sorted_cards_hash
+
+      hooks_requests.each do |request|
+        sort_card_types_from_request(request, sorted_cards)
+      rescue JSON::ParserError
+        next
+      end
+
+      cache_sorted_cards(hooks_requests, sorted_cards)
+      sorted_cards
+    end
+
+    def sort_card_types_from_request(request, sorted_cards)
+      response_body = JSON.parse(request.response_body)
+      response_body['cards']&.each do |card|
+        sorted_cards['cards'][identify_card_type(card)] << card
+      end
+
+      response_body['systemActions']&.each do |action|
+        sorted_cards['actions'][identify_action_type(action)] << action
+      end
+    end
+
+    def initialize_sorted_cards_hash
+      {
+        'cards' => {
+          ADDITIONAL_ORDERS_RESPONSE_TYPE => [],
+          CREATE_OR_UPDATE_COVERAGE_RESPONSE_TYPE => [],
+          EXTERNAL_REFERENCE_RESPONSE_TYPE => [],
+          FORM_COMPLETION_RESPONSE_TYPE => [],
+          INSTRUCTIONS_RESPONSE_TYPE => [],
+          LAUNCH_SMART_APP_RESPONSE_TYPE => [],
+          PROPOSE_ALTERNATIVE_REQUEST_RESPONSE_TYPE => [],
+          nil => [] # unknown type
+        },
+        'actions' => {
+          COVERAGE_INFORMATION_RESPONSE_TYPE => [],
+          CREATE_OR_UPDATE_COVERAGE_RESPONSE_TYPE => [],
+          FORM_COMPLETION_RESPONSE_TYPE => [],
+          nil => [] # unknown type
+        }
+      }
+    end
+
+    def extract_coverage_information_extensions(sorted_cards)
+      coverage_information_extensions = []
+
+      sorted_cards['actions'][COVERAGE_INFORMATION_RESPONSE_TYPE].each do |coverage_information_action|
+        coverage_information_action['resource']['extension'].each do |extension|
+          coverage_information_extensions << extension if extension['url'] == COVERAGE_INFO_EXT_URL
+        end
+      end
+
+      coverage_information_extensions.map { |ext| FHIR::Extension.new(ext) }
+    end
+
+    def sorted_cards_cached?(requests)
+      return false unless scratch['sorted_cards'].present?
+      return false unless scratch['sorted_cards']['hook_instances'].length == requests.length
+
+      requests.all? do |request|
+        scratch['sorted_cards']['hook_instances'].include?(JSON.parse(request.request_body)&.dig('hookInstance'))
+      rescue JSON::ParserError
+        false
+      end
+    end
+
+    def cache_sorted_cards(requests, sorted_cards)
+      scratch['sorted_cards'] = {
+        'hook_instances' => hook_instances_from_requests(requests),
+        'data' => sorted_cards
+      }
+    rescue JSON::ParserError
+      nil
+    end
+
+    def sorted_cards_from_cache
+      scratch['sorted_cards']['data']
+    end
+
+    def hook_instances_from_requests(requests)
+      requests.map { |request| JSON.parse(request.request_body)&.dig('hookInstance') }.compact
+    end
+  end
+end

data/lib/davinci_crd_test_kit/{cards_validation.rb → cross_suite/cards_validation.rb}

@@ -1,9 +1,9 @@
-require_relative 'server_hook_request_validation'
+require_relative 'hook_request_field_validation'
 require_relative 'suggestion_actions_validation'
 
 module DaVinciCRDTestKit
   module CardsValidation
-    include DaVinciCRDTestKit::ServerHookRequestValidation
+    include DaVinciCRDTestKit::HookRequestFieldValidation
     include DaVinciCRDTestKit::SuggestionActionsValidation
 
     HOOKS = [
@@ -12,7 +12,18 @@ module DaVinciCRDTestKit
     ].freeze
 
     def card_required_fields
-      { 'summary' => String, 'indicator' => String, 'source' => Hash }
+      {
+        'v221' => {
+          'uuid' => String,
+          'summary' => String,
+          'source' => Hash
+        },
+        'v201' => {
+          'indicator' => String,
+          'summary' => String,
+          'source' => Hash
+        }
+      }
     end
 
     def source_required_fields
@@ -25,11 +36,22 @@ module DaVinciCRDTestKit
 
     def card_optional_fields
       {
-        'uuid' => String,
-        'detail' => String,
-        'suggestions' => Array,
-        'overrideReasons' => Array,
-        'links' => Array
+        'v221' => {
+          'detail' => String,
+          'indicator' => String,
+          'suggestions' => Array,
+          'selectionBehavior' => String,
+          'overrideReasons' => Array,
+          'links' => Array
+        },
+        'v201' => {
+          'detail' => String,
+          'uuid' => String,
+          'suggestions' => Array,
+          'selectionBehavior' => String,
+          'overrideReasons' => Array,
+          'links' => Array
+        }
       }
     end
 
@@ -41,12 +63,12 @@ module DaVinciCRDTestKit
       { 'label' => String, 'type' => String, 'url' => 'URL' }
     end
 
-    def valid_card_with_optionals?(card)
+    def valid_card_with_optionals?(card, version)
       current_error_count = messages.count { |msg| msg[:type] == 'error' }
-      card_optional_fields.each do |field, type|
+      card_optional_fields[version].each do |field, type|
         next unless card[field]
 
-        validate_presence_and_type(card, field, type, 'Card')
+        validate_presence_and_type(card, field, type, 'Card', required: false)
       end
 
       card_selection_behavior_check(card)
@@ -84,32 +106,83 @@ module DaVinciCRDTestKit
       end
     end
 
-    def card_links_check(card)
+    def card_links_check(card) # rubocop:disable Metrics/CyclomaticComplexity
       return unless card['links'].is_a?(Array) && card['links'].present?
 
       card['links'].each do |link|
         link_required_fields.each do |field, type|
           validate_presence_and_type(link, field, type, 'Link')
         end
+      end
 
-        card_link_type_check(card, link)
+      if card['links'].all? { |link| link['type'] == 'absolute' }
+        external_reference_card_check(card)
+      elsif card['links'].all? { |link| link['type'] == 'smart' }
+        smart_app_card_check(card)
+      else
+        add_message(
+          'error',
+          "All links must either be `absolute` or `smart` in card: #{card}"
+        )
       end
     end
 
-    def card_link_type_check(card, link)
-      return unless link['type']
+    def external_reference_card_check(card)
+      if card['suggestions'].present?
+        add_message(
+          'error',
+          "Cards with `absolute` links must not contain suggestions. In card `#{card}`"
+        )
+      end
 
-      unless ['absolute', 'smart'].include?(link['type'])
-        add_message('error',
-                    "`Link.type` must be `absolute` or `smart`. Got `#{link['type']}`: `#{link}`. In Card `#{card}`")
-        return
+      card['links'].each do |link|
+        next if link['appContext'].blank?
+
+        add_message(
+          'error',
+          '`appContext` field must not be present if the link type is absolute: ' \
+          "`#{link}`. In Card `#{card}`"
+        )
       end
+    end
 
-      return unless link['type'] == 'absolute' && link['appContext'].present?
+    def smart_app_card_check(card)
+      if card['suggestions'].blank?
+        add_message(
+          'error',
+          "Cards with `smart` links must contain at least one suggestion. In card `#{card}`"
+        )
+      elsif card['suggestions'].any? { |suggestion| suggestion['actions'].present? }
+        add_message(
+          'error',
+          "Cards with `smart` links must not contain any suggestion actions. In card `#{card}`"
+        )
+      end
+    end
 
-      msg = '`appContext` field should only be valued if the link type is smart and is not valid for absolute links: ' \
-            "`#{link}`. In Card `#{card}`"
-      add_message('error', msg)
+    def no_links_check(card, card_type)
+      return unless card['links'].present?
+
+      add_message(
+        'error',
+        "#{card_type} response must not contain links. In card: `#{card}`"
+      )
+    end
+
+    def additional_orders_check(card)
+      no_links_check(card, 'Additional Orders')
+    end
+
+    def create_or_update_coverage_check(card)
+      no_links_check(card, 'Update Coverage Records')
+    end
+
+    def form_completion_check(card)
+      no_links_check(card, 'Form Completion')
+    end
+
+    def propose_alternate_request_check(card)
+      no_links_check(card, 'Propose Alternate Request')
     end
 
     def card_suggestions_check(card)
@@ -122,6 +195,7 @@ module DaVinciCRDTestKit
 
     def process_suggestion(card, suggestion)
       validate_presence_and_type(suggestion, 'label', String, 'Suggestion')
+      validate_presence_and_type(suggestion, 'uuid', String, 'Suggestion')
       return unless suggestion['actions']
 
       validate_and_process_actions(card, suggestion)
@@ -166,7 +240,7 @@ module DaVinciCRDTestKit
     def card_summary_check(card)
       return if !card['summary'].is_a?(String) || card['summary'].length < 140
 
-      add_message('error', "`summary` is over the 140-character limit: `#{card}`")
+      add_message('error', "`summary` is over the 140-character limit: `#{card['summary']}`")
     end
 
     def card_indicator_check(card)
@@ -176,10 +250,10 @@ module DaVinciCRDTestKit
       add_message('error', msg)
     end
 
-    def cards_check(cards)
+    def cards_check(cards, version = 'v221')
       cards.each do |card|
         current_error_count = messages.count { |msg| msg[:type] == 'error' }
-        card_required_fields.each do |field, type|
+        card_required_fields[version].each do |field, type|
           validate_presence_and_type(card, field, type, 'Card')
         end
 
@@ -195,7 +269,7 @@ module DaVinciCRDTestKit
       "Server response #{index}"
     end
 
-    def perform_cards_validation(cards, response_index = 0)
+    def perform_cards_validation(cards, response_has_system_actions, version, response_index)
       unless cards
         add_message('error', "#{response_label(response_index + 1)} did not have the `cards` field.")
         return
@@ -205,9 +279,10 @@ module DaVinciCRDTestKit
         return
       end
       warning do
-        assert cards.present?, "#{response_label(response_index + 1)} has no decision support."
+        assert cards.present? || response_has_system_actions,
+               "#{response_label(response_index + 1)} has no decision support."
       end
-      cards_check(cards)
+      cards_check(cards, version)
     end
 
     def all_requests
@@ -216,23 +291,5 @@ module DaVinciCRDTestKit
         reqs.concat(requests)
       end
     end
-
-    def extract_all_valid_cards_from_hooks_responses
-      all_requests.keep_if { |request| request.status == 200 }
-      all_requests.each_with_index do |request, index|
-        service_response = JSON.parse(request.response_body)
-        perform_cards_validation(service_response['cards'], index)
-      rescue JSON::ParserError
-        add_message('error', "Invalid JSON: #{response_label(response_index + 1).downcase} is not a valid JSON.")
-      end
-    end
-
-    def extract_valid_cards_with_links_from_hooks_responses
-      extract_all_valid_cards_from_hooks_responses
-
-      valid_cards.each do |card|
-        valid_cards_with_links << card if valid_card_with_optionals?(card) && (card['links'])
-      end
-    end
   end
 end

data/lib/davinci_crd_test_kit/cross_suite/coverage-information_stu201_metadata.yml

@@ -0,0 +1,27 @@
+---
+:name: coverage_information
+:version: v2.0.1
+:reformatted_version: v201
+:profile_url: http://hl7.org/fhir/us/davinci-crd/StructureDefinition/ext-coverage-information
+:profile_name: "Extension: Coverage Information"
+:profile_version: 2.0.1
+:title: Coverage Information
+:must_supports:
+  :extensions:
+  - :id: Extension.extension:coverage
+    :path: extension
+    :url: coverage
+  - :id: Extension.extension:covered
+    :path: extension
+    :url: covered
+  - :id: Extension.extension:doc-needed
+    :path: extension
+    :url: doc-needed
+  - :id: Extension.extension:doc-purpose
+    :path: extension
+    :url: doc-purpose
+  - :id: Extension.extension:info-needed
+    :path: extension
+    :url: info-needed
+  :slices:
+  :elements:

data/lib/davinci_crd_test_kit/cross_suite/coverage-information_stu221_metadata.yml

@@ -0,0 +1,60 @@
+---
+:name: coverage_information
+:version: v2.2.1
+:reformatted_version: v221
+:profile_url: http://hl7.org/fhir/us/davinci-crd/StructureDefinition/ext-coverage-information
+:profile_name: "Extension: Coverage Information"
+:profile_version: 2.2.1
+:title: Coverage Information
+:must_supports:
+  :extensions:
+  - :id: Extension.extension:coverage
+    :path: extension
+    :url: coverage
+  - :id: Extension.extension:covered
+    :path: extension
+    :url: covered
+  - :id: Extension.extension:pa-needed
+    :path: extension
+    :url: pa-needed
+  - :id: Extension.extension:doc-needed
+    :path: extension
+    :url: doc-needed
+  - :id: Extension.extension:doc-purpose
+    :path: extension
+    :url: doc-purpose
+  - :id: Extension.extension:info-needed
+    :path: extension
+    :url: info-needed
+  - :id: Extension.extension:billingCode
+    :path: extension
+    :url: billingCode
+  - :id: Extension.extension:reason
+    :path: extension
+    :url: reason
+  - :id: Extension.extension:detail
+    :path: extension
+    :url: detail
+  - :id: Extension.extension:dependency
+    :path: extension
+    :url: dependency
+  - :id: Extension.extension:questionnaire
+    :path: extension
+    :url: questionnaire
+  - :id: Extension.extension:date
+    :path: extension
+    :url: date
+  - :id: Extension.extension:coverage-assertion-id
+    :path: extension
+    :url: coverage-assertion-id
+  - :id: Extension.extension:satisfied-pa-id
+    :path: extension
+    :url: satisfied-pa-id
+  - :id: Extension.extension:contact
+    :path: extension
+    :url: contact
+  - :id: Extension.extension:expiry-date
+    :path: extension
+    :url: expiry-date
+  :slices:
+  :elements: