davinci_crd_test_kit 0.14.0 → 0.14.1

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

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

@@ -1,6 +1,8 @@
 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
@@ -10,123 +12,42 @@ module DaVinciCRDTestKit
       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/STU2/cards.html#coverage-information)
+        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).
+        - 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-32',
+      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 :coverage_info
+      input :invoked_hook
       input :mock_ehr_bundle, optional: true
+      output :coverage_info
 
-      def find_extension_value(extension, url, *properties)
-        found_extension = extension.extension.find { |ext| ext.url == url }
-        return nil unless found_extension
-
-        properties.reduce(found_extension) do |current, prop|
-          return current unless current.respond_to?(prop)
-
-          current.send(prop)
-        end
-      end
-
-      def extract_and_group_coverage_info(resource)
-        resource.extension.each_with_object({}) do |extension, grouped_extensions|
-          next unless extension.url == COVERAGE_INFO_EXT_URL
-
-          coverage_key = find_extension_value(extension, 'coverage', 'valueReference', 'reference')
-          grouped_extensions[coverage_key] ||= []
-          grouped_extensions[coverage_key] << extension
-        end
-      end
-
-      # For the same coverage, ensure coverage-assertion-ids and satisfied-pa-ids are the same.
-      # For different coverages, ensure coverage-assertion-ids and satisfied-pa-ids are distinct.
-      def multiple_extensions_conformance_check(grouped_coverage_info, resource)
-        resource_ref = "#{resource.resourceType}/#{resource.id}"
-        assertion_ids_across_coverages = Set.new
-        pa_ids_across_coverages = Set.new
-
-        grouped_coverage_info.each do |coverage, extensions|
-          coverage_assertion_ids = collect_extensions_id(extensions, 'coverage-assertion-id', 'valueString').uniq
-          satisfied_pa_ids = collect_extensions_id(extensions, 'satisfied-pa-id', 'valueString').uniq.compact
-          assert coverage_assertion_ids.length == 1,
-                 same_coverage_conformance_error_msg(resource_ref, coverage, 'coverage-assertion-ids')
-
-          assert satisfied_pa_ids.length <= 1,
-                 same_coverage_conformance_error_msg(resource_ref, coverage, 'satisfied-pa-ids')
-
-          assertion_id = coverage_assertion_ids.first
-          assert !assertion_ids_across_coverages.include?(assertion_id),
-                 different_coverage_conformance_error_msg(resource_ref, 'coverage-assertion-ids')
-          assertion_ids_across_coverages.add(assertion_id)
-          pa_id = satisfied_pa_ids.first
-          next unless pa_id
-
-          assert !pa_ids_across_coverages.include?(pa_id),
-                 different_coverage_conformance_error_msg(resource_ref, 'satisfied-pa-ids')
-          pa_ids_across_coverages.add(pa_id)
-        end
-      end
-
-      def collect_extensions_id(extensions, url, *properties)
-        extensions.map do |extension|
-          find_extension_value(extension, url, *properties)
-        end
-      end
-
-      def same_coverage_conformance_error_msg(resource_ref, coverage, id_name)
-        "#{resource_ref}: extension has multiple repetitions of coverage `#{coverage}` with different #{id_name}."
-      end
-
-      def different_coverage_conformance_error_msg(resource_ref, id_name)
-        "#{resource_ref}: extensions referencing differing coverage SHALL have distinct #{id_name}."
-      end
-
-      def 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 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'] == COVERAGE_INFO_EXT_URL
-        end
-        normalized_hash.delete('extension') if normalized_hash['extension'].empty?
-        normalized_hash
-      end
-
-      def verify_only_coverage_info_changed(action)
-        request = matching_request_for_action(action)
+      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']}"
@@ -140,44 +61,69 @@ module DaVinciCRDTestKit
           return
         end
 
-        source_resource_hash = source_resource.to_hash
+        return if only_coverage_information_changed?(source_resource.to_hash, 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))
+        add_message(
+          'error',
+          "#{resource_ref}: resource content changed outside the coverage-information extension."
+        )
+      end
 
-        assert source_without_coverage_info == updated_without_coverage_info,
-               "#{resource_ref}: resource content changed outside the coverage-information extension."
+      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_system_action_check(coverage_info_system_action)
-        type = coverage_info_system_action['type']
-        assert type, '`type` field is missing.'
-        assert type == 'update', "`type` must be `update`, but was `#{type}`"
+      def coverage_info_actions(request)
+        return [] if request.status != 200
+
+        response_body = JSON.parse(request.response_body)
 
-        resource = FHIR.from_contents(coverage_info_system_action['resource'].to_json)
-        profile_url = structure_definition_map('v221')[resource.resourceType]
-        resource_is_valid?(resource:, profile_url:)
+        return [] if body_has_no_system_actions?(response_body)
 
-        grouped_coverage_info = extract_and_group_coverage_info(resource)
-        multiple_extensions_conformance_check(grouped_coverage_info, resource)
-        verify_only_coverage_info_changed(coverage_info_system_action)
+        response_body['systemActions'].select { |action| coverage_information_response_type? action }
+      rescue JSON::ParserError
+        []
       end
 
       run do
         load_tagged_requests(tested_hook_name)
-        parsed_coverage_info = parse_json(coverage_info)
-        error_messages = []
-        parsed_coverage_info.each do |action|
-          coverage_info_system_action_check(action)
-        rescue Inferno::Exceptions::AssertionException => e
-          error_messages << "Coverage Info system action `#{action}`: #{e.message}"
-        end
 
-        error_messages.each do |msg|
-          messages << { type: 'error', message: msg }
+        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
 
-        assert_no_error_messages 'Some Coverage Info system actions are not valid.'
+        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

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

@@ -1,74 +1,118 @@
 require_relative '../../server_test_helper'
-require_relative '../../../cross_suite/suggestion_actions_validation'
 require_relative '../../server_hook_helper'
 require_relative '../../../cross_suite/cards_identification'
-require_relative '../../../cross_suite/cards_validation'
+require_relative '../../../cross_suite/response_logical_model_validation'
 
 module DaVinciCRDTestKit
   module V221
     class CreateOrUpdateCoverageInfoResponseValidationTest < Inferno::Test
       include DaVinciCRDTestKit::ServerTestHelper
-      include DaVinciCRDTestKit::SuggestionActionsValidation
       include DaVinciCRDTestKit::ServerHookHelper
       include DaVinciCRDTestKit::CardsIdentification
-      include DaVinciCRDTestKit::CardsValidation
+      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/STU2/cards.html#create-or-update-coverage-information).
+        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.
+          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 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.
+          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-71'
+      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
-      input :valid_cards_with_suggestions, :valid_system_actions
+
+      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
-        parsed_cards = parse_json(valid_cards_with_suggestions)
-        parsed_actions = parse_json(valid_system_actions)
+        load_tagged_requests(tested_hook_name)
 
-        create_or_update_coverage_info_cards = parsed_cards.select do |card|
-          create_or_update_coverage_card_response_type?(card)
-        end
-        create_or_update_coverage_info_actions = parsed_actions.select do |action|
-          create_or_update_coverage_action_response_type?(action)
-        end
+        update_coverage_count = 0
 
-        skip_msg = "#{tested_hook_name} hook response does not contain any Create or Update Coverage Information " \
-                   'cards or system actions.'
-        skip_if create_or_update_coverage_info_cards.blank? && create_or_update_coverage_info_actions.blank?, skip_msg
+        successful_requests = requests.select { |request| request.status == 200 }
 
-        if create_or_update_coverage_info_actions.present?
-          actions_check(create_or_update_coverage_info_actions, ig_version: 'v221')
-        end
+        skip_if successful_requests.blank?,
+                'No successful hook responses were received'
 
-        if create_or_update_coverage_info_cards.present?
-          create_or_update_coverage_info_cards.each do |card|
-            actions_check(card['suggestions'].first['actions'].select do |action|
-                            create_or_update_coverage_action_response_type?(action)
-                          end, ig_version: 'v221')
+        requests.each_with_index do |request, index|
+          cards = update_coverage_cards(request)
+          actions = update_coverage_actions(request)
 
-            create_or_update_coverage_check(card)
-          end
+          update_coverage_count += cards.length + actions.length
+
+          perform_response_logical_model_validation(
+            cards,
+            actions,
+            request.request_body,
+            index,
+            '2.2.1'
+          )
         end
 
-        no_error_validation('Some Create or Update Coverage Information received are not valid.')
+        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

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

@@ -1,7 +1,7 @@
 require_relative '../../server_test_helper'
 require_relative '../../server_hook_helper'
 require_relative '../../../cross_suite/cards_identification'
-require_relative '../../../cross_suite/cards_validation'
+require_relative '../../../cross_suite/response_logical_model_validation'
 
 module DaVinciCRDTestKit
   module V221
@@ -9,38 +9,80 @@ module DaVinciCRDTestKit
       include DaVinciCRDTestKit::ServerTestHelper
       include DaVinciCRDTestKit::ServerHookHelper
       include DaVinciCRDTestKit::CardsIdentification
-      include DaVinciCRDTestKit::CardsValidation
+      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 list of valid cards
-        returned by the CRD service.
-        As per the [Da Vinci CRD Implementation Guide](https://hl7.org/fhir/us/davinci-crd/STU2/cards.html#external-reference),
-        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:
+        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-22'
+      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
 
-      input :valid_cards_with_links
       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
-        parsed_cards = parse_json(valid_cards_with_links)
-        external_reference_cards = parsed_cards.select { |card| external_reference_response_type?(card) }
+        load_tagged_requests(tested_hook_name)
+
+        external_reference_count = 0
+
+        successful_requests = requests.select { |request| request.status == 200 }
 
-        skip_if external_reference_cards.blank?,
-                "#{tested_hook_name} hook response does not contain any External Reference cards."
+        skip_if successful_requests.blank?,
+                'No successful hook responses were received'
 
-        external_reference_cards.each do |card|
-          external_reference_card_check(card)
+        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
 
-        assert messages.blank?,
-               'Not all External Reference cards were valid. See messages for more information.'
+        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