davinci_crd_test_kit 0.13.0 → 0.14.1

data/lib/davinci_crd_test_kit/server/v2.2.1/verify_request/service_request_no_custom_extensions_test.rb

@@ -0,0 +1,120 @@
+require_relative '../../resource_extractor'
+require_relative '../../server_hook_helper'
+
+module DaVinciCRDTestKit
+  module V221
+    class ServiceRequestNoCustomExtensionsTest < Inferno::Test
+      include DaVinciCRDTestKit::ResourceExtractor
+      include DaVinciCRDTestKit::ServerHookHelper
+
+      US_CORE_EXTENSION_URLS = [
+        'http://hl7.org/fhir/us/core/StructureDefinition/us-core-birthsex',
+        'http://hl7.org/fhir/us/core/StructureDefinition/us-core-direct',
+        'http://hl7.org/fhir/us/core/StructureDefinition/us-core-ethnicity',
+        'http://hl7.org/fhir/us/core/StructureDefinition/us-core-race',
+        'http://hl7.org/fhir/us/core/StructureDefinition/uscdi-requirement',
+        'http://hl7.org/fhir/us/core/StructureDefinition/us-core-extension-questionnaire-uri',
+        'http://hl7.org/fhir/us/core/StructureDefinition/us-core-genderIdentity',
+        'http://hl7.org/fhir/us/core/StructureDefinition/us-core-jurisdiction',
+        'http://hl7.org/fhir/us/core/StructureDefinition/us-core-sex',
+        'http://hl7.org/fhir/us/core/StructureDefinition/us-core-tribal-affiliation',
+        'http://hl7.org/fhir/us/core/StructureDefinition/us-core-medication-adherence',
+        'http://hl7.org/fhir/StructureDefinition/condition-assertedDate'
+      ].freeze
+
+      CRD_EXTENSION_URLS = [
+        'http://hl7.org/fhir/us/davinci-crd/StructureDefinition/ext-coverage-information',
+        'http://hl7.org/fhir/us/davinci-crd/StructureDefinition/ext-billing-options',
+        'http://hl7.org/fhir/us/davinci-crd/StructureDefinition/ext-request-category',
+        'http://hl7.org/fhir/StructureDefinition/codeOptions',
+        'http://hl7.org/fhir/StructureDefinition/alternate-reference',
+        'http://hl7.org/fhir/5.0/StructureDefinition/extension-CommunicationRequest.payload.content',
+        'http://hl7.org/fhir/5.0/StructureDefinition/extension-Task.requestedPeriod',
+        'http://hl7.org/fhir/5.0/StructureDefinition/extension-Task.requestedPerformer',
+        'http://hl7.org/fhir/5.0/StructureDefinition/extension-Task.performer',
+        'http://hl7.org/fhir/StructureDefinition/request-doNotPerform',
+        'http://hl7.org/fhir/5.0/StructureDefinition/extension-Task.input.value',
+        'http://hl7.org/fhir/5.0/StructureDefinition/extension-Task.output.value',
+        'http://hl7.org/fhir/5.0/StructureDefinition/extension-Task.statusReason'
+      ].freeze
+
+      HREX_EXTENSION_URLS = [
+        'http://hl7.org/fhir/us/davinci-hrex/StructureDefinition/extension-CoverageDavinciWellknownLocation'
+      ].freeze
+
+      VALID_EXTENSION_URLS = (US_CORE_EXTENSION_URLS + CRD_EXTENSION_URLS + HREX_EXTENSION_URLS).freeze
+
+      title 'Server does not require custom extensions'
+      id :crd_v221_service_request_no_custom_extensions
+      description %(
+        This test verifies that the server is capable of responding to a client
+        without the use of any custom extensions. It inspects each successful
+        hook call, and if it finds one which doesn't use any extensions not
+        defined by US Core, CRD, or HREX it passes.
+      )
+
+      verifies_requirements 'hl7.fhir.us.davinci-crd_2.2.1@conf-7',
+                            'hl7.fhir.us.davinci-crd_2.2.1@hook-22'
+
+      run do
+        ALL_HOOK_TAGS.each do |tag|
+          load_tagged_requests(tag)
+        end
+
+        skip_if requests.blank?, 'No requests were made in a previous test as expected.'
+
+        successful_requests = requests.select { |request| request.status == 200 }
+
+        skip_if successful_requests.empty?, 'All service requests were unsuccessful.'
+
+        embedded_resources =
+          successful_requests
+            .map { |request| resources_from_request(request) }
+            .reject(&:blank?)
+
+        skip_if embedded_resources.blank?,
+                'No embedded FHIR resources were found in successful hook requests.'
+
+        request_with_no_custom_extensions =
+          embedded_resources.any? { |resources| resources.all? { |resource| no_custom_extensions? resource } }
+
+        pass_if request_with_no_custom_extensions
+
+        custom_extensions_string =
+          embedded_resources
+            .flatten
+            .flat_map { |resource| custom_extensions(resource) }
+            .uniq
+            .map { |extension| "\n- `#{extension}`" }
+            .join
+
+        skip 'No requests were made without custom extensions. The following custom extensions were found: ' \
+             "#{custom_extensions_string}"
+      end
+
+      def no_custom_extensions?(resource)
+        resource.each_element do |value, _metadata, path|
+          next unless value.is_a? FHIR::Extension
+
+          next if path.scan('extension').length > 1
+
+          return false unless VALID_EXTENSION_URLS.include? value.url
+        end
+
+        true
+      end
+
+      def custom_extensions(resource)
+        [].tap do |custom_extensions|
+          resource.each_element do |value, _metadata, path|
+            next unless value.is_a? FHIR::Extension
+
+            next if path.scan('extension').length > 1
+
+            custom_extensions << value.url unless VALID_EXTENSION_URLS.include? value.url
+          end
+        end
+      end
+    end
+  end
+end

data/lib/davinci_crd_test_kit/server/v2.2.1/verify_request/service_request_optional_fields_validation_test.rb

@@ -0,0 +1,40 @@
+require_relative '../../server_hook_request_validation'
+require_relative '../../server_hook_helper'
+
+module DaVinciCRDTestKit
+  module V221
+    class ServiceRequestOptionalFieldsValidationTest < Inferno::Test
+      include DaVinciCRDTestKit::ServerHookRequestValidation
+      include DaVinciCRDTestKit::ServerHookHelper
+
+      title 'Service request optional fields are valid'
+      id :crd_v221_service_request_optional_fields_validation
+      description %(
+        This optional test reviews the user-submitted CRD service requests for the presence of optional fields:
+        `fhirAuthorization` and `prefetch`.
+
+        The test will not fail if these optional fields are missing from a service request; instead, it generates an
+        informational message.
+      )
+      optional
+      simulation_verification
+
+      run do
+        load_tagged_requests(tested_hook_name)
+        skip_if requests.empty?, "No #{tested_hook_name} request was made in a previous test as expected."
+
+        requests.each_with_index do |request, index|
+          @request_number = index + 1
+          request_body = json_parse(request.request_body)
+          if request_body.blank?
+            add_message('error', "#{request_number}Hook request body cannot be empty.")
+            next
+          end
+
+          hook_request_optional_fields_check(request_body, ig_version: 'v221')
+        end
+        no_error_validation('Some service requests have invalid optional fields.')
+      end
+    end
+  end
+end

data/lib/davinci_crd_test_kit/server/v2.2.1/verify_request/service_request_required_fields_validation_test.rb

@@ -0,0 +1,41 @@
+require_relative '../../server_hook_request_validation'
+require_relative '../../server_hook_helper'
+
+module DaVinciCRDTestKit
+  module V221
+    class ServiceRequestRequiredFieldsValidationTest < Inferno::Test
+      include DaVinciCRDTestKit::ServerHookRequestValidation
+      include DaVinciCRDTestKit::ServerHookHelper
+
+      title 'Service requests contain required fields'
+      id :crd_v221_service_request_required_fields_validation
+      description %(
+        This test validates all CRD service requests provided by the user, ensuring each includes all required fields
+        specified in the [CDS Hooks spec section on Calling a CDS Service](https://cds-hooks.hl7.org/2.0/#calling-a-cds-service):
+        `hook`, `hookInstance`, and `context`. Furthermore, the test checks for the conditional presence of the
+        `fhirServer` field if `fhirAuthorization` is included.
+      )
+      input :invoked_hook
+      output :contexts
+      simulation_verification
+
+      run do
+        load_tagged_requests(tested_hook_name)
+        skip_if requests.empty?, "No #{tested_hook_name} request was made in a previous test as expected."
+        contexts = []
+        requests.each_with_index do |request, index|
+          @request_number = index + 1
+          request_body = json_parse(request.request_body)
+          next if request_body.blank?
+
+          contexts << request_body['context'] if request_body['context'].is_a?(Hash)
+          hook_request_required_fields_check(request_body, invoked_hook, ig_version: 'v221')
+        end
+
+        output contexts: contexts.to_json
+
+        no_error_validation('Some service requests made are not valid.')
+      end
+    end
+  end
+end

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

@@ -0,0 +1,109 @@
+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 AdditionalOrdersValidationTest < Inferno::Test
+      include DaVinciCRDTestKit::ServerTestHelper
+      include DaVinciCRDTestKit::ServerHookHelper
+      include DaVinciCRDTestKit::CardsIdentification
+      include DaVinciCRDTestKit::ResponseLogicalModelValidation
+
+      title 'Additional Orders cards are valid'
+      id :crd_v221_additional_orders_card_validation
+      description %(
+        This test validates that an [Identify Additional
+        Orders](https://hl7.org/fhir/us/davinci-crd/2.2.1/en/cards.html#identify-additional-orders-response-type)
+        card was received. It does so by:
+        - Filtering cards with the following criteria:
+          - For each suggestion in the card's suggestions array, all actions
+            have a type of 'create' and the action's resource type is one of the
+            expected types: CommunicationRequest, Device, DeviceRequest,
+            Medication, MedicationRequest, NutritionOrder, ServiceRequest, or
+            VisionPrescription.
+        - Then, for each valid Additional Orders card retrieved, verifying that
+          each action within the card's suggestions complies with their
+          respective profiles as specified in the [CRD IG section on Identify
+          Additional
+          Orders](https://hl7.org/fhir/us/davinci-crd/2.2.1/en/cards.html#identify-additional-orders-response-type):
+          -
+            [crd-profile-communicationrequest](https://hl7.org/fhir/us/davinci-crd/2.2.1/StructureDefinition-profile-communicationrequest.html)
+          -
+            [crd-profile-device](https://hl7.org/fhir/us/davinci-crd/2.2.1/StructureDefinition-profile-device.html)
+          -
+            [crd-profile-deviceRequest](https://hl7.org/fhir/us/davinci-crd/2.2.1/StructureDefinition-profile-devicerequest.html)
+          -
+            [us-core-medication](http://hl7.org/fhir/us/core/STU3.1.1/StructureDefinition-us-core-medication.html)
+          -
+            [crd-profile-medicationRequest](https://hl7.org/fhir/us/davinci-crd/2.2.1/StructureDefinition-profile-medicationrequest.html)
+          -
+            [crd-profile-nutritionOrder](https://hl7.org/fhir/us/davinci-crd/2.2.1/StructureDefinition-profile-nutritionorder.html)
+          -
+            [crd-profile-serviceRequest](https://hl7.org/fhir/us/davinci-crd/2.2.1/StructureDefinition-profile-servicerequest.html)
+          -
+            [crd-profile-visionPrescription](https://hl7.org/fhir/us/davinci-crd/2.2.1/StructureDefinition-profile-visionprescription.html).
+
+        The test will skip if no Identify Additional Orders cards are found.
+      )
+
+      verifies_requirements 'hl7.fhir.us.davinci-crd_2.2.1@resp-3',
+                            'hl7.fhir.us.davinci-crd_2.2.1@resp-57',
+                            'hl7.fhir.us.davinci-crd_2.2.1@resp-58'
+
+      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 additional_orders_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| additional_orders_response_type? card }
+      rescue JSON::ParserError
+        []
+      end
+
+      run do
+        load_tagged_requests(tested_hook_name)
+
+        additional_orders_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 = additional_orders_cards(request)
+
+          additional_orders_count += cards.length
+
+          perform_response_logical_model_validation(
+            cards,
+            nil,
+            request.request_body,
+            index,
+            '2.2.1'
+          )
+        end
+
+        skip_if additional_orders_count.zero?,
+                "#{tested_hook_name} hook responses do not contain any Additional Orders cards."
+
+        no_error_validation('Not all Additional Orders cards were valid. See messages for more information.')
+      end
+    end
+  end
+end

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

@@ -0,0 +1,123 @@
+require_relative '../../server_test_helper'
+require_relative '../../server_hook_helper'
+require_relative '../../../cross_suite/cards_identification'
+require_relative '../../../cross_suite/profiles_and_resource_types'
+
+module DaVinciCRDTestKit
+  module V221
+    class AllResponsesIncludeCoverageInformationTest < Inferno::Test
+      include DaVinciCRDTestKit::ServerTestHelper
+      include DaVinciCRDTestKit::ServerHookHelper
+      include DaVinciCRDTestKit::CardsIdentification
+
+      title 'Hook responses include Coverage Information system actions'
+      id :crd_v221_all_responses_include_coverage_information
+      description %(
+        This test validates that a [Coverage
+        Information](https://hl7.org/fhir/us/davinci-crd/2.2.1/en/cards.html#coverage-information-response-type)
+        system action was returned for every hook call, unless the resource
+        which is the focus of the hook call already includes a
+        [coverage-information
+        extension](https://hl7.org/fhir/us/davinci-crd/2.2.1/en/StructureDefinition-ext-coverage-information.html).
+        It does so by:
+        - First checking for the presence of actions with a `resource` element
+          of the following types:
+          - For `appointment-book`: Appointment
+          - For `order-sign` or `order-dispatch`: CommunicationRequest,
+            DeviceRequest, MedicationRequest, NutritionOrder, ServiceRequest, or
+            VisionPrescription
+        - Then, checking whether each resource contains the coverage-information extension
+        - Finally verifying that the response to each hook call where the
+          resource did not contain a coverage-information extension includes
+          coverage information system action
+      )
+
+      verifies_requirements 'hl7.fhir.us.davinci-crd_2.2.1@hook-16',
+                            'hl7.fhir.us.davinci-crd_2.2.1@resp-28'
+
+      input :invoked_hook
+
+      def target_resources
+        {
+          'appointment-book' => ['Appointment'],
+          'order-sign' => ProfilesAndResourceTypes::ORDER_RESOURCE_TYPES,
+          'order-dispatch' => ProfilesAndResourceTypes::ORDER_RESOURCE_TYPES,
+          'order-select' => ProfilesAndResourceTypes::ORDER_RESOURCE_TYPES,
+          'encounter-start' => ['Encounter'],
+          'encounter-discharge' => ['Encounter']
+        }[tested_hook_name]
+      end
+
+      def hook_bundle_field_name
+        {
+          'appointment-book' => 'appointments',
+          'order-sign' => 'draftOrders'
+        }[tested_hook_name]
+      end
+
+      def resources_contain_coverage_information_extension?(resources)
+        resources.all? do |resource|
+          resource.extension&.any? do |extension|
+            extension.url == 'http://hl7.org/fhir/us/davinci-crd/StructureDefinition/ext-coverage-information'
+          end
+        end
+      end
+
+      def order_resources(hook_call_body)
+        bundle = FHIR::Bundle.new(hook_call_body.dig('context', hook_bundle_field_name))
+        bundle.entry.map(&:resource).select { |resource| target_resources.include? resource.resourceType }
+      end
+
+      run do
+        successful_hook_calls_without_coverage_information = 0
+        coverage_information_system_actions_received = 0
+
+        load_tagged_requests(tested_hook_name)
+
+        requests.each do |request|
+          next if request.status != 200
+
+          hook_call_body = JSON.parse(request.request_body)
+
+          # TODO: handle when default value for coverage-info is false
+          next if hook_call_body.dig('extension', 'davinci-crd.configuration', 'coverage-info') == false
+
+          resources = order_resources(hook_call_body)
+
+          next if resources_contain_coverage_information_extension?(resources)
+
+          successful_hook_calls_without_coverage_information += 1
+
+          hook_call_response = JSON.parse(request.response_body)
+
+          system_actions = hook_call_response['systemActions']
+
+          next if system_actions.blank?
+
+          system_actions_resources =
+            system_actions
+              .select { |action| action['type'] == 'update' }
+              .select { |action| target_resources.include? action['resource']['resourceType'] }
+              .map { |action| FHIR.from_contents(action['resource'].to_json) }
+
+          next unless resources_contain_coverage_information_extension?(system_actions_resources)
+
+          coverage_information_system_actions_received += 1
+        rescue JSON::ParserError => e
+          warning(e.message)
+          next
+        end
+
+        skip_if successful_hook_calls_without_coverage_information.zero?,
+                'No successful hook calls were made with resources which did not already ' \
+                'contain a coverage-information extension.'
+
+        assert successful_hook_calls_without_coverage_information == coverage_information_system_actions_received,
+               "#{successful_hook_calls_without_coverage_information} successful hook calls " \
+               'without a coverage-information extension were made, but only ' \
+               "#{coverage_information_system_actions_received} of the responses contained " \
+               'a coverage information system action.'
+      end
+    end
+  end
+end

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

@@ -0,0 +1,83 @@
+require_relative '../../../cross_suite/cards_identification'
+require_relative '../../server_hook_helper'
+require_relative '../server_urls'
+
+module DaVinciCRDTestKit
+  module V221
+    class CoverageInfoConfigurationTest < Inferno::Test
+      include DaVinciCRDTestKit::CardsIdentification
+      include DaVinciCRDTestKit::ServerHookHelper
+      include DaVinciCRDTestKit::V221::ServerURLs
+
+      title 'Coverage Information configuration option suppresses coverage-info responses'
+      id :crd_v221_coverage_info_configuration
+      description %(
+        This test checks follow-up hook requests made with
+        `extension.davinci-crd.configuration.coverage-info` set to `false` after prior successful hook requests
+        returned coverage-info content.
+
+        CRD Servers SHALL behave in the manner prescribed by supported configuration information received from
+        the CRD Client. When `coverage-info` is `false`, responses must not include coverage-info cards or
+        coverage-information/form-completion system actions.
+      )
+
+      verifies_requirements 'hl7.fhir.us.davinci-crd_2.2.1@dev-14',
+                            'hl7.fhir.us.davinci-crd_2.2.1@resp-28'
+
+      def coverage_info_message(cards, actions)
+        card_summaries = cards.map { |card| card['summary'] }.compact
+        action_descriptions = actions.map { |action| action['description'] }.compact
+
+        'Coverage-info disabled server response included coverage-info content despite ' \
+          "`#{COVERAGE_INFO_CONFIGURATION_CODE}` being set to `false`. " \
+          "Cards: #{card_summaries.join(', ')}. System actions: #{action_descriptions.join(', ')}."
+      end
+
+      def primary_hook?
+        ['appointment-book', 'order-sign', 'order-dispatch'].include? tested_hook_name
+      end
+
+      def parsed_body(json)
+        JSON.parse(json)
+      rescue JSON::ParserError
+        nil
+      end
+
+      run do
+        load_tagged_requests(tested_hook_name, COVERAGE_INFO_DISABLED_TAG)
+
+        if requests.empty?
+          message = "No successful #{tested_hook_name} response contained coverage-info content to suppress."
+          if primary_hook?
+            skip message
+          else
+            omit message
+          end
+        end
+
+        requests.each do |request|
+          unless request.status == 200
+            add_message(
+              'error',
+              "Coverage-info disabled server request returned HTTP #{request.status}; expected HTTP 200."
+            )
+            next
+          end
+
+          response_body = parsed_body(request.response_body)
+          unless response_body.is_a?(Hash)
+            add_message('error', 'Coverage-info disabled server response was not valid JSON.')
+            next
+          end
+
+          cards, actions = coverage_info_content(response_body)
+          next if cards.empty? && actions.empty?
+
+          add_message('error', coverage_info_message(cards, actions))
+        end
+
+        assert_no_error_messages('Coverage-info configuration responses were not valid. Check messages for details.')
+      end
+    end
+  end
+end

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

@@ -0,0 +1,76 @@
+require_relative '../../server_hook_helper'
+require_relative '../../../cross_suite/cards_identification'
+require_relative 'hook_request_resource_resolution'
+
+module DaVinciCRDTestKit
+  module V221
+    class CoverageInformationCardAbsenceTest < Inferno::Test
+      include DaVinciCRDTestKit::ServerHookHelper
+      include DaVinciCRDTestKit::CardsIdentification
+      include HookRequestResourceResolution
+
+      title 'Hook responses do not include Coverage Information cards'
+      id :crd_v221_coverage_information_card_absence
+      description %(
+        This test verifies that the server does not return the
+        [Coverage Information](https://hl7.org/fhir/us/davinci-crd/2.2.1/en/cards.html#coverage-information-response-type)
+        response type as a CDS Hooks card. Coverage Information responses must be returned as `systemActions`
+        that update resources with the `coverage-information` extension (inclusion of systemActions is verified in a
+        previous test).
+      )
+
+      verifies_requirements 'hl7.fhir.us.davinci-crd_2.2.1@resp-25'
+
+      input :mock_ehr_bundle, optional: true
+
+      def coverage_information_card_message(response_index, card)
+        identifier = card['uuid'].present? ? "uuid `#{card['uuid']}`" : 'no uuid'
+
+        "Server response #{response_index + 1} included a card with #{identifier} and a suggestion action that only " \
+          'adds or modifies the coverage-information extension. Coverage Information must be returned as a ' \
+          'systemAction, not as a card.'
+      end
+
+      def coverage_information_card_response_type?(card, request)
+        Array(card['suggestions']).any? do |suggestion|
+          Array(suggestion['actions']).any? do |action|
+            coverage_information_card_action?(action, request)
+          end
+        end
+      end
+
+      def coverage_information_card_action?(action, request)
+        return false unless coverage_information_response_type?(action)
+        return false unless action['type'] == 'update'
+
+        source_resource = find_action_source_resource(action, request)
+        return coverage_information_extension_only_payload?(action['resource']) unless source_resource
+
+        only_coverage_information_changed?(source_resource.to_hash, action['resource'])
+      end
+
+      run do
+        load_tagged_requests(tested_hook_name)
+        skip_if requests.blank?, "No #{tested_hook_name} request was made in a previous test as expected."
+
+        successful_requests = requests.select { |request| request.status == 200 }
+        skip_if successful_requests.empty?, 'All service requests were unsuccessful.'
+
+        successful_requests.each_with_index do |request, index|
+          response_body = JSON.parse(request.response_body)
+          cards = response_body['cards'].is_a?(Array) ? response_body['cards'] : []
+
+          cards.select { |card| coverage_information_card_response_type?(card, request) }.each do |card|
+            add_message('error', coverage_information_card_message(index, card))
+          end
+        rescue JSON::ParserError
+          add_message('error', "Invalid JSON: server response #{index + 1} is not valid JSON.")
+        end
+
+        assert_no_error_messages(
+          'Service response(s) included Coverage Information cards. Check messages for details.'
+        )
+      end
+    end
+  end
+end