davinci_crd_test_kit 0.9.0

data/lib/davinci_crd_test_kit/server_tests/coverage_information_system_action_across_hooks_validation_test.rb

@@ -0,0 +1,32 @@
+require_relative '../test_helper'
+
+module DaVinciCRDTestKit
+  class CoverageInformationSystemActionAcrossHooksValidationTest < Inferno::Test
+    include DaVinciCRDTestKit::TestHelper
+
+    title 'Valid Coverage Information system actions received across all hooks'
+    id :crd_coverage_info_system_action_across_hooks_validation
+    description %(
+      This test verifies the presence of valid [Coverage Information](https://hl7.org/fhir/us/davinci-crd/STU2/cards.html#coverage-information)
+      system action returned by CRD services across all hooks invoked. 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).
+
+      The test will be skipped if no valid Coverage Information system actions are returned across all hooks.
+    )
+
+    run do
+      verify_at_least_one_test_passes(
+        self.class.parent.parent.groups,
+        'crd_coverage_info_system_action_validation',
+        'None of the hooks invoked returned valid Coverage Info system actions.'
+      )
+    end
+  end
+end

data/lib/davinci_crd_test_kit/server_tests/coverage_information_system_action_received_test.rb

@@ -0,0 +1,58 @@
+require_relative '../test_helper'
+module DaVinciCRDTestKit
+  class CoverageInformationSystemActionReceivedTest < Inferno::Test
+    include DaVinciCRDTestKit::TestHelper
+
+    title 'Coverage Information system action was received'
+    id :crd_coverage_info_system_action_received
+    description %(
+      This test validates that a [Coverage Information](https://hl7.org/fhir/us/davinci-crd/STU2/cards.html#coverage-information)
+      system action was returned. It does so by:
+      - First checking for the presence of actions with a `resource` element of the following types:
+        - For `appointment-book`: Appointment
+        - For `order-sign` or `order-dispatch`: DeviceRequest, MedicationRequest, NutritionOrder,
+          ServiceRequest, or VisionPrescription
+      - Then, among the target actions, checking if their resource has the [coverage-information extension](http://hl7.org/fhir/us/davinci-crd/StructureDefinition/ext-coverage-information).
+    )
+
+    input :valid_system_actions
+    output :coverage_info
+
+    def hook_name
+      config.options[:hook_name]
+    end
+
+    def resources_by_hook
+      shared_resources = [
+        'DeviceRequest', 'MedicationRequest', 'NutritionOrder',
+        'ServiceRequest', 'VisionPrescription'
+      ]
+      {
+        'appointment-book' => ['Appointment'],
+        'order-sign' => shared_resources,
+        'order-dispatch' => shared_resources
+      }
+    end
+
+    run do
+      parsed_actions = parse_json(valid_system_actions)
+      target_resources = resources_by_hook[hook_name]
+
+      target_actions = parsed_actions.select do |action|
+        resource = FHIR.from_contents(action['resource'].to_json)
+        target_resources.include?(resource&.resourceType)
+      end
+
+      coverage_info_system_actions = target_actions.select do |action|
+        resource = FHIR.from_contents(action['resource'].to_json)
+        coverage_info_ext_url = 'http://hl7.org/fhir/us/davinci-crd/StructureDefinition/ext-coverage-information'
+        resource.extension.any? { |extension| extension.url == coverage_info_ext_url }
+      end
+
+      assert coverage_info_system_actions.present?,
+             "Coverage Information system action was not returned in the #{hook_name} hook response."
+
+      output coverage_info: coverage_info_system_actions.to_json
+    end
+  end
+end

data/lib/davinci_crd_test_kit/server_tests/coverage_information_system_action_validation_test.rb

@@ -0,0 +1,121 @@
+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
+
+    def hook_name
+      config.options[:hook_name]
+    end
+
+    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

@@ -0,0 +1,72 @@
+require_relative '../test_helper'
+require_relative '../suggestion_actions_validation'
+
+module DaVinciCRDTestKit
+  class CreateOrUpdateCoverageInfoResponseValidationTest < Inferno::Test
+    include DaVinciCRDTestKit::TestHelper
+    include DaVinciCRDTestKit::SuggestionActionsValidation
+
+    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.
+    )
+    optional
+    input :valid_cards_with_suggestions, :valid_system_actions
+
+    def hook_name
+      config.options[:hook_name]
+    end
+
+    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 = "#{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

@@ -0,0 +1,88 @@
+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:)
+      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

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

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

@@ -0,0 +1,36 @@
+require_relative '../test_helper'
+
+module DaVinciCRDTestKit
+  class ExternalReferenceCardValidationTest < Inferno::Test
+    include DaVinciCRDTestKit::TestHelper
+
+    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`.
+    )
+
+    input :valid_cards_with_links
+    optional
+
+    def hook_name
+      config.options[:hook_name]
+    end
+
+    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?, "#{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

@@ -0,0 +1,79 @@
+require_relative '../test_helper'
+require_relative '../suggestion_actions_validation'
+
+module DaVinciCRDTestKit
+  class FormCompletionResponseValidationTest < Inferno::Test
+    include DaVinciCRDTestKit::TestHelper
+    include DaVinciCRDTestKit::SuggestionActionsValidation
+
+    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.
+    )
+    optional
+    input :valid_cards_with_suggestions, :valid_system_actions
+
+    def hook_name
+      config.options[:hook_name]
+    end
+
+    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?,
+              "#{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

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

@@ -0,0 +1,28 @@
+require_relative '../test_helper'
+
+module DaVinciCRDTestKit
+  class InstructionsCardReceivedTest < Inferno::Test
+    include DaVinciCRDTestKit::TestHelper
+
+    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
+
+    def hook_name
+      config.options[:hook_name]
+    end
+
+    run do
+      parsed_cards = parse_json(valid_cards)
+      instructions_card = parsed_cards.find { |card| card['links'].blank? && card['suggestions'].blank? }
+      assert instructions_card, 'Hook response did not contain an Instructions card.'
+    end
+  end
+end