davinci_crd_test_kit 0.13.0 → 0.14.1

data/lib/davinci_crd_test_kit/server/v2.2.1/verify_response/coverage_information_system_action_validation_test.rb

@@ -0,0 +1,130 @@
+require_relative '../../server_hook_request_validation'
+require_relative '../../server_test_helper'
+require_relative '../../server_hook_helper'
+require_relative '../../../cross_suite/cards_identification'
+require_relative '../../../cross_suite/response_logical_model_validation'
+require_relative 'hook_request_resource_resolution'
+
+module DaVinciCRDTestKit
+  module V221
+    class CoverageInformationSystemActionValidationTest < Inferno::Test
+      include DaVinciCRDTestKit::ServerHookRequestValidation
+      include DaVinciCRDTestKit::ServerTestHelper
+      include DaVinciCRDTestKit::ServerHookHelper
+      include HookRequestResourceResolution
+      include DaVinciCRDTestKit::CardsIdentification
+      include DaVinciCRDTestKit::ResponseLogicalModelValidation
+
+      COVERAGE_INFO_EXT_URL = 'http://hl7.org/fhir/us/davinci-crd/StructureDefinition/ext-coverage-information'.freeze
+
+      title 'Coverage Information system actions are valid'
+      id :crd_v221_coverage_info_system_action_validation
+      description %(
+        This test validates all [Coverage
+        Information](https://hl7.org/fhir/us/davinci-crd/2.2.1/en/cards.html#coverage-information-response-type)
+        system actions received. It verifies the following for each action:
+        - The action type is `update`.
+        - The resource within the action conforms its respective FHIR profile.
+        - The resource does not change any data elements other than adding or
+          modifying the `coverage-information` extension.
+
+        Additionally, the test examines the `coverage-info` extensions within
+        the resource to ensure that:
+        - Entries referencing differing coverage have distinct
+        `coverage-assertion-ids` and `satisfied-pa-ids` (if present).
+        - Entries referencing the same coverage have the same
+        `coverage-assertion-ids` and `satisfied-pa-ids` (if present).
+      )
+
+      verifies_requirements 'hl7.fhir.us.davinci-crd_2.2.1@resp-26',
+                            'hl7.fhir.us.davinci-crd_2.2.1@resp-32',
+                            'hl7.fhir.us.davinci-crd_2.2.1@resp-37',
+                            'hl7.fhir.us.davinci-crd_2.2.1@resp-47',
+                            'hl7.fhir.us.davinci-crd_2.2.1@resp-48',
+                            'hl7.fhir.us.davinci-crd_2.2.1@resp-52'
+
+      input :invoked_hook
+      input :mock_ehr_bundle, optional: true
+      output :coverage_info
+
+      def verify_only_coverage_info_changed(action, request)
+        source_resource = find_action_source_resource(action, request)
+        updated_resource_hash = action['resource']
+        resource_ref = "#{updated_resource_hash['resourceType']}/#{updated_resource_hash['id']}"
+        unless source_resource
+          messages << {
+            type: 'warning',
+            message: 'Inferno could not resolve the original source resource for Coverage Information systemAction ' \
+                     "targeting #{resource_ref}, so it could not verify that only coverage-information extensions " \
+                     'were changed.'
+          }
+          return
+        end
+
+        return if only_coverage_information_changed?(source_resource.to_hash, updated_resource_hash)
+
+        add_message(
+          'error',
+          "#{resource_ref}: resource content changed outside the coverage-information extension."
+        )
+      end
+
+      def body_has_no_system_actions?(body)
+        !body.is_a?(Hash) ||
+          body['systemActions'].blank? ||
+          !body['systemActions'].is_a?(Array) ||
+          !body['systemActions'].all?(Hash)
+      end
+
+      def coverage_info_actions(request)
+        return [] if request.status != 200
+
+        response_body = JSON.parse(request.response_body)
+
+        return [] if body_has_no_system_actions?(response_body)
+
+        response_body['systemActions'].select { |action| coverage_information_response_type? action }
+      rescue JSON::ParserError
+        []
+      end
+
+      run do
+        load_tagged_requests(tested_hook_name)
+
+        all_coverage_info_actions = []
+        coverage_info_count = 0
+
+        successful_requests = requests.select { |request| request.status == 200 }
+
+        skip_if successful_requests.blank?,
+                'No successful hook responses were received'
+
+        requests.each_with_index do |request, index|
+          actions = coverage_info_actions(request)
+
+          coverage_info_count += actions.length
+
+          perform_response_logical_model_validation(
+            nil,
+            actions,
+            request.request_body,
+            index,
+            '2.2.1'
+          )
+          actions.each { |action| verify_only_coverage_info_changed(action, request) }
+
+          all_coverage_info_actions.concat(actions)
+        end
+
+        skip_if coverage_info_count.zero?,
+                "#{tested_hook_name} hook responses do not contain any Coverage Information system actions."
+
+        output coverage_info: all_coverage_info_actions.to_json
+
+        no_error_validation(
+          'Not all Coverage Information system actions were valid. See messages for more information.'
+        )
+      end
+    end
+  end
+end

data/lib/davinci_crd_test_kit/server/v2.2.1/verify_response/create_or_update_coverage_info_response_validation_test.rb

@@ -0,0 +1,119 @@
+require_relative '../../server_test_helper'
+require_relative '../../server_hook_helper'
+require_relative '../../../cross_suite/cards_identification'
+require_relative '../../../cross_suite/response_logical_model_validation'
+
+module DaVinciCRDTestKit
+  module V221
+    class CreateOrUpdateCoverageInfoResponseValidationTest < Inferno::Test
+      include DaVinciCRDTestKit::ServerTestHelper
+      include DaVinciCRDTestKit::ServerHookHelper
+      include DaVinciCRDTestKit::CardsIdentification
+      include DaVinciCRDTestKit::ResponseLogicalModelValidation
+
+      title 'Create or Update Coverage Information cards and system actions are valid'
+      id :crd_v221_create_or_update_coverage_info_response_validation
+      description %(
+        This test validates the Create or Update Coverage Information cards or
+        system actions received from the CRD service, as per the specifications
+        outlined in the [Da Vinci CRD Implementation
+        Guide](https://hl7.org/fhir/us/davinci-crd/2.2.1/en/cards.html#update-coverage-records-response-type).
+
+        - **Checking for Presence:**
+          The test first checks if any Create or Update Coverage Information
+          cards or system actions are present in the returned valid cards or
+          valid system actions.
+          - **For cards**: it ensures there are cards with a `suggestions` array
+            containing a single suggestion, and the `actions` array of that
+            suggestion has one `create` or `update` action for the `Coverage`
+            resource.
+          - **For system actions**: it checks for the presence of `create` or
+            `update` actions for the `Coverage` resource.
+
+        - **Validating:**
+          If any Create or Update Coverage Information cards or system actions
+          are found, each `Coverage` resource is validated against the base FHIR
+          Coverage resource.
+
+          If no Create or Update Coverage Information cards or system actions
+          are received, the test is skipped.
+      )
+
+      verifies_requirements 'hl7.fhir.us.davinci-crd_2.2.1@resp-3',
+                            'hl7.fhir.us.davinci-crd_2.2.1@resp-71'
+
+      input :invoked_hook
+
+      optional
+
+      def body_has_no_cards?(body)
+        !body.is_a?(Hash) ||
+          body['cards'].blank? ||
+          !body['cards'].is_a?(Array) ||
+          !body['cards'].all?(Hash)
+      end
+
+      def update_coverage_cards(request)
+        return [] if request.status != 200
+
+        response_body = JSON.parse(request.response_body)
+
+        return [] if body_has_no_cards?(response_body)
+
+        response_body['cards'].select { |card| create_or_update_coverage_card_response_type? card }
+      rescue JSON::ParserError
+        []
+      end
+
+      def body_has_no_system_actions?(body)
+        !body.is_a?(Hash) ||
+          body['systemActions'].blank? ||
+          !body['systemActions'].is_a?(Array) ||
+          !body['systemActions'].all?(Hash)
+      end
+
+      def update_coverage_actions(request)
+        return [] if request.status != 200
+
+        response_body = JSON.parse(request.response_body)
+
+        return [] if body_has_no_system_actions?(response_body)
+
+        response_body['systemActions'].select { |action| create_or_update_coverage_action_response_type? action }
+      rescue JSON::ParserError
+        []
+      end
+
+      run do
+        load_tagged_requests(tested_hook_name)
+
+        update_coverage_count = 0
+
+        successful_requests = requests.select { |request| request.status == 200 }
+
+        skip_if successful_requests.blank?,
+                'No successful hook responses were received'
+
+        requests.each_with_index do |request, index|
+          cards = update_coverage_cards(request)
+          actions = update_coverage_actions(request)
+
+          update_coverage_count += cards.length + actions.length
+
+          perform_response_logical_model_validation(
+            cards,
+            actions,
+            request.request_body,
+            index,
+            '2.2.1'
+          )
+        end
+
+        skip_if update_coverage_count.zero?,
+                "#{tested_hook_name} hook responses do not contain any Update Coverage Records cards or system actions."
+
+        no_error_validation('Not all Update Coverage Records responses were valid. See messages for more information.')
+      end
+    end
+  end
+end

data/lib/davinci_crd_test_kit/server/v2.2.1/verify_response/external_reference_card_validation_test.rb

@@ -0,0 +1,89 @@
+require_relative '../../server_test_helper'
+require_relative '../../server_hook_helper'
+require_relative '../../../cross_suite/cards_identification'
+require_relative '../../../cross_suite/response_logical_model_validation'
+
+module DaVinciCRDTestKit
+  module V221
+    class ExternalReferenceCardValidationTest < Inferno::Test
+      include DaVinciCRDTestKit::ServerTestHelper
+      include DaVinciCRDTestKit::ServerHookHelper
+      include DaVinciCRDTestKit::CardsIdentification
+      include DaVinciCRDTestKit::ResponseLogicalModelValidation
+
+      title 'External Reference cards are valid'
+      id :crd_v221_external_reference_card_validation
+      description %(
+        This test verifies the presence of valid External Reference cards within
+        the CRD service responses.
+
+        As per the [Da Vinci CRD Implementation
+        Guide](https://hl7.org/fhir/us/davinci-crd/2.2.1/en/cards.html#external-reference-response-type),
+        External Reference cards must contain links with the type set to
+        `absolute`. This test checks for the presence of any External Reference
+        cards by verifying:
+        - The presence of a `links` array within each card.
+        - That every link in the `links` array of a card is of type `absolute`.
+
+        The test will be skipped if no External Reference cards are found within
+        the returned valid cards.
+      )
+
+      verifies_requirements 'hl7.fhir.us.davinci-crd_2.2.1@resp-19',
+                            'hl7.fhir.us.davinci-crd_2.2.1@resp-22'
+
+      input :invoked_hook
+
+      optional
+
+      def body_has_no_cards?(body)
+        !body.is_a?(Hash) ||
+          body['cards'].blank? ||
+          !body['cards'].is_a?(Array) ||
+          !body['cards'].all?(Hash)
+      end
+
+      def external_reference_cards(request)
+        return [] if request.status != 200
+
+        response_body = JSON.parse(request.response_body)
+
+        return [] if body_has_no_cards?(response_body)
+
+        response_body['cards'].select { |card| external_reference_response_type? card }
+      rescue JSON::ParserError
+        []
+      end
+
+      run do
+        load_tagged_requests(tested_hook_name)
+
+        external_reference_count = 0
+
+        successful_requests = requests.select { |request| request.status == 200 }
+
+        skip_if successful_requests.blank?,
+                'No successful hook responses were received'
+
+        requests.each_with_index do |request, index|
+          cards = external_reference_cards(request)
+
+          external_reference_count += cards.length
+
+          perform_response_logical_model_validation(
+            cards,
+            nil,
+            request.request_body,
+            index,
+            '2.2.1'
+          )
+        end
+
+        skip_if external_reference_count.zero?,
+                "#{tested_hook_name} hook responses do not contain any External Reference cards."
+
+        no_error_validation('Not all External Reference cards were valid. See messages for more information.')
+      end
+    end
+  end
+end

data/lib/davinci_crd_test_kit/server/v2.2.1/verify_response/form_completion_response_validation_test.rb

@@ -0,0 +1,126 @@
+require_relative '../../server_test_helper'
+require_relative '../../server_hook_helper'
+require_relative '../../../cross_suite/cards_identification'
+require_relative '../../../cross_suite/response_logical_model_validation'
+
+module DaVinciCRDTestKit
+  module V221
+    class FormCompletionResponseValidationTest < Inferno::Test
+      include DaVinciCRDTestKit::ServerTestHelper
+      include DaVinciCRDTestKit::ServerHookHelper
+      include DaVinciCRDTestKit::CardsIdentification
+      include DaVinciCRDTestKit::ResponseLogicalModelValidation
+
+      title 'Request Form Completion cards and system actions are valid'
+      id :crd_v221_request_form_completion_response_validation
+      description %(
+        This test validates the Request Form Completion cards or system actions
+        received from the CRD service, as per the specifications outlined in the
+        [Da Vinci CRD Implementation
+        Guide](https://hl7.org/fhir/us/davinci-crd/2.2.1/en/cards.html#request-form-completion-response-type).
+
+        - **Checking for Presence:**
+          The test begins by verifying whether any Request Form Completion cards
+          or system actions are present.
+          - **For cards:** It ensures that there are cards with `suggestions`
+            containing `create` actions for the `Task` resource, specifically:
+            - The `Task` must have a `code` of `complete-questionnaire`.
+            - The `Task` should include an input of type `text`
+              (`Task.input.type.text`) labeled as `questionnaire` and associated
+              with a valid canonical URL (`Task.input.valueCanonical`).
+          - **For system actions:** It checks for the presence of `create`
+            actions for the `Task` resource with the characteristics described
+            above.
+
+        - **Validating:**
+          If any Request Form Completion cards or system actions are found, the
+          test proceeds to validate them. Each `Task` resource is validated
+          against the [CRD Questionnaire Task
+          profile](https://hl7.org/fhir/us/davinci-crd/2.2.1/en/StructureDefinition-profile-taskquestionnaire.html).
+          Additionally, if any actions for the creation of a `Questionnaire` are
+          found, the test verifies that they include the
+          `davinci-crd.if-none-exist` extension.
+
+        If no Request Form Completion cards or system actions are received, the test is skipped.
+      )
+
+      verifies_requirements 'hl7.fhir.us.davinci-crd_2.2.1@dev-20',
+                            'hl7.fhir.us.davinci-crd_2.2.1@resp-3',
+                            'hl7.fhir.us.davinci-crd_2.2.1@resp-62',
+                            'hl7.fhir.us.davinci-crd_2.2.1@resp-65'
+
+      input :invoked_hook
+
+      optional
+
+      def body_has_no_cards?(body)
+        !body.is_a?(Hash) ||
+          body['cards'].blank? ||
+          !body['cards'].is_a?(Array) ||
+          !body['cards'].all?(Hash)
+      end
+
+      def form_completion_cards(request)
+        return [] if request.status != 200
+
+        response_body = JSON.parse(request.response_body)
+
+        return [] if body_has_no_cards?(response_body)
+
+        response_body['cards'].select { |card| form_completion_card_response_type? card }
+      rescue JSON::ParserError
+        []
+      end
+
+      def body_has_no_system_actions?(body)
+        !body.is_a?(Hash) ||
+          body['systemActions'].blank? ||
+          !body['systemActions'].is_a?(Array) ||
+          !body['systemActions'].all?(Hash)
+      end
+
+      def form_completion_actions(request)
+        return [] if request.status != 200
+
+        response_body = JSON.parse(request.response_body)
+
+        return [] if body_has_no_system_actions?(response_body)
+
+        response_body['systemActions'].select { |action| form_completion_action_response_type? action }
+      rescue JSON::ParserError
+        []
+      end
+
+      run do
+        load_tagged_requests(tested_hook_name)
+
+        form_completion_count = 0
+
+        successful_requests = requests.select { |request| request.status == 200 }
+
+        skip_if successful_requests.blank?,
+                'No successful hook responses were received'
+
+        requests.each_with_index do |request, index|
+          cards = form_completion_cards(request)
+          actions = form_completion_actions(request)
+
+          form_completion_count += cards.length + actions.length
+
+          perform_response_logical_model_validation(
+            cards,
+            actions,
+            request.request_body,
+            index,
+            '2.2.1'
+          )
+        end
+
+        skip_if form_completion_count.zero?,
+                "#{tested_hook_name} hook responses do not contain any Request Form Completion cards or system actions."
+
+        no_error_validation('Not all Request Form Completion responses were valid. See messages for more information.')
+      end
+    end
+  end
+end

data/lib/davinci_crd_test_kit/server/v2.2.1/verify_response/hook_request_resource_resolution.rb

@@ -0,0 +1,174 @@
+module DaVinciCRDTestKit
+  module V221
+    module HookRequestResourceResolution
+      def mock_ehr_bundle_resource
+        @mock_ehr_bundle_resource ||= JSON.parse(mock_ehr_bundle) if mock_ehr_bundle.present?
+      rescue JSON::ParserError
+        nil
+      end
+
+      def matching_request_for_action(action)
+        requests.find do |request|
+          response = JSON.parse(request.response_body)
+          request.status == 200 && Array(response['systemActions']).any? { |candidate| candidate == action }
+        rescue JSON::ParserError
+          false
+        end
+      end
+
+      # Resolve the original resource being updated by a systemAction.
+      # - appointment-book: look in context.appointments; if the action targets a ServiceRequest,
+      #   follow the Appointment basedOn reference and resolve that from prefetch or mock EHR data
+      # - order-sign/order-select: look in context.draftOrders
+      # - other hooks: resolve from prefetch or mock EHR data because context may carry only ids/references
+      def find_action_source_resource(action, request)
+        action_resource = action['resource']
+        return unless action_resource.is_a?(Hash)
+
+        target_type = action_resource['resourceType']
+        target_id = action_resource['id']
+        request_body = parse_request_body(request)
+        return unless target_type.present? && target_id.present? && request_body
+
+        hook_context_resource(request_body, target_type, target_id) ||
+          fallback_source_resource(request_body, target_type, target_id)
+      end
+
+      def only_coverage_information_changed?(source_resource_hash, updated_resource_hash)
+        return true if coverage_information_extension_only_payload?(updated_resource_hash)
+
+        source_without_coverage_info = normalize_value(strip_coverage_info_extensions(source_resource_hash))
+        updated_without_coverage_info = normalize_value(strip_coverage_info_extensions(updated_resource_hash))
+
+        source_without_coverage_info == updated_without_coverage_info
+      end
+
+      def coverage_information_extension_only_payload?(resource_hash)
+        return false unless resource_hash.is_a?(Hash)
+
+        strip_coverage_info_extensions(resource_hash).keys.all? { |key| ['resourceType', 'id', 'meta'].include?(key) }
+      end
+
+      def strip_coverage_info_extensions(resource_hash)
+        normalized_hash = resource_hash.deep_dup
+        return normalized_hash unless normalized_hash['extension'].is_a?(Array)
+
+        normalized_hash['extension'] = normalized_hash['extension'].reject do |extension|
+          extension['url'] == DaVinciCRDTestKit::CardsIdentification::COVERAGE_INFO_EXT_URL
+        end
+        normalized_hash.delete('extension') if normalized_hash['extension'].empty?
+        normalized_hash
+      end
+
+      def normalize_value(value)
+        case value
+        when Hash
+          value.transform_values { |child| normalize_value(child) }
+        when Array
+          value.map { |child| normalize_value(child) }.sort_by(&:to_json)
+        else
+          value
+        end
+      end
+
+      def find_appointment_book_resource(request_body, target_type, target_id)
+        appointments_bundle = request_body.dig('context', 'appointments')
+        find_resource_in_bundle(appointments_bundle, target_type, target_id) ||
+          appointment_book_service_request(request_body, appointments_bundle, target_id)
+      end
+
+      def find_draft_orders_resource(request_body, target_type, target_id)
+        draft_orders_bundle = request_body.dig('context', 'draftOrders')
+        find_resource_in_bundle(draft_orders_bundle, target_type, target_id)
+      end
+
+      def fallback_source_resource(request_body, target_type, target_id)
+        find_resource_in_prefetch(request_body, target_type, target_id) ||
+          find_resource_in_bundle(mock_ehr_bundle_resource, target_type, target_id)
+      end
+
+      def hook_context_resource(request_body, target_type, target_id)
+        case tested_hook_name
+        when 'appointment-book'
+          find_appointment_book_resource(request_body, target_type, target_id)
+        when 'order-sign', 'order-select'
+          find_draft_orders_resource(request_body, target_type, target_id)
+        end
+      end
+
+      def appointment_book_service_request(request_body, appointments_bundle_hash, target_id)
+        target_type = 'ServiceRequest'
+        appointments_bundle = parse_bundle(appointments_bundle_hash)
+        appointment = (appointments_bundle&.entry || [])
+          .filter_map(&:resource)
+          .find { |candidate| appointment_based_on_matches_target?(candidate, target_type, target_id) }
+        return unless appointment
+
+        find_resource_in_prefetch(request_body, target_type, target_id) ||
+          find_resource_in_bundle(mock_ehr_bundle_resource, target_type, target_id)
+      end
+
+      def appointment_based_on_matches_target?(appointment, target_type, target_id)
+        Array(appointment.basedOn).any? do |reference|
+          reference_parts(reference.reference) == [target_type, target_id]
+        end
+      end
+
+      def find_resource_in_prefetch(request_body, target_type, target_id)
+        Array(request_body['prefetch']&.values).each do |prefetched_value|
+          if prefetched_value.is_a?(Hash) &&
+             prefetched_value['resourceType'] == target_type &&
+             prefetched_value['id'] == target_id
+            return FHIR.from_contents(prefetched_value.to_json)
+          end
+
+          resource = find_resource_in_bundle(prefetched_value, target_type, target_id)
+          return resource if resource
+        end
+
+        nil
+      end
+
+      def find_resource_by_reference(request_body, reference)
+        target_type, target_id = reference_parts(reference)
+        return unless target_type.present? && target_id.present?
+
+        find_resource_in_prefetch(request_body, target_type, target_id) ||
+          find_resource_in_bundle(mock_ehr_bundle_resource, target_type, target_id)
+      end
+
+      def find_resource_in_bundle(bundle_hash, target_type, target_id)
+        bundle = parse_bundle(bundle_hash)
+        return unless bundle&.entry
+
+        bundle.entry
+          .filter_map(&:resource)
+          .find { |resource| resource.resourceType == target_type && resource.id == target_id }
+      end
+
+      def reference_parts(reference)
+        return if reference.blank?
+
+        parts = reference.split('/')
+        return unless parts.length >= 2
+
+        [parts[-2], parts[-1]]
+      end
+
+      def parse_bundle(bundle_hash)
+        bundle = FHIR.from_contents(bundle_hash.to_json)
+        bundle if bundle.is_a?(FHIR::Bundle)
+      rescue StandardError
+        nil
+      end
+
+      def parse_request_body(request)
+        return unless request&.request_body.present?
+
+        JSON.parse(request.request_body)
+      rescue JSON::ParserError
+        nil
+      end
+    end
+  end
+end