davinci_crd_test_kit 0.14.0 → 0.14.2

data/lib/davinci_crd_test_kit/server/v2.2.1/specific_coverage_responses/technical_issues_group.rb

@@ -0,0 +1,121 @@
+require_relative 'technical_issues_invoke_test'
+require_relative 'coverage_info_reason_test'
+
+module DaVinciCRDTestKit
+  module V221
+    class TechnicalIssuesGroup < Inferno::TestGroup
+      title 'Technical Issues'
+      id :crd_v221_server_technical_issues_group
+      description %(
+        This group of tests allows the system to demonstrate its ability to
+        respond to a CRD Hook invocation with an `indeterminate` coverage
+        determination due to technical issues.
+
+        For these tests, the hook call will include an invalid access token,
+        which due to the nature of Inferno's FHIR server simulation will result
+        in 500 response to FHIR requests, simulating a temporary server outage.
+        The tests then verify that a Coverage Information systemAction is
+        received with `indeterminate` coverage for `technical` reasons.
+      )
+
+      config options: { hook_name: TECHNICAL_ISSUES_TAG }
+      run_as_group
+
+      group do
+        title 'Interaction'
+
+        test from: :crd_v221_server_technical_issues_invoke_hook_test,
+             description: <<~DESCRIPTION,
+               This test initiates a POST request to a specified CDS Service
+               using the JSON body list provided by the user. This request is
+               generated so that requests for FHIR resources from the CDS service
+               result in 500 errors, simulating a temporary server error.
+             DESCRIPTION
+             config: {
+               inputs: {
+                 service_ids: {
+                   name: :technical_issues_service_ids,
+                   title: 'Service id to use for the "Technical Issues" test',
+                   description: %(
+                     If blank, Inferno will attempt to infer the service id to use
+                     by finding a service entry in the Discovery response for the
+                     hook indicated in the provided request body. If it cannot be
+                     inferred, the tests will be skipped.
+                   )
+                 },
+                 service_request_bodies: {
+                   name: :technical_issues_request_body,
+                   title: 'Request body to use for the "Technical Issues" test',
+                   description: %(
+                     Provide a single JSON request body to submit for the hook
+                     invocation. The type of hook invoked will be inferred based
+                     on the `hook` element in the request.
+                   )
+                 }
+               }
+             }
+      end
+
+      group do
+        title 'Requests'
+        simulation_verification
+
+        test from: :crd_v221_service_request_required_fields_validation,
+             config: {
+               outputs: {
+                 contexts: {
+                   name: :technical_issues_contexts
+                 }
+               }
+             }
+        test from: :crd_v221_service_request_context_validation,
+             config: {
+               inputs: {
+                 contexts: {
+                   name: :technical_issues_contexts
+                 },
+                 request_body: {
+                   name: :technical_issues_request_body
+                 }
+               }
+             }
+      end
+
+      group do
+        title 'Responses'
+
+        test from: :crd_v221_service_response_validation
+        test from: :crd_v221_coverage_info_system_action_validation,
+             config: {
+               outputs: {
+                 coverage_info: {
+                   name: :technical_issues_coverage_info
+                 }
+               }
+             }
+        test from: :crd_v221_coverage_info_reason,
+             title: 'Coverage Information responses have indeterminate coverage for technical reasons',
+             description: <<~DESCRIPTION,
+               This test verifies that the Coverage Information responses received contain Coverage Information
+               extensions with `indeterminate` coverage and a `technical` reason, and additional details about the
+               failure are included in the `text` field of the reason extension.
+             DESCRIPTION
+             config: {
+               inputs: {
+                 coverage_info: {
+                   name: :technical_issues_coverage_info
+                 }
+               },
+               options: {
+                 expected_coverage_code: 'indeterminate',
+                 expected_reason_code: 'technical',
+                 require_reason_text: true
+               }
+             },
+             verifies_requirements: [
+               'hl7.fhir.us.davinci-crd_2.2.1@resp-43'
+             ]
+      end
+    end
+  end
+end

data/lib/davinci_crd_test_kit/server/v2.2.1/specific_coverage_responses/technical_issues_invoke_test.rb

@@ -0,0 +1,22 @@
+require_relative '../server_urls'
+require_relative '../../jobs/invoke_hook_with_bad_auth'
+require_relative '../../server_abstract_invoke_hook_test'
+
+module DaVinciCRDTestKit
+  module V221
+    class TechnicalIssuesInvokeHookTest < ServerAbstractInvokeHookTest
+      include ServerURLs
+
+      title 'Inferno invokes the selected hook with invalid authorization'
+      id :crd_v221_server_technical_issues_invoke_hook_test
+
+      def perform_invoke_hook_job(*)
+        Inferno::Jobs.perform(DaVinciCRDTestKit::Jobs::InvokeHookWithBadAuth, *)
+      end
+
+      def check_request_length(payloads)
+        skip_if payloads.length != 1, 'The *Technical Issues* test supports only one request body.'
+      end
+    end
+  end
+end

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

@@ -16,6 +16,7 @@ module DaVinciCRDTestKit
         required fields.
       )
       input :contexts, :invoked_hook
+      simulation_verification
 
       run do
         parsed_contexts = parse_json(contexts)

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

@@ -17,6 +17,7 @@ module DaVinciCRDTestKit
         informational message.
       )
       optional
+      simulation_verification
 
       run do
         load_tagged_requests(tested_hook_name)

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

@@ -17,6 +17,7 @@ module DaVinciCRDTestKit
       )
       input :invoked_hook
       output :contexts
+      simulation_verification
 
       run do
         load_tagged_requests(tested_hook_name)

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

@@ -1,65 +1,108 @@
 require_relative '../../server_test_helper'
 require_relative '../../server_hook_helper'
-require_relative '../../../cross_suite/suggestion_actions_validation'
 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 AdditionalOrdersValidationTest < Inferno::Test
       include DaVinciCRDTestKit::ServerTestHelper
-      include DaVinciCRDTestKit::SuggestionActionsValidation
       include DaVinciCRDTestKit::ServerHookHelper
       include DaVinciCRDTestKit::CardsIdentification
-      include DaVinciCRDTestKit::CardsValidation
+      include DaVinciCRDTestKit::ResponseLogicalModelValidation
 
       title 'Additional Orders cards are valid'
       id :crd_v221_additional_orders_card_validation
       description %(
-        This test validates that an [Additional Orders as companions/prerequisites](https://hl7.org/fhir/us/davinci-crd/STU2/cards.html#identify-additional-orders-as-companionsprerequisites-for-current-order)
+        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 Additional Orders as companions/prerequisites](https://hl7.org/fhir/us/davinci-crd/STU2/cards.html#identify-additional-orders-as-companionsprerequisites-for-current-order):
-          - [crd-profile-communicationrequest](https://hl7.org/fhir/us/davinci-crd/STU2/StructureDefinition-profile-communicationrequest.html)
-          - [crd-profile-device](https://hl7.org/fhir/us/davinci-crd/STU2/StructureDefinition-profile-device.html)
-          - [crd-profile-deviceRequest](https://hl7.org/fhir/us/davinci-crd/STU2/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/STU2/StructureDefinition-profile-medicationrequest.html)
-          - [crd-profile-nutritionOrder](https://hl7.org/fhir/us/davinci-crd/STU2/StructureDefinition-profile-nutritionorder.html)
-          - [crd-profile-serviceRequest](https://hl7.org/fhir/us/davinci-crd/STU2/StructureDefinition-profile-servicerequest.html)
-          - [crd-profile-visionPrescription](https://hl7.org/fhir/us/davinci-crd/STU2/StructureDefinition-profile-visionprescription.html).
-
-        The test will skip if no Additional Orders cards are found.
+          - 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-57',
+      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
-      input :valid_cards_with_suggestions
+
+      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
-        parsed_cards = parse_json(valid_cards_with_suggestions)
-        additional_orders_cards = parsed_cards.filter do |card|
-          additional_orders_response_type?(card)
-        end
-        skip_if additional_orders_cards.blank?,
-                "#{tested_hook_name} hook response does not include Additional Orders as companion/prerequisite cards."
+        load_tagged_requests(tested_hook_name)
+
+        additional_orders_count = 0
+
+        successful_requests = requests.select { |request| request.status == 200 }
 
-        additional_orders_cards.each do |card|
-          card['suggestions'].each do |suggestion|
-            actions_check(suggestion['actions'], ig_version: 'v221')
-          end
+        skip_if successful_requests.blank?,
+                'No successful hook responses were received'
 
-          additional_orders_check(card)
+        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
 
-        no_error_validation('Some Additional Order cards are not valid. See messages for more information.')
+        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

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