davinci_crd_test_kit 0.12.2 → 0.14.0

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

@@ -0,0 +1,75 @@
+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'
+
+module DaVinciCRDTestKit
+  module V221
+    class CreateOrUpdateCoverageInfoResponseValidationTest < Inferno::Test
+      include DaVinciCRDTestKit::ServerTestHelper
+      include DaVinciCRDTestKit::SuggestionActionsValidation
+      include DaVinciCRDTestKit::ServerHookHelper
+      include DaVinciCRDTestKit::CardsIdentification
+      include DaVinciCRDTestKit::CardsValidation
+
+      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).
+
+        - **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-71'
+
+      optional
+      input :valid_cards_with_suggestions, :valid_system_actions
+
+      run do
+        parsed_cards = parse_json(valid_cards_with_suggestions)
+        parsed_actions = parse_json(valid_system_actions)
+
+        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
+
+        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
+
+        if create_or_update_coverage_info_actions.present?
+          actions_check(create_or_update_coverage_info_actions, ig_version: 'v221')
+        end
+
+        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')
+
+            create_or_update_coverage_check(card)
+          end
+        end
+
+        no_error_validation('Some Create or Update Coverage Information received are not valid.')
+      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,47 @@
+require_relative '../../server_test_helper'
+require_relative '../../server_hook_helper'
+require_relative '../../../cross_suite/cards_identification'
+require_relative '../../../cross_suite/cards_validation'
+
+module DaVinciCRDTestKit
+  module V221
+    class ExternalReferenceCardValidationTest < Inferno::Test
+      include DaVinciCRDTestKit::ServerTestHelper
+      include DaVinciCRDTestKit::ServerHookHelper
+      include DaVinciCRDTestKit::CardsIdentification
+      include DaVinciCRDTestKit::CardsValidation
+
+      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:
+        - The presence of a `links` array within each card.
+        - That every link in the `links` array of a card is of type `absolute`.
+      )
+
+      verifies_requirements 'hl7.fhir.us.davinci-crd_2.2.1@resp-22'
+
+      input :valid_cards_with_links
+      optional
+
+      run do
+        parsed_cards = parse_json(valid_cards_with_links)
+        external_reference_cards = parsed_cards.select { |card| external_reference_response_type?(card) }
+
+        skip_if external_reference_cards.blank?,
+                "#{tested_hook_name} hook response does not contain any External Reference cards."
+
+        external_reference_cards.each do |card|
+          external_reference_card_check(card)
+        end
+
+        assert messages.blank?,
+               '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,91 @@
+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'
+
+module DaVinciCRDTestKit
+  module V221
+    class FormCompletionResponseValidationTest < Inferno::Test
+      include DaVinciCRDTestKit::ServerTestHelper
+      include DaVinciCRDTestKit::SuggestionActionsValidation
+      include DaVinciCRDTestKit::ServerHookHelper
+      include DaVinciCRDTestKit::CardsIdentification
+      include DaVinciCRDTestKit::CardsValidation
+
+      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/STU2/cards.html#request-form-completion).
+
+        - **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](http://hl7.org/fhir/us/davinci-crd/StructureDefinition/profile-taskquestionnaire).
+          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-62',
+                            'hl7.fhir.us.davinci-crd_2.2.1@resp-65'
+
+      optional
+      input :valid_cards_with_suggestions, :valid_system_actions
+
+      run do
+        parsed_cards = parse_json(valid_cards_with_suggestions)
+        parsed_actions = parse_json(valid_system_actions)
+
+        form_completion_cards = parsed_cards.select { |card| form_completion_card_response_type?(card) }
+        form_completion_actions = parsed_actions.select { |action| form_completion_action_response_type?(action) }
+
+        skip_if form_completion_cards.blank? && form_completion_actions.blank?,
+                "#{tested_hook_name} hook response does not contain any Request Form Completion cards " \
+                'or system actions.'
+
+        actions_check(form_completion_actions, ig_version: 'v221') if form_completion_actions.present?
+
+        if form_completion_cards.present?
+          form_completion_cards.each do |card|
+            actions =
+              card['suggestions']
+                .flat_map { |suggestion| suggestion['actions'] }
+                .compact
+                .select { |action| form_completion_action_response_type? action }
+
+            actions_check(actions, ig_version: 'v221')
+
+            form_completion_check(card)
+          end
+        end
+
+        questionnaire_create_actions =
+          parsed_actions.select { |action| create_questionnaire_action_response_type?(action) } +
+          form_completion_cards
+            .flat_map { |card| card['suggestions'] }
+            .flat_map { |suggestion| suggestion['actions'] }
+            .compact
+            .select { |action| create_questionnaire_action_response_type?(action) }
+
+        questionnaire_create_actions.each { |action| questionnaire_creation_check(action) }
+
+        no_error_validation('Some Request Form Completion received are not valid.')
+      end
+    end
+  end
+end

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

@@ -0,0 +1,137 @@
+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 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

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

@@ -0,0 +1,32 @@
+require_relative '../../server_test_helper'
+require_relative '../../server_hook_helper'
+require_relative '../../../cross_suite/cards_identification'
+
+module DaVinciCRDTestKit
+  module V221
+    class InstructionsCardReceivedTest < Inferno::Test
+      include DaVinciCRDTestKit::ServerTestHelper
+      include DaVinciCRDTestKit::ServerHookHelper
+      include DaVinciCRDTestKit::CardsIdentification
+
+      title 'Instructions cards are valid'
+      id :crd_v221_valid_instructions_card_received
+      description %(
+        This test validates that an [Instructions](https://hl7.org/fhir/us/davinci-crd/STU2/cards.html#instructions)
+        card was received. It does so by:
+        - Checking for the presence of a valid card that does not contain the `links` field and the `suggestions` field.
+      )
+
+      verifies_requirements 'hl7.fhir.us.davinci-crd_2.2.1@resp-24'
+
+      input :valid_cards
+      optional
+
+      run do
+        parsed_cards = parse_json(valid_cards)
+        instructions_card = parsed_cards.find { |card| instructions_response_type?(card) }
+        assert instructions_card, "#{tested_hook_name} hook response did not contain an Instructions card."
+      end
+    end
+  end
+end

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

@@ -0,0 +1,49 @@
+require_relative '../../server_test_helper'
+require_relative '../../server_hook_helper'
+require_relative '../../../cross_suite/cards_identification'
+require_relative '../../../cross_suite/cards_validation'
+
+module DaVinciCRDTestKit
+  module V221
+    class LaunchSmartAppCardValidationTest < Inferno::Test
+      include DaVinciCRDTestKit::ServerTestHelper
+      include DaVinciCRDTestKit::ServerHookHelper
+      include DaVinciCRDTestKit::CardsIdentification
+      include DaVinciCRDTestKit::CardsValidation
+
+      title 'Launch SMART Application cards are valid'
+      id :crd_v221_launch_smart_app_card_validation
+      description %(
+        This test verifies the presence of valid Launch SMART Application 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#launch-smart-application),
+        Launch SMART Application cards must contain links with the type set to `smart`.
+        This test checks for the presence of any Launch SMART Application cards by verifying:
+        - The existence of a `links` array within each card.
+        - That every link in the `links` array of a card is of type `smart`.
+
+        The test will be skipped if no Launch SMART Application cards are found within the returned valid cards.
+      )
+
+      verifies_requirements 'hl7.fhir.us.davinci-crd_2.2.1@resp-72'
+
+      optional
+      input :valid_cards_with_links
+
+      run do
+        parsed_cards = parse_json(valid_cards_with_links)
+        launch_smart_app_cards = parsed_cards.select { |card| launch_smart_app_response_type?(card) }
+
+        skip_if launch_smart_app_cards.blank?,
+                "#{tested_hook_name} hook response does not contain any Launch SMART App cards."
+
+        launch_smart_app_cards.each do |card|
+          smart_app_card_check(card)
+        end
+
+        assert messages.blank?,
+               'Not all Launch SMART App cards were valid. See messages for more information.'
+      end
+    end
+  end
+end

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

@@ -0,0 +1,38 @@
+require_relative 'all_responses_include_coverage_information_test'
+require_relative 'hook_request_resource_resolution'
+
+module DaVinciCRDTestKit
+  module V221
+    class OrderDispatchCoverageInformationTest < AllResponsesIncludeCoverageInformationTest
+      include HookRequestResourceResolution
+
+      id :crd_v221_order_dispatch_coverage_information
+
+      input :invoked_hook
+
+      input :mock_ehr_bundle
+
+      def order_resources(hook_call_body)
+        references = hook_call_body.dig('context', 'dispatchedOrders')
+        resources = []
+        unmatched_references = []
+
+        Array(references).each do |reference|
+          resource = find_resource_by_reference(hook_call_body, reference)
+
+          if resource.present?
+            resources << resource
+          else
+            unmatched_references << reference
+          end
+        end
+
+        skip_if unmatched_references.present?,
+                'The following `dispatchedOrders` are not included in the Mock EHR Data input or prefetch: ' \
+                "#{unmatched_references.join(', ')}"
+
+        resources
+      end
+    end
+  end
+end

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

@@ -0,0 +1,54 @@
+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'
+
+module DaVinciCRDTestKit
+  module V221
+    class ProposeAlternateRequestCardValidationTest < Inferno::Test
+      include DaVinciCRDTestKit::ServerTestHelper
+      include DaVinciCRDTestKit::SuggestionActionsValidation
+      include DaVinciCRDTestKit::ServerHookHelper
+      include DaVinciCRDTestKit::CardsIdentification
+      include DaVinciCRDTestKit::CardsValidation
+
+      title 'Propose Alternate Request cards are valid'
+      id :crd_v221_propose_alternate_request_card_validation
+      description %(
+        This test validates that all [Propose Alternate Request](https://hl7.org/fhir/us/davinci-crd/STU2/cards.html#propose-alternate-request)
+        cards received are valid. It checks for the presence of a card's suggestion
+        with a single action with `Action.type` of `update` or a card with at least
+        two actions, one with `Action.type` of `delete` and the other with
+        `Action.type` of `create`.
+      )
+      optional
+
+      verifies_requirements 'hl7.fhir.us.davinci-crd_2.2.1@resp-55',
+                            'hl7.fhir.us.davinci-crd_2.2.1@resp-56'
+
+      input :valid_cards_with_suggestions, :contexts
+
+      run do
+        parsed_cards = parse_json(valid_cards_with_suggestions)
+        parsed_contexts = parse_json(contexts)
+        proposed_alternate_cards = parsed_cards.filter do |card|
+          propose_alternative_request_response_type?(card)
+        end
+
+        skip_if proposed_alternate_cards.blank?,
+                "#{tested_hook_name} hook response does not contain a Propose Alternate Request card."
+
+        proposed_alternate_cards.each do |card|
+          card['suggestions'].each do |suggestion|
+            actions_check(suggestion['actions'], parsed_contexts, ig_version: 'v221')
+          end
+
+          propose_alternate_request_check(card)
+        end
+
+        no_error_validation('Some Propose Alternate Request cards are not valid.')
+      end
+    end
+  end
+end

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

@@ -0,0 +1,97 @@
+require_relative '../../../cross_suite/cards_validation'
+require_relative '../../../cross_suite/response_logical_model_validation'
+require_relative '../../server_hook_helper'
+
+module DaVinciCRDTestKit
+  module V221
+    class ServiceResponseValidationTest < Inferno::Test
+      include DaVinciCRDTestKit::CardsValidation
+      include DaVinciCRDTestKit::ResponseLogicalModelValidation
+      include DaVinciCRDTestKit::ServerHookHelper
+
+      title 'Service responses contain valid cards and systemActions'
+      id :crd_v221_service_response_validation
+      description %(
+        As per the [CDS Hooks spec section on CDS Service
+        Response](https://cds-hooks.hl7.org/2.0/#cds-service-response), a
+        successful server's response to a service request must be a JSON object
+        containing a `cards` array and optionally a `systemActions` array.
+
+        Each card must contain the following required fields: `summary`, `indicator`, and `source`.
+        The required fields must have a valid data structure.
+      )
+
+      verifies_requirements 'hl7.fhir.us.davinci-crd_2.2.1@resp-4',
+                            'hl7.fhir.us.davinci-crd_2.2.1@resp-5',
+                            'hl7.fhir.us.davinci-crd_2.2.1@resp-13',
+                            'hl7.fhir.us.davinci-crd_2.2.1@resp-22',
+                            'hl7.fhir.us.davinci-crd_2.2.1@resp-24',
+                            'hl7.fhir.us.davinci-crd_2.2.1@resp-56'
+
+      input :invoked_hook
+      output :valid_cards, :valid_system_actions
+
+      SYSTEM_ACTIONS_HOOK_NAMES = ['appointment-book', 'order-sign', 'order-dispatch'].freeze
+
+      def valid_cards
+        @valid_cards ||= []
+      end
+
+      def valid_system_actions
+        @valid_system_actions ||= []
+      end
+
+      def system_actions_check(system_actions)
+        system_actions.each do |action|
+          current_error_count = messages.count { |msg| msg[:type] == 'error' }
+          action_fields_validation(action, ig_version: 'v221')
+          valid_system_actions << action if current_error_count == messages.count { |msg| msg[:type] == 'error' }
+        end
+      end
+
+      def perform_system_actions_validation(system_actions, response_index)
+        if SYSTEM_ACTIONS_HOOK_NAMES.include?(invoked_hook) && system_actions.nil?
+          msg = "Server response #{response_index + 1} did not have the `systemActions` field, " \
+                "which must be present for the `#{invoked_hook}` hook."
+          add_message('error', msg)
+        end
+        return if system_actions.nil?
+
+        unless system_actions.is_a?(Array)
+          add_message('error', "`systemActions` of server response #{response_index + 1} is not an array.")
+          return
+        end
+        system_actions_check(system_actions)
+      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.'
+
+        info do
+          unsuccessful_count = (requests - successful_requests).length
+          assert unsuccessful_count.zero?, "#{unsuccessful_count} out of #{requests.length} requests were unsuccessful"
+        end
+
+        successful_requests.each_with_index do |request, index|
+          service_response = JSON.parse(request.response_body)
+          perform_cards_validation(service_response['cards'], service_response['systemActions'].present?, 'v221', index)
+
+          perform_system_actions_validation(service_response['systemActions'], index)
+
+          # perform_response_logical_model_validation(service_response['cards'], service_response['systemActions'],
+          #                                           index)
+        rescue JSON::ParserError
+          add_message('error', "Invalid JSON: server response #{index + 1} is not valid JSON.")
+        end
+
+        output valid_system_actions: valid_system_actions.to_json
+        output valid_cards: valid_cards.to_json
+
+        no_error_validation('Some service responses are not valid. Check messages for issues found.')
+      end
+    end
+  end
+end