davinci_crd_test_kit 0.13.0 → 0.14.0

data/lib/davinci_crd_test_kit/server_tests/coverage_information_system_action_validation_test.rb

@@ -1,118 +0,0 @@
-require_relative '../server_hook_request_validation'
-require_relative '../test_helper'
-
-module DaVinciCRDTestKit
-  class CoverageInformationSystemActionValidationTest < Inferno::Test
-    include DaVinciCRDTestKit::ServerHookRequestValidation
-    include DaVinciCRDTestKit::TestHelper
-
-    title 'All Coverage Information system actions received are valid'
-    id :crd_coverage_info_system_action_validation
-    description %(
-      This test validates all [Coverage Information](https://hl7.org/fhir/us/davinci-crd/STU2/cards.html#coverage-information)
-      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.
-
-      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).
-    )
-    input :coverage_info
-    verifies_requirements 'hl7.fhir.us.davinci-crd_2.0.1@264', 'hl7.fhir.us.davinci-crd_2.0.1@265'
-
-    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 == 'http://hl7.org/fhir/us/davinci-crd/StructureDefinition/ext-coverage-information'
-
-        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 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}`"
-
-      resource = FHIR.from_contents(coverage_info_system_action['resource'].to_json)
-      profile_url = structure_definition_map[resource.resourceType]
-      assert_valid_resource(resource:, profile_url:)
-
-      grouped_coverage_info = extract_and_group_coverage_info(resource)
-      multiple_extensions_conformance_check(grouped_coverage_info, resource)
-    end
-
-    run do
-      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 }
-      end
-      assert error_messages.empty?, 'Some Coverage Info system actions are not valid.'
-    end
-  end
-end

data/lib/davinci_crd_test_kit/server_tests/create_or_update_coverage_info_response_validation_test.rb

@@ -1,71 +0,0 @@
-require_relative '../test_helper'
-require_relative '../suggestion_actions_validation'
-require_relative '../server_hook_helper'
-
-module DaVinciCRDTestKit
-  class CreateOrUpdateCoverageInfoResponseValidationTest < Inferno::Test
-    include DaVinciCRDTestKit::TestHelper
-    include DaVinciCRDTestKit::SuggestionActionsValidation
-    include DaVinciCRDTestKit::ServerHookHelper
-
-    title 'Valid Create or Update Coverage Information cards or system actions received'
-    id :crd_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.0.1@306'
-    optional
-    input :valid_cards_with_suggestions, :valid_system_actions
-
-    def coverage_actions(actions)
-      return [] if actions.nil?
-
-      valid_types = ['create', 'update']
-      actions.filter do |action|
-        valid_types.include?(action['type']) && action_resource_type_check(action, ['Coverage'])
-      end
-    end
-
-    def create_or_update_coverage_info_card?(card)
-      card['suggestions'].one? && coverage_actions(card['suggestions'].first['actions']).one?
-    end
-
-    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.filter { |card| create_or_update_coverage_info_card?(card) }
-      create_or_update_coverage_info_actions = coverage_actions(parsed_actions)
-
-      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
-
-      actions_check(create_or_update_coverage_info_actions) if create_or_update_coverage_info_actions.present?
-
-      if create_or_update_coverage_info_cards.present?
-        create_or_update_coverage_info_cards.each do |card|
-          actions = card['suggestions'].first['actions']
-          actions_check(coverage_actions(actions))
-        end
-      end
-
-      no_error_validation('Some Create or Update Coverage Information received are not valid.')
-    end
-  end
-end

data/lib/davinci_crd_test_kit/server_tests/discovery_endpoint_test.rb

@@ -1,88 +0,0 @@
-module DaVinciCRDTestKit
-  class DiscoveryEndpointTest < Inferno::Test
-    title 'Server returns a discovery response'
-    id :crd_discovery_endpoint_test
-    description %(
-      A CDS Service provider must expose its discovery endpoint at `{baseURL}/cds-services`
-      as specified in the [CDS Hooks Specification](https://cds-hooks.hl7.org/2.0/#discovery).
-
-      This test checks that the server responds to a GET request at the following endpoint:
-
-      `GET {baseURL}/cds-services`
-
-      It does this by checking that the server responds with an HTTP OK 200 status code
-      and that the body of the response is a valid JSON object. This test does not
-      inspect the structure and content of the response body to see if it contains the required information.
-      It only checks to see if the RESTful interaction is supported and returns a valid JSON object.
-    )
-
-    input_order :base_url, :authentication_required, :encryption_method, :jwks_kid
-    input :base_url
-    input :authentication_required,
-          title: 'Discovery endpoint requires authentication?',
-          type: 'radio',
-          default: 'no',
-          options: {
-            list_options: [
-              {
-                label: 'No',
-                value: 'no'
-              },
-              {
-                label: 'Yes',
-                value: 'yes'
-              }
-            ]
-          }
-    input :encryption_method,
-          title: 'JWT Signing Algorithm',
-          description: <<~DESCRIPTION,
-            CDS Hooks recommends ES384 and RS384 for JWT signature verification.
-            Select which method to use.
-          DESCRIPTION
-          type: 'radio',
-          default: 'ES384',
-          options: {
-            list_options: [
-              {
-                label: 'ES384',
-                value: 'ES384'
-              },
-              {
-                label: 'RS384',
-                value: 'RS384'
-              }
-            ]
-          }
-    input :jwks_kid,
-          title: 'CDS Services JWKS kid',
-          description: <<~DESCRIPTION,
-            The key ID of the JWKS private key to use for signing the JWTs when invoking a CDS service endpoint
-            requiring authentication.
-            Defaults to the first JWK in the list if no kid is supplied.
-          DESCRIPTION
-          optional: true
-    output :cds_services
-
-    run do
-      discovery_url = "#{base_url.chomp('/')}/cds-services"
-      headers = { 'Accept' => 'application/json' }
-
-      if authentication_required == 'yes'
-        token = JwtHelper.build(
-          aud: discovery_url,
-          iss: inferno_base_url,
-          jku: "#{inferno_base_url}/jwks.json",
-          kid: jwks_kid,
-          encryption_method:
-        )
-        headers['Authorization'] = "Bearer #{token}"
-      end
-      get(discovery_url, headers:, tags: [DISCOVERY_TAG])
-      assert_response_status(200)
-      assert_valid_json(request.response_body)
-
-      output cds_services: request.response_body
-    end
-  end
-end

data/lib/davinci_crd_test_kit/server_tests/discovery_services_validation_test.rb

@@ -1,65 +0,0 @@
-require_relative '../test_helper'
-
-module DaVinciCRDTestKit
-  class DiscoveryServicesValidationTest < Inferno::Test
-    include DaVinciCRDTestKit::TestHelper
-
-    title 'Discovery response contains valid services'
-    id :crd_discovery_services_validation
-    description %(
-      As per the [CDS Hooks Spec](https://cds-hooks.hl7.org/2.0/#response),
-      the response to the discovery endpoint SHALL be an object containing
-      a list of CDS services. If your CDS server hosts no CDS services,
-      the discovery endpoint should return a 200 HTTP response with
-      an empty array of services.
-
-      Each CDS service must contain the following required fields:
-      `hook`, `description`, and `id`.
-
-      This test checks for the presence of the required fields and
-      validates that they are of the correct type.
-
-      The test will be skipped if the server hosts no CDS services.
-    )
-
-    input :cds_services
-    output :appointment_book_service_ids, :encounter_start_service_ids, :encounter_discharge_service_ids,
-           :order_dispatch_service_ids, :order_select_service_ids, :order_sign_service_ids
-
-    def required_fields
-      {
-        'hook' => String,
-        'description' => String,
-        'id' => String
-      }
-    end
-
-    run do
-      object = parse_json(cds_services)
-      assert object['services'], 'Discovery response did not contain `services`'
-
-      services = object['services']
-      assert services.is_a?(Array), 'Services field of the CDS Discovery response object is not an array.'
-      skip_if services.empty?, 'Server hosts no CDS Services.'
-
-      service_hooks_to_ids = services.each_with_object({}) do |service, hash|
-        hash[service['hook']] ||= []
-        hash[service['hook']] << service['id'] if service['id']
-      end
-
-      output appointment_book_service_ids: service_hooks_to_ids['appointment-book']&.join(', '),
-             encounter_start_service_ids: service_hooks_to_ids['encounter-start']&.join(', '),
-             encounter_discharge_service_ids: service_hooks_to_ids['encounter-discharge']&.join(', '),
-             order_dispatch_service_ids: service_hooks_to_ids['order-dispatch']&.join(', '),
-             order_select_service_ids: service_hooks_to_ids['order-select']&.join(', '),
-             order_sign_service_ids: service_hooks_to_ids['order-sign']&.join(', ')
-
-      services.each do |service|
-        required_fields.each do |field, type|
-          assert(service[field], "Service `#{service}` did not contain required field: `#{field}`")
-          assert(service[field].is_a?(type), "Service `#{service}`: field `#{field}` is not of type #{type}")
-        end
-      end
-    end
-  end
-end

data/lib/davinci_crd_test_kit/server_tests/external_reference_card_across_hooks_validation_test.rb

@@ -1,28 +0,0 @@
-require_relative '../test_helper'
-
-module DaVinciCRDTestKit
-  class ExternalReferenceCardAcrossHooksValidationTest < Inferno::Test
-    include DaVinciCRDTestKit::TestHelper
-
-    title 'Valid External Reference cards received across all hooks'
-    id :crd_external_reference_card_across_hooks_validation
-    description %(
-      This test verifies the presence of valid External Reference returned by CRD services across all hooks invoked.
-      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`.
-
-      The test will be skipped if no valid External Reference cards are returned across all hooks.
-    )
-
-    run do
-      verify_at_least_one_test_passes(
-        self.class.parent.parent.groups,
-        'crd_external_reference_card_validation',
-        'None of the hooks invoked returned an External Reference card.'
-      )
-    end
-  end
-end

data/lib/davinci_crd_test_kit/server_tests/external_reference_card_validation_test.rb

@@ -1,36 +0,0 @@
-require_relative '../test_helper'
-require_relative '../server_hook_helper'
-
-module DaVinciCRDTestKit
-  class ExternalReferenceCardValidationTest < Inferno::Test
-    include DaVinciCRDTestKit::TestHelper
-    include DaVinciCRDTestKit::ServerHookHelper
-
-    title 'Valid External Reference cards received'
-    id :crd_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.0.1@258', 'hl7.fhir.us.davinci-crd_2.0.1@259'
-
-    input :valid_cards_with_links
-    optional
-
-    run do
-      parsed_cards = parse_json(valid_cards_with_links)
-      external_reference_cards = parsed_cards.select do |card|
-        links = card['links']
-        links.present? && links.all? { |link| link['type'] == 'absolute' }
-      end
-
-      assert external_reference_cards.present?,
-             "#{tested_hook_name} hook response did not contain an External Reference card."
-    end
-  end
-end

data/lib/davinci_crd_test_kit/server_tests/form_completion_response_validation_test.rb

@@ -1,78 +0,0 @@
-require_relative '../test_helper'
-require_relative '../suggestion_actions_validation'
-require_relative '../server_hook_helper'
-
-module DaVinciCRDTestKit
-  class FormCompletionResponseValidationTest < Inferno::Test
-    include DaVinciCRDTestKit::TestHelper
-    include DaVinciCRDTestKit::SuggestionActionsValidation
-    include DaVinciCRDTestKit::ServerHookHelper
-
-    title 'Valid Request Form Completion cards or system actions received'
-    id :crd_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).
-
-      If no Request Form Completion cards or system actions are received, the test is skipped.
-    )
-    verifies_requirements 'hl7.fhir.us.davinci-crd_2.0.1@299'
-    optional
-    input :valid_cards_with_suggestions, :valid_system_actions
-
-    def task_actions(actions)
-      actions&.select { |action| action['type'] == 'create' && action_resource_type_check(action, ['Task']) }
-    end
-
-    def task_questionnaire?(task_action)
-      task = FHIR.from_contents(task_action['resource'].to_json)
-      task.code.coding.any? { |code| code.code == 'complete-questionnaire' } &&
-        task.input.any? { |input| input.type.text == 'questionnaire' && valid_url?(input.valueCanonical) }
-    end
-
-    def request_form_completion_card?(card)
-      card['suggestions'].all? do |suggestion|
-        actions = suggestion['actions']
-        task_actions = task_actions(actions)
-        task_actions.present? && task_actions.all? { |action| task_questionnaire?(action) }
-      end
-    end
-
-    run do
-      parsed_cards = parse_json(valid_cards_with_suggestions)
-      parsed_actions = parse_json(valid_system_actions)
-
-      form_completion_cards = parsed_cards.filter { |card| request_form_completion_card?(card) }
-      form_completion_actions = task_actions(parsed_actions).select { |action| task_questionnaire?(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) if form_completion_actions.present?
-
-      if form_completion_cards.present?
-        form_completion_cards.each do |card|
-          card['suggestions'].each do |suggestion|
-            actions_check(task_actions(suggestion['actions']))
-          end
-        end
-      end
-
-      no_error_validation('Some Request Form Completion received are not valid.')
-    end
-  end
-end

data/lib/davinci_crd_test_kit/server_tests/instructions_card_received_across_hooks_test.rb

@@ -1,25 +0,0 @@
-require_relative '../test_helper'
-
-module DaVinciCRDTestKit
-  class InstructionsCardReceivedAcrossHooksTest < Inferno::Test
-    include DaVinciCRDTestKit::TestHelper
-
-    title 'Valid Instructions cards received across all hooks'
-    id :crd_valid_instructions_card_received_across_hooks
-    description %(
-      This test validates that a valid [Instructions card](https://hl7.org/fhir/us/davinci-crd/STU2/cards.html#instructions)
-      was received across all hooks responses.
-
-      The test will be skipped if no valid Instructions cards are returned across all hooks.
-    )
-
-    run do
-      verify_at_least_one_test_passes(
-        self.class.parent.parent.groups,
-        'crd_valid_instructions_card_received',
-        'None of the hooks invoked returned a valid Instructions card.',
-        'across_hooks'
-      )
-    end
-  end
-end

data/lib/davinci_crd_test_kit/server_tests/instructions_card_received_test.rb

@@ -1,26 +0,0 @@
-require_relative '../test_helper'
-require_relative '../server_hook_helper'
-
-module DaVinciCRDTestKit
-  class InstructionsCardReceivedTest < Inferno::Test
-    include DaVinciCRDTestKit::TestHelper
-    include DaVinciCRDTestKit::ServerHookHelper
-
-    title 'Valid Instructions cards received'
-    id :crd_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.
-    )
-
-    input :valid_cards
-    optional
-
-    run do
-      parsed_cards = parse_json(valid_cards)
-      instructions_card = parsed_cards.find { |card| card['links'].blank? && card['suggestions'].blank? }
-      assert instructions_card, "#{tested_hook_name} hook response did not contain an Instructions card."
-    end
-  end
-end

data/lib/davinci_crd_test_kit/server_tests/launch_smart_app_card_validation_test.rb

@@ -1,38 +0,0 @@
-require_relative '../test_helper'
-require_relative '../server_hook_helper'
-
-module DaVinciCRDTestKit
-  class LaunchSmartAppCardValidationTest < Inferno::Test
-    include DaVinciCRDTestKit::TestHelper
-    include DaVinciCRDTestKit::ServerHookHelper
-
-    title 'Valid Launch SMART Application cards received'
-    id :crd_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.0.1@258'
-
-    optional
-    input :valid_cards_with_links
-
-    run do
-      parsed_cards = parse_json(valid_cards_with_links)
-      external_reference_cards = parsed_cards.select do |card|
-        links = card['links']
-        links.present? && links.all? { |link| link['type'] == 'smart' }
-      end
-
-      skip_if external_reference_cards.blank?,
-              "#{tested_hook_name} hook response does not contain any Launch SMART App cards."
-    end
-  end
-end

data/lib/davinci_crd_test_kit/server_tests/propose_alternate_request_card_validation_test.rb

@@ -1,63 +0,0 @@
-require_relative '../test_helper'
-require_relative '../suggestion_actions_validation'
-require_relative '../server_hook_helper'
-
-module DaVinciCRDTestKit
-  class ProposeAlternateRequestCardValidationTest < Inferno::Test
-    include DaVinciCRDTestKit::TestHelper
-    include DaVinciCRDTestKit::SuggestionActionsValidation
-    include DaVinciCRDTestKit::ServerHookHelper
-
-    title 'Valid Propose Alternate Request cards received'
-    id :crd_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
-    input :valid_cards_with_suggestions, :contexts
-
-    EXPECTED_RESOURCE_TYPES = %w[
-      Device DeviceRequest Encounter Medication
-      MedicationRequest NutritionOrder ServiceRequest
-      VisionPrescription
-    ].freeze
-
-    def check_action_type(actions, action_type)
-      actions&.any? do |action|
-        action['type'] == action_type && action_resource_type_check(action, EXPECTED_RESOURCE_TYPES)
-      end
-    end
-
-    def propose_alternate_request_card?(card)
-      card['suggestions'].any? do |suggestion|
-        actions = suggestion['actions']
-        has_update = check_action_type(actions, 'update')
-        has_delete = check_action_type(actions, 'delete')
-        has_create = check_action_type(actions, 'create')
-
-        has_update || (has_delete && has_create)
-      end
-    end
-
-    run do
-      parsed_cards = parse_json(valid_cards_with_suggestions)
-      parsed_contexts = parse_json(contexts)
-      proposed_alternate_cards = parsed_cards.filter { |card| propose_alternate_request_card?(card) }
-
-      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)
-        end
-      end
-
-      no_error_validation('Some Proposed Alternate Request cards are not valid.')
-    end
-  end
-end