davinci_crd_test_kit 0.13.0 → 0.14.0

data/lib/davinci_crd_test_kit/client/v2.2.1/registration/client_service_registration_attestation_test.rb

@@ -0,0 +1,107 @@
+module DaVinciCRDTestKit
+  module V221
+    class CRDClientServiceRegistrationAttestation < Inferno::Test
+      include ClientURLs
+
+      id :crd_v221_client_service_registration_attestation
+      title 'CRD client registers Inferno (Attestation)'
+      description %(
+        Inferno simulates two CRD servers which can be discovered at the following endpoints:
+        - Complete Prefetch Service Discovery Endpoint: #{ClientURLs.discovery_url}
+        - Subset Prefetch Service Discovery Endpoint: #{ClientURLs.prefetch_subset_discovery_url}
+
+        During this test, the tester will confirm that these two endpoints
+        have been registered by the client as trusted CRD servers that can access the CRD client's
+        FHIR server and that they have each been
+        - Associated with a particular payer organization (used to check that the
+          hook requests are sent by the client system to the appropriate payers based on
+          the Patient's coverage).
+        - Granted patient- or user-level read and search access to all US Core resource
+          types in the selected US Core version (required to verify the client's support
+          of the US Core FHIR API and used to verify the `fhirAuthorization.scope`
+          hook request field).
+      )
+      verifies_requirements 'cds-hooks_3.0.0-ballot@174'
+
+      input :complete_prefetch_service_organization_id,
+            title: 'Complete Prefetch Service Organization id',
+            description: %(
+              The FHIR Organization id associated with Inferno's simulated
+              complete prefetch CRD server. This Organization must be referenced as the
+              payer on Coverages in hook requests made to services described by the
+              `#{ClientURLs.discovery_url}` discovery endpoint.
+              The client suite may be run without this input, but it is required
+              for the tests to pass.
+            ),
+            type: 'text',
+            optional: true
+      input :subset_prefetch_service_organization_id,
+            title: 'Subset Prefetch Service Organization id',
+            description: %(
+              The FHIR Organization id associated with Inferno's simulated
+              subset prefetch CRD server. This Organization must be referenced
+              payer on Coverages in hook requests made to services described by the
+              `#{ClientURLs.prefetch_subset_discovery_url}` discovery endpoint.
+              The client suite may be run without this input, but it is required
+              for the tests to pass.
+            ),
+            type: 'text',
+            optional: true
+      output :attest_true_url
+      output :attest_false_url
+
+      def us_core_version
+        case suite_options[:us_core_version]
+        when CRDClientOptions::US_CORE_3
+          'v3.1.1'
+        when CRDClientOptions::US_CORE_6
+          'v6.1.0'
+        when CRDClientOptions::US_CORE_7
+          'v7.0.0'
+        end
+      end
+
+      def us_core_version_resource_types
+        case suite_options[:us_core_version]
+        when CRDClientOptions::US_CORE_3
+          CRDClientOptions::US_CORE_3_RESOURCE_TYPES
+        when CRDClientOptions::US_CORE_6, CRDClientOptions::US_CORE_7
+          CRDClientOptions::US_CORE_6_7_RESOURCE_TYPES
+        end.join('`, `')
+      end
+
+      run do
+        identifier = SecureRandom.hex(32)
+        attest_true_url = "#{resume_pass_url}?token=#{identifier}"
+        attest_false_url = "#{resume_fail_url}?token=#{identifier}"
+        output(attest_true_url:)
+        output(attest_false_url:)
+        wait(
+          identifier:,
+          message: <<~MESSAGE
+            **Registration of Inferno as a trusted CRD server**:
+
+            I attest that the following Inferno CRD servers have been registered as trusted
+            within the client system:
+
+            - Complete Prefetch Service Discovery Endpoint: `#{discovery_url}`
+              - Services on this CRD server will be invoked for patients with a primary coverage issued by the payer
+                represented by the Organization resource with id `#{complete_prefetch_service_organization_id}`.
+              - The CRD server has been granted patient- or user-level read and search access scopes for
+                all US Core #{us_core_version} profiled resource types (`#{us_core_version_resource_types}`).
+
+            - Subset Prefetch Service Discovery Endpoint: `#{prefetch_subset_discovery_url}`
+              - Services on this CRD server will be invoked for patients with a primary coverage issued by the payer
+                represented by the Organization resource with id `#{subset_prefetch_service_organization_id}`.
+              - The CRD server has been granted patient- or user-level read and search access scopes for
+                all US Core #{us_core_version} profiled resource types (`#{us_core_version_resource_types}`).
+
+            [Click here](#{attest_true_url}) if the above statement is **true**.
+
+            [Click here](#{attest_false_url}) if the above statement is **false**.
+          MESSAGE
+        )
+      end
+    end
+  end
+end

data/lib/davinci_crd_test_kit/client/v2.2.1/verify_request/hook_request_conformance_test.rb

@@ -0,0 +1,47 @@
+require_relative '../../../cross_suite/requests_logical_model_validation'
+require_relative '../../tagged_request_load_helper'
+require_relative '../../multi_request_message_helper'
+
+module DaVinciCRDTestKit
+  module V221
+    class HookRequestConformanceTest < Inferno::Test
+      include RequestsLogicalModelValidation
+      include DaVinciCRDTestKit::TaggedRequestLoadHelper
+      include DaVinciCRDTestKit::MultiRequestMessageHelper
+
+      id :crd_v221_hook_request_conformance
+      title 'Hook requests have the correct structure and contents'
+      description %(
+        During this test, Inferno will check each request body against the structural and content
+        requirements for the invoked hook.
+      )
+
+      output :url, :smart_auth_info
+
+      verifies_requirements 'cds-hooks_3.0.0-ballot@3', 'cds-hooks_3.0.0-ballot@222', 'cds-hooks_3.0.0-ballot@223',
+                            'cds-hooks_3.0.0-ballot@224',
+                            'hl7.fhir.us.davinci-crd_2.2.1@billopt-1', 'hl7.fhir.us.davinci-crd_2.2.1@found-36-A',
+                            'hl7.fhir.us.davinci-crd_2.2.1@hook-20', 'hl7.fhir.us.davinci-crd_2.2.1@hook-21'
+
+      run do
+        hook_requests = load_hook_requests
+
+        skip_if hook_requests.blank?, "No #{hook_name} hook requests received."
+
+        hook_requests.each_with_index do |request, request_index|
+          request_body = parse_json_request_entity(request.request_body, 'Request body', request_index)
+          next unless request_body.present?
+
+          validate_request_against_logical_model(request_body, request_index, '2.2.1')
+
+          output url: request_body['fhirServer'] if request_body['fhirServer'].present?
+          if request_body.dig('fhirAuthorization', 'access_token').present?
+            output smart_auth_info: { access_token: request_body['fhirAuthorization']['access_token'] }.to_json
+          end
+        end
+
+        assert_no_error_messages("#{requests_with_errors_prefix}Non-conformant hook request. See Messages for details.")
+      end
+    end
+  end
+end

data/lib/davinci_crd_test_kit/client/v2.2.1/verify_request/hook_request_coverage_verification_test.rb

@@ -0,0 +1,152 @@
+require_relative '../../../cross_suite/tags'
+require_relative '../../multi_request_message_helper'
+require_relative '../../tagged_request_load_helper'
+require_relative '../client_urls'
+
+module DaVinciCRDTestKit
+  module V221
+    class HookRequestCoverageVerificationTest < Inferno::Test
+      include DaVinciCRDTestKit::MultiRequestMessageHelper
+      include DaVinciCRDTestKit::TaggedRequestLoadHelper
+      include ClientURLs
+
+      id :crd_v221_hook_request_coverage_verification
+      title 'Prefetched coverages are valid'
+      description %(
+        During this test, Inferno will verify that the issuing payer Organization id from the `payor` element
+        of each hook request's prefetched coverage matches the Organization id associated with the
+        invoked simulated CRD server provided by the tester during the "Registration" group.
+        Inferno also checks that the Organization resources conform to the
+        [CRD Organization](https://hl7.org/fhir/us/davinci-crd/2.2.1/en/StructureDefinition-profile-organization.html)
+        profile.
+      )
+
+      verifies_requirements 'hl7.fhir.us.davinci-crd_2.2.1@dev-29-A', 'hl7.fhir.us.davinci-crd_2.2.1@hook-1'
+
+      input :complete_prefetch_service_organization_id,
+            title: 'Complete Prefetch Service Organization id',
+            description: %(
+              The FHIR Organization id associated with Inferno's simulated
+              complete prefetch CRD server. This Organization must be referenced as the
+              payer on Coverages in hook requests made to services described by the `#{ClientURLs.discovery_url}`
+              discovery endpoint. The client suite may be run without this input, but it is required
+              for the tests to pass.
+              Re-run the "Registration" group to provide this detail.
+            ),
+            type: 'text',
+            optional: true,
+            locked: true
+      input :subset_prefetch_service_organization_id,
+            title: 'Subset Prefetch Service Organization id',
+            description: %(
+              The FHIR Organization id associated with Inferno's simulated
+              subset prefetch CRD server. This Organization must be referenced
+              payer on Coverages in hook requests made to services described by the
+              `#{ClientURLs.prefetch_subset_discovery_url}` discovery endpoint.
+              The client suite may be run without this input, but it is required
+              for the tests to pass.
+              Re-run the "Registration" group to provide this detail.
+            ),
+            type: 'text',
+            optional: true,
+            locked: true
+
+      def prefetch_target(request)
+        if request.url.include?(PREFETCH_SUBSET_PREFIX)
+          :subset
+        else
+          :complete
+        end
+      end
+
+      def payer_org_id_for_request(request)
+        if prefetch_target(request) == :subset
+          subset_prefetch_service_organization_id
+        else
+          complete_prefetch_service_organization_id
+        end
+      end
+
+      def load_payer_request_for_hook_request(request_body)
+        hook_data_fetch_tag = TagMethods.hook_instance_data_fetch_tag(request_body['hookInstance'])
+        load_tagged_requests(PAYER_ORG_FETCH_TAG, hook_data_fetch_tag, DATA_FETCH_TAG).first
+      end
+
+      def check_payer_request(request_body, request_index, expected_payer_org_id)
+        payer_request = load_payer_request_for_hook_request(request_body)
+        unless payer_request.present? && payer_request.status.to_s.starts_with?('2')
+          add_request_message('error',
+                              "Inferno failed to retrieve the Coverage's payer during hook processing.",
+                              request_index)
+          return
+        end
+
+        payer_resource = FHIR.from_contents(payer_request.response_body)
+        unless payer_resource.present?
+          add_request_message('error', 'Request for payer resource returned invalid FHIR data.', request_index)
+          return
+        end
+
+        if payer_resource.resourceType != 'Organization'
+          add_request_message('error', 'Payer for the Coverage is not an Organization: ' \
+                                       "got '#{payer_resource.resourceType}'", request_index)
+        end
+        if payer_resource.id != expected_payer_org_id
+          add_request_message('error', 'Payer for the Coverage has the wrong id: ' \
+                                       "expected '#{expected_payer_org_id}', got '#{payer_resource.id}'.",
+                              request_index)
+        end
+
+        validator_response_details = []
+        resource_is_valid?(resource: payer_resource, profile_url: 'http://hl7.org/fhir/us/davinci-crd/StructureDefinition/profile-organization|2.2.1',
+                           add_messages_to_runnable: false, validator_response_details:)
+
+        validator_response_details.each { |issue| add_request_message(issue.severity, issue.message, request_index) }
+      end
+
+      run do
+        hook_requests = load_hook_requests
+
+        skip_if hook_requests.blank?, "No #{hook_name} hook requests received."
+
+        hook_requests.each_with_index do |request, request_index|
+          request_body = parse_json_request_entity(request.request_body, 'Request body', request_index)
+          next unless request_body.present?
+
+          expected_payer_org_id = payer_org_id_for_request(request)
+          if expected_payer_org_id.blank?
+            add_request_message(
+              'error',
+              'No Inferno Payer Organization id configured for this endpoint; skipping required coverage check.',
+              request_index
+            )
+            next
+          end
+
+          coverage = prefetched_coverage(request_body)
+          unless coverage.present?
+            add_request_message('warning', 'Request has no coverage.', request_index)
+            next
+          end
+
+          payer_organization_reference = coverage.dig('payor', 0, 'reference')
+          if payer_organization_reference.blank?
+            add_request_message('error', 'Coverage has no payer reference.', request_index)
+            next
+          end
+
+          check_payer_request(request_body, request_index, expected_payer_org_id)
+        end
+
+        assert_no_error_messages("#{requests_with_errors_prefix}Invalid coverage. " \
+                                 'See Messages for details.')
+      end
+
+      def prefetched_coverage(request_body)
+        coverage = request_body.dig('prefetch', 'coverage', 'entry', 0, 'resource')
+        coverage = request_body.dig('prefetch', 'cov', 'entry', 0, 'resource') unless coverage.present?
+        coverage
+      end
+    end
+  end
+end

data/lib/davinci_crd_test_kit/client/v2.2.1/verify_request/hook_request_data_fetch_verification_test.rb

@@ -0,0 +1,55 @@
+require_relative '../../../cross_suite/tags'
+require_relative '../../tagged_request_load_helper'
+
+module DaVinciCRDTestKit
+  module V221
+    class HookRequestDataFetchVerificationTest < Inferno::Test
+      include DaVinciCRDTestKit::TaggedRequestLoadHelper
+
+      id :crd_v221_hook_data_fetch_verification
+      title 'Client made additional FHIR data available during hook request processing'
+      description %(
+        During this test, Inferno will verify that for at least one hook request it was successfully
+        able to use the FHIR API and access token indicated in that hook request to gather additional data during
+        hook invocation. For this test to pass, at least one additional data request across
+        all hook invocations must succeed and return a FHIR resource.
+      )
+
+      verifies_requirements 'hl7.fhir.us.davinci-crd_2.2.1@found-20'
+
+      def fhir_data_returned?(request)
+        return false unless request.status.to_s.starts_with?('2')
+
+        fhir_response = FHIR.from_contents(request.response_body)
+        return false unless fhir_response.present?
+
+        if fhir_response.is_a?(FHIR::Bundle)
+          fhir_response.entry.any? { |entry| entry.resource.present? }
+        else
+          true
+        end
+      rescue JSON::ParserError
+        false
+      end
+
+      run do
+        hook_requests = load_hook_requests
+
+        skip_if hook_requests.blank?, "No #{hook_name} hook requests received."
+
+        data_returned = hook_requests.any? do |request|
+          request_body = JSON.parse(request.request_body)
+          additional_data_requests =
+            load_tagged_requests(TagMethods.hook_instance_data_fetch_tag(request_body['hookInstance']), DATA_FETCH_TAG)
+
+          additional_data_requests.any? { |data_request| fhir_data_returned?(data_request) }
+        rescue JSON::ParserError
+          false
+        end
+
+        assert data_returned,
+               'Inferno was never able to successfully obtain additional FHIR data during hook processing.'
+      end
+    end
+  end
+end

data/lib/davinci_crd_test_kit/client/v2.2.1/verify_request/hook_request_granted_scopes_test.rb

@@ -0,0 +1,123 @@
+require_relative '../../multi_request_message_helper'
+require_relative '../../crd_client_options'
+require_relative '../../tagged_request_load_helper'
+
+module DaVinciCRDTestKit
+  module V221
+    class HookRequestGrantedScopesTest < Inferno::Test
+      include DaVinciCRDTestKit::MultiRequestMessageHelper
+      include DaVinciCRDTestKit::TaggedRequestLoadHelper
+
+      id :crd_v221_hook_request_granted_scopes
+      title 'Hook requests grant the requested scopes'
+      description %(
+        As a part of registration, CRD clients and servers agree on a set of scopes that the server needs
+        to obtain all data that goes into creating hook responses. For the purposes of simulating a
+        payer CRD server acting as a part of these tests that evaluate conformance to the CRD specification,
+        Inferno requires access to all US Core resource types. While in a real exchange scenario, a CRD client
+        organization might well reject such a set of scopes as too large, for the purposes of testing, the client
+        must grant these scopes in order for Inferno to verify its conformance.
+
+        During this test, Inferno will verify that the requested scopes covering all resource types profiled in
+        the selected version of the US Core IG are granted and no more. Clients may choose to grant either user scopes
+        or patient scopes. If choosing patient scopes, note that the token is used by default for complete testing
+        of the client's US Core FHIR API, so either that single patient would need to
+        demonstrate all US Core resources and must support elements or another access token would need
+        to be provided when testing the client's FHIR API.
+      )
+
+      verifies_requirements 'hl7.fhir.us.davinci-crd_2.2.1@found-21'
+
+      run do
+        hook_requests = load_hook_requests
+
+        skip_if hook_requests.blank?, "No #{hook_name} hook requests received."
+
+        hook_requests.each_with_index do |request, request_index|
+          request_body = parse_json_request_entity(request.request_body, 'Request body', request_index)
+          next unless request_body.present?
+
+          # check that the resource scopes match what Inferno requested
+          granted_resource_scopes = granted_resource_scopes(request_body)
+          check_granted_resources(granted_resource_scopes, request_index)
+          check_granted_scopes_level(granted_resource_scopes, request_index)
+          check_granted_interactions(granted_resource_scopes, request_index)
+        end
+
+        assert_no_error_messages("#{requests_with_errors_prefix}Granted scopes do not match the requested scopes. " \
+                                 'See Messages for details.')
+      end
+
+      def requested_scope_resources
+        case suite_options[:us_core_version]
+        when CRDClientOptions::US_CORE_3
+          CRDClientOptions::US_CORE_3_RESOURCE_TYPES
+        when CRDClientOptions::US_CORE_6, CRDClientOptions::US_CORE_7
+          CRDClientOptions::US_CORE_6_7_RESOURCE_TYPES
+        end
+      end
+
+      def granted_resource_scopes(request_body)
+        granted_scopes = request_body.dig('fhirAuthorization', 'scope')
+        return [] unless granted_scopes.present?
+
+        granted_scopes.split(' ').grep(%r{\A\S+/\S+\.\S+\z}) # rubocop:disable Style/RedundantArgument
+      end
+
+      def check_granted_resources(granted_resource_scopes, request_index)
+        granted_scope_resources = granted_resource_scopes.map { |scope| scope.split('/').last.split('.').first }
+
+        missing_resources = requested_scope_resources - granted_scope_resources
+        extra_resources = granted_scope_resources - requested_scope_resources
+        if missing_resources.present?
+          add_request_message('error', 'Granted scopes missing the following ' \
+                                       "requested resource types: #{missing_resources.join(', ')}", request_index)
+        end
+        return unless extra_resources.present?
+
+        add_request_message('error', 'Granted scopes included the following resource types ' \
+                                     "beyond what was requested: #{extra_resources.join(', ')}", request_index)
+      end
+
+      def check_granted_interactions(granted_resource_scopes, request_index)
+        return if granted_resource_scopes.all? { |scope| scope.split('.').last == 'rs' }
+
+        if granted_resource_scopes.all? { |scope| scope.split('.').last == 'read' }
+          add_request_message('warning',
+                              'SMART v1 `read` scope used. Use of SMART v2 `rs` scope recommended.',
+                              request_index)
+          return
+        end
+
+        add_request_message('error', 'Some granted resource scopes do not provide ' \
+                                     "requested 'rs' (read and search) interactions.", request_index)
+      end
+
+      def check_granted_scopes_level(granted_resource_scopes, request_index)
+        level = scopes_level(granted_resource_scopes)
+        if level.blank?
+          add_request_message('error',
+                              'Requested scopes did not use a consistent level of scope (patient or user).',
+                              request_index)
+          return
+        end
+
+        return if ['user', 'patient'].include?(level)
+
+        add_request_message('error',
+                            "Unexpected level for granted scopes: expected 'user' or 'patient', got '#{level}'.",
+                            request_index)
+      end
+
+      def scopes_level(granted_resource_scopes)
+        return nil unless granted_resource_scopes.present? && all_scopes_same_level?(granted_resource_scopes)
+
+        granted_resource_scopes.first.split('/').first
+      end
+
+      def all_scopes_same_level?(granted_resource_scopes)
+        granted_resource_scopes.map { |s| s.split('/').first }.uniq.size <= 1
+      end
+    end
+  end
+end

data/lib/davinci_crd_test_kit/client/v2.2.1/verify_request/hook_request_prefetch_complete_test.rb

@@ -0,0 +1,127 @@
+require_relative '../../../cross_suite/prefetch_completeness_checker'
+require_relative '../../tagged_request_load_helper'
+require_relative '../../multi_request_message_helper'
+require_relative '../client_urls'
+
+module DaVinciCRDTestKit
+  module V221
+    class HookRequestPrefetchCompleteTest < Inferno::Test
+      include DaVinciCRDTestKit::TaggedRequestLoadHelper
+      include DaVinciCRDTestKit::MultiRequestMessageHelper
+
+      id :crd_v221_hook_request_prefetch_complete
+      title 'Hook requests include the requested prefetch data'
+      description %(
+        The [CDS service discovery response `prefetch` field](https://cds-hooks.hl7.org/2026Jan/en/#response)
+        contains key/value pairs describing additional information needed to render a response. Each key is a
+        string that describes the type of data being requested and the corresponding
+        value is a FHIR query (read or search) that will return the desired scope.
+        See the [Prefetch Template](https://cds-hooks.hl7.org/2026Jan/en/#prefetch-template)
+        section for more information about the format of `prefetch` templates.
+
+        [The CRD IG requires client support for prefetch](https://hl7.org/fhir/us/davinci-crd/2.2.1/en/foundation.html#prefetch)
+        including the ability to provide all data in and subsets of the [standard prefetch templates](https://hl7.org/fhir/us/davinci-crd/2.2.1/en/foundation.html#standard-prefetch),
+        when they are requested by the invoked CRD server. Inferno simulates two CRD servers,
+        one at `#{ClientURLs.discovery_url}` requiring the [complete set of standard prefetches](https://github.com/inferno-framework/davinci-crd-test-kit/blob/main/lib/davinci_crd_test_kit/client/v2.2.1/cds-services-v221.json)
+        and the other at `#{ClientURLs.prefetch_subset_discovery_url}`
+        [requesting a subset of the standard prefetch data set](https://github.com/inferno-framework/davinci-crd-test-kit/blob/main/lib/davinci_crd_test_kit/client/v2.2.1/cds-services-prefetch-subset-v221.json).
+
+        During this test, Inferno will verify that each hook request body includes a `prefetch` field populated with
+        valid JSON that contains exactly the requested prefetch keys and data sets described in the service description
+        for the invoked service as calculated by Inferno based on the resources provided in the request.
+      )
+      verifies_requirements 'cds-hooks_3.0.0-ballot@30', 'cds-hooks_3.0.0-ballot@231', 'cds-hooks_3.0.0-ballot@45',
+                            'cds-hooks_3.0.0-ballot@46', 'cds-hooks_3.0.0-ballot@47', 'cds-hooks_3.0.0-ballot@232',
+                            'cds-hooks_3.0.0-ballot@53', 'cds-hooks_3.0.0-ballot@240',
+                            'hl7.fhir.us.davinci-crd_2.2.1@dev-29-A', 'hl7.fhir.us.davinci-crd_2.2.1@found-23',
+                            'hl7.fhir.us.davinci-crd_2.2.1@found-24', 'hl7.fhir.us.davinci-crd_2.2.1@found-25-A',
+                            'hl7.fhir.us.davinci-crd_2.2.1@found-25-B', 'hl7.fhir.us.davinci-crd_2.2.1@found-31'
+
+      # output emitted only if the behavior is detected
+      output :demonstrates_fhirpath_collection_as_comma_delimited_string,
+             :demonstrates_prefetch_subset_distinct_from_complete,
+             :demonstrates_prefetch_complete_distinct_from_subset
+
+      SERVICE_FILENAMES = {
+        complete: 'cds-services-v221.json',
+        subset: 'cds-services-prefetch-subset-v221.json'
+      }.freeze
+
+      def service_path_for_target(target)
+        File.join(__dir__, '..', SERVICE_FILENAMES[target])
+      end
+
+      def service_path_for_opposite(target)
+        opposite = target == :complete ? :subset : :complete
+        service_path_for_target(opposite)
+      end
+
+      PREFETCH_KEY_COMPARISON_MAP = {
+        'patient' => 'pat',
+        'encounter' => 'enc',
+        'coverage' => 'cov',
+        'communicationRequests' => 'comReqs',
+        'deviceRequests' => 'devReqs',
+        'medicationRequests' => 'medReqs',
+        'nutritionOrders' => 'nutOrds',
+        'serviceRequests' => 'servReqs',
+        'visionPrescriptions' => 'visRxs',
+        'devices' => 'devs',
+        'medications' => 'meds',
+        'practitionerRoles' => 'roles',
+        'practitioners' => 'pracs',
+        'organizations' => 'orgs',
+        'locations' => 'locs'
+      }.freeze
+
+      def key_comparison_map_for_target(target)
+        if target == :complete
+          PREFETCH_KEY_COMPARISON_MAP.invert
+        else
+          PREFETCH_KEY_COMPARISON_MAP
+        end
+      end
+
+      run do
+        hook_requests = load_hook_requests
+
+        skip_if hook_requests.blank?, "No #{hook_name} hook requests received."
+
+        hook_requests.each_with_index do |request, request_index|
+          hook_request = parse_json_request_entity(request.request_body, 'Request body', request_index)
+          next unless hook_request.present?
+
+          prefetch_target = if request.url.include?(PREFETCH_SUBSET_PREFIX)
+                              :subset
+                            else
+                              :complete
+                            end
+
+          services_path = service_path_for_target(prefetch_target)
+          checker = PrefetchCompletenessChecker.new(hook_request, request_index, services_path)
+          completeness_errors = checker.check_prefetched_data
+          completeness_errors.each do |error|
+            add_message('error', error) # NOTE: PrefetchCompletenessChecker adds the (Request #) prefix
+          end
+          if checker.observed_fhirpath_collection_as_comma_delimited_string
+            output demonstrates_fhirpath_collection_as_comma_delimited_string: true
+          end
+          if completeness_errors.blank? &&
+             checker.data_set_different_with_alternate_service?(
+               service_path_for_opposite(prefetch_target),
+               key_comparison_map_for_target(prefetch_target)
+             )
+            if prefetch_target == :subset
+              output demonstrates_prefetch_subset_distinct_from_complete: true
+            else
+              output demonstrates_prefetch_complete_distinct_from_subset: true
+            end
+          end
+        end
+
+        assert_no_error_messages("#{requests_with_errors_prefix}Incomplete or invalid prefetched data. " \
+                                 'See Messages for details.')
+      end
+    end
+  end
+end

data/lib/davinci_crd_test_kit/client/v2.2.1/verify_request/hook_request_prefetch_profiles_test.rb

@@ -0,0 +1,55 @@
+require_relative '../../../cross_suite/prefetch_profile_validation'
+require_relative '../../tagged_request_load_helper'
+require_relative '../../multi_request_message_helper'
+
+module DaVinciCRDTestKit
+  module V221
+    class HookRequestPrefetchProfilesTest < Inferno::Test
+      include PrefetchProfileValidation
+      include DaVinciCRDTestKit::TaggedRequestLoadHelper
+      include DaVinciCRDTestKit::MultiRequestMessageHelper
+
+      id :crd_v221_hook_request_prefetch_profiles
+      title 'Prefetched resources conform to the required CRD profiles'
+      description %(
+        The [CDS service discovery response `prefetch` field](https://cds-hooks.hl7.org/2026Jan/en/#response)
+        contains key/value pairs describing additional information needed to render a response. Each key is a
+        string that describes the type of data being requested and the corresponding
+        value is a FHIR query (read or search) that will return the desired scope.
+        See the [Prefetch Template](https://cds-hooks.hl7.org/2026Jan/en/#prefetch-template)
+        section for more information about the format of `prefetch` templates.
+
+        [The CRD IG requires client support for prefetch](https://hl7.org/fhir/us/davinci-crd/2.2.1/en/foundation.html#prefetch)
+        including that the provided resources, which are part of the data included in the hook invocation,
+        [conform to the appropriate CRD profile](https://hl7.org/fhir/us/davinci-crd/2.2.1/en/hooks.html#ci-c-hook-21).
+
+        During this test, Inferno will verify that each FHIR resources found under the `prefetch`
+        field of each request body conforms to the appropriate CRD profile.
+      )
+
+      verifies_requirements 'hl7.fhir.us.davinci-crd_2.2.1@hook-21', 'hl7.fhir.us.davinci-crd_2.2.1@prof-3',
+                            'hl7.fhir.us.davinci-crd_2.2.1@prof-4', 'hl7.fhir.us.davinci-crd_2.2.1@prof-5',
+                            'hl7.fhir.us.davinci-crd_2.2.1@prof-6', 'hl7.fhir.us.davinci-crd_2.2.1@prof-7',
+                            'hl7.fhir.us.davinci-crd_2.2.1@prof-8', 'hl7.fhir.us.davinci-crd_2.2.1@prof-9',
+                            'hl7.fhir.us.davinci-crd_2.2.1@prof-10', 'hl7.fhir.us.davinci-crd_2.2.1@prof-11',
+                            'hl7.fhir.us.davinci-crd_2.2.1@prof-12'
+      run do
+        hook_requests = load_hook_requests
+
+        skip_if hook_requests.blank?, "No #{hook_name} hook requests received."
+
+        hook_requests.each_with_index do |request, request_index|
+          hook_request = parse_json_request_entity(request.request_body, 'Request body',
+                                                   request_index)
+          next unless hook_request.present?
+          next unless hook_request.key?('prefetch')
+
+          check_prefetch_profiles(hook_request['prefetch'], request_index)
+        end
+
+        assert_no_error_messages("#{requests_with_errors_prefix}Prefetched data not conformant to CRD profiles. " \
+                                 'See Messages for details.')
+      end
+    end
+  end
+end