davinci_crd_test_kit 0.12.2 → 0.14.0

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:

data/lib/davinci_crd_test_kit/cross_suite/fhirpath_on_cds_request.rb

@@ -0,0 +1,177 @@
+require 'date'
+require 'uri'
+
+module DaVinciCRDTestKit
+  class FhirpathServiceError < StandardError; end
+
+  # Methods for executing simple fhirpath queries on cds request objects, e.g., to resolve
+  # prefetch tokens.
+  #
+  # If resolve() calls are in scope (CRD 2.2.1 and beyond), then an implementation of the
+  # `resolve(target)` method must be provided, where `target` is
+  module FhirpathOnCDSRequest
+    SUPPORTED_POST_RESOLVE_FUNCTIONS = %w[ofType today resolve].freeze
+    TODAY_EXPRESSION_PATTERN = /\Atoday\(\)\s*(?:([+-])\s*(\d+)\s+days)?\z/
+
+    # fhirpath services doesn't handle the following, which are handled manually
+    # - non-fhir objects
+    # - resolve()
+    # - Bundle.entry.resource when resolve() appears in the remaining query (to track entry.fullUrl per entry)
+    # - standalone today() expressions (today(), today()-N, today()+N)
+    def execute_fhirpath_on_cds_request(hook_request, fhirpath_query)
+      today_result = execute_today_expression(fhirpath_query)
+      return today_result if today_result
+
+      cds_component, remaining_query = identify_cds_component(fhirpath_query)
+      execution_targets = cds_component.present? ? get_cds_field(hook_request, cds_component) : hook_request
+
+      execution_targets.map do |execution_target|
+        @current_base_fhir_server = hook_request['fhirServer']
+        execute(execution_target, remaining_query)
+      end.flatten.compact
+    ensure
+      # clean-up identity
+      @current_base_fhir_server = nil
+    end
+
+    private
+
+    # -------------------------------------------------------------------------
+    # today() handling
+    # -------------------------------------------------------------------------
+
+    def execute_today_expression(fhirpath_query)
+      match = fhirpath_query.strip.match(TODAY_EXPRESSION_PATTERN)
+      return nil unless match
+
+      date = Date.today
+      if match[1]
+        days = match[2].to_i
+        date = match[1] == '+' ? date + days : date - days
+      end
+      [date.to_s]
+    end
+
+    # -------------------------------------------------------------------------
+    # resolve() handling
+    # -------------------------------------------------------------------------
+
+    # input is either
+    # - string representing a FHIR reference, absolute or relative
+    # - a FHIR Reference object with an absolute or relative reference in the `reference` element
+    # Default implementation does not perform any resolution
+    def resolve(_reference)
+      nil
+    end
+
+    # -------------------------------------------------------------------------
+    # CDS Request Handling
+    # -------------------------------------------------------------------------
+
+    # returns a pair of [cds component, remaining query]
+    def identify_cds_component(fhirpath_query)
+      if fhirpath_query.starts_with?('context.')
+        context_field, remaining_query = fhirpath_query[8..].split('.', 2)
+        ["context.#{context_field}", remaining_query]
+      elsif fhirpath_query.starts_with?('%')
+        prefetch_key, remaining_query = fhirpath_query[1..].split('.', 2)
+        ["prefetch.#{prefetch_key}",  remaining_query]
+      else
+        # everything is in the cds request
+        [fhirpath_query, nil]
+      end
+    end
+
+    def get_cds_field(request, cds_path)
+      value = cds_path.split('.').reduce(request) { |hash, path| hash.present? ? hash[path] : nil }
+
+      value.is_a?(Array) ? value : [value]
+    end
+
+    # -------------------------------------------------------------------------
+    # Main execution loop
+    # -------------------------------------------------------------------------
+
+    def execute(execution_target, fhirpath_query)
+      return execution_target unless fhirpath_query.present? && execution_target.present?
+
+      if fhirpath_query.starts_with?('resolve()')
+        execute_resolve(execution_target, fhirpath_query)
+      elsif fhirpath_query.starts_with?('entry.resource.') && fhirpath_query.include?('resolve()')
+        execute_entry_resource_step(execution_target, fhirpath_query)
+      else
+        execute_fhirpath_step(execution_target, fhirpath_query)
+      end
+    end
+
+    def execute_fhirpath_step(execution_target, fhirpath_query)
+      path_to_execute, query_after_next_resolve = fhirpath_query.split('.resolve()', 2)
+      remaining_query = "#{'resolve()' if fhirpath_query.include?('resolve()')}#{query_after_next_resolve}"
+      delegate_execution_to_fhirpath_engine(execution_target, path_to_execute).compact.map do |result|
+        execute(result, remaining_query)
+      end.flatten.compact
+    end
+
+    def execute_resolve(execution_target, fhirpath_query)
+      referenced = resolve(execution_target)
+      return nil unless referenced.present?
+
+      execute(referenced, fhirpath_query[10..])
+    end
+
+    def execute_entry_resource_step(execution_target, fhirpath_query)
+      validate_entry_resource_query!(fhirpath_query)
+      return nil unless execution_target['entry'].present?
+
+      Array.wrap(execution_target['entry']).map do |entry|
+        @current_base_fhir_server = base_fhir_server_for_identity(entry['fullUrl'])
+        execute(entry['resource'], fhirpath_query[15..])
+      end.flatten.compact
+    end
+
+    def validate_entry_resource_query!(fhirpath_query)
+      _, post_resolve = fhirpath_query.split('.resolve()', 2)
+      return unless post_resolve.present?
+
+      unsupported = post_resolve.scan(/[a-zA-Z_]\w*(?=\()/).uniq - SUPPORTED_POST_RESOLVE_FUNCTIONS
+      return if unsupported.empty?
+
+      raise FhirpathServiceError,
+            "Unsupported function(s) after resolve() in '#{fhirpath_query}': #{unsupported.join(', ')}. " \
+            "Supported: #{SUPPORTED_POST_RESOLVE_FUNCTIONS.join(', ')}."
+    end
+
+    def base_fhir_server_for_identity(current_resource_identity)
+      return nil unless current_resource_identity.present?
+
+      parsed_identity = URI.parse(current_resource_identity)
+      return nil unless ['http', 'https'].include?(parsed_identity.scheme)
+
+      current_resource_identity.split('/')[0..-3].join('/')
+    rescue URI::InvalidURIError
+      nil
+    end
+
+    # -------------------------------------------------------------------------
+    # fhirpath delegation
+    # -------------------------------------------------------------------------
+
+    def fhirpath_evaluator
+      @fhirpath_evaluator ||= Inferno::DSL::FhirpathEvaluation::Evaluator.new
+    end
+
+    def delegate_execution_to_fhirpath_engine(hash, fhirpath_query)
+      return [hash] unless fhirpath_query.present?
+      return [] unless hash.present?
+
+      result = fhirpath_evaluator.call_fhirpath_service(hash, fhirpath_query)
+      unless result.status.to_s.starts_with?('2')
+        raise FhirpathServiceError,
+              "FHIRPath service returned #{result.status} for query '#{fhirpath_query}' " \
+              "on resource #{hash.to_json}: #{result.body}"
+      end
+
+      JSON.parse(result.body).map { |entry| entry['element'] }
+    end
+  end
+end