davinci_crd_test_kit 0.13.0 → 0.14.1

data/lib/davinci_crd_test_kit/server/v2.2.1/discovery/discovery_configuration_test.rb

@@ -0,0 +1,159 @@
+module DaVinciCRDTestKit
+  module V221
+    class DiscoveryConfigurationTest < Inferno::Test
+      title 'Server makes configuration options available'
+      id :crd_v221_discovery_configuration
+      description %(
+        According to the spec:
+
+        > CRD servers SHALL, at minimum, offer configuration options for each
+          type of card they support
+
+        This test verifies that all primary hook services contain at least one
+        valid configuration option for `coverage-info`. Secondary hooks are not
+        expected to return cards, so they are ignored in this test.
+      )
+
+      verifies_requirements 'hl7.fhir.us.davinci-crd_2.2.1@dev-4',
+                            'hl7.fhir.us.davinci-crd_2.2.1@dev-5',
+                            'hl7.fhir.us.davinci-crd_2.2.1@dev-7',
+                            'hl7.fhir.us.davinci-crd_2.2.1@dev-8'
+
+      input :cds_services
+      input :crd_discovery_service_ignore_list,
+            optional: true
+
+      def primary_hooks
+        ['appointment-book', 'order-sign', 'order-dispatch']
+      end
+
+      def primary_hook?(hook)
+        primary_hooks.include? hook
+      end
+
+      def required_fields
+        ['code', 'type', 'name', 'description', 'default']
+      end
+
+      def verify_unique_values(hook, service)
+        unique_fields = ['code', 'name', 'description']
+
+        config_options =
+          service
+            .dig('extension', 'davinci-crd.configuration-options')
+
+        return if config_options.blank?
+
+        unique_fields.each do |unique_field|
+          value_counts =
+            config_options
+              .map { |config_option| config_option[unique_field] }
+              .tally
+
+          duplicate_values =
+            value_counts
+              .select { |_value, count| count > 1 }
+              .keys
+
+          next if duplicate_values.blank?
+
+          duplicate_values_string = duplicate_values.map { |value| "\n- `#{value}`" }.join
+
+          add_message(
+            'error',
+            "Services for hook `#{hook}` contain duplicate values for `#{unique_field}`:" \
+            "#{duplicate_values_string}"
+          )
+        end
+      end
+
+      def verify_required_fields(hook, service)
+        service.dig('extension', 'davinci-crd.configuration-options')&.each do |config_option|
+          required_fields.each do |field_name|
+            unless config_option.key?(field_name)
+              add_message(
+                'error',
+                "Hook `#{hook}` service `#{service['id']}` configuration option `#{config_option['code']}` " \
+                "does not contain `#{field_name}` field"
+              )
+              next
+            end
+
+            next if field_name == 'default'
+
+            next if config_option[field_name].is_a? String
+
+            type = config_option[field_name].class
+            add_message(
+              'error',
+              "Expected hook `#{hook}` service `#{service['id']}` configuration option `#{config_option['code']}` " \
+              "field `#{field_name}` to be a String, but found #{type}"
+            )
+          end
+        end
+      end
+
+      run do
+        ignore_list = crd_discovery_service_ignore_list.to_s.split(',').map(&:strip).reject(&:blank?)
+        services =
+          JSON.parse(cds_services)['services']
+            .reject { |service| ignore_list.include? service['id'] }
+
+        services_by_hook = services.group_by { |service| service['hook'] }
+
+        services_by_hook.each do |hook, hook_services|
+          hook_services.each do |service|
+            verify_required_fields(hook, service)
+            verify_unique_values(hook, service)
+          end
+        end
+
+        primary_hook_services = services_by_hook.slice(*primary_hooks).values.flatten
+
+        assert messages.none? { |message| message[:type] == 'error' },
+               'Some services contain invalid configuration options.'
+
+        omit_if primary_hook_services.blank?, 'No services for primary hooks found'
+
+        services_without_configuration_options =
+          primary_hook_services.reject do |service|
+            service['extension'].present? && service['extension']['davinci-crd.configuration-options'].present?
+          end
+
+        if services_without_configuration_options.present?
+          add_message(
+            'error',
+            'The following services do not contain any configuration options: ' \
+            "#{services_without_configuration_options.map { |service| service['code'] }.join(', ')}"
+          )
+        end
+
+        primary_hook_services.each do |service|
+          coverage_info_config =
+            service.dig('extension', 'davinci-crd.configuration-options')&.find do |config_option|
+              config_option['code'] == 'coverage-info'
+            end
+
+          if coverage_info_config.present?
+            if coverage_info_config['type'] != 'boolean'
+              add_message(
+                'error',
+                "Service `#{service['id']}` `coverage-info` configuration option is not of type boolean"
+              )
+            end
+
+            next
+          end
+
+          add_message(
+            'error',
+            "Service `#{service['id']}` does not contain a `coverage-info` configuration option"
+          )
+        end
+
+        assert messages.none? { |message| message[:type] == 'error' },
+               'Not all primary hook services contain valid configuration options.'
+      end
+    end
+  end
+end

data/lib/davinci_crd_test_kit/server/v2.2.1/discovery/discovery_endpoint_test.rb

@@ -0,0 +1,90 @@
+module DaVinciCRDTestKit
+  module V221
+    class DiscoveryEndpointTest < Inferno::Test
+      title 'Server returns a discovery response'
+      id :crd_v221_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
+end

data/lib/davinci_crd_test_kit/server/v2.2.1/discovery/discovery_prefetch_support_test.rb

@@ -0,0 +1,43 @@
+require_relative '../../server_test_helper'
+
+module DaVinciCRDTestKit
+  module V221
+    class DiscoveryPrefetchSupportTest < Inferno::Test
+      include DaVinciCRDTestKit::ServerTestHelper
+
+      title 'Server advertises prefetch support'
+      id :crd_v221_discovery_prefetch_support
+      description %(
+        This test expects the server to demonstrate support for prefetch queries
+        by providing a prefetch query in at least one of the advertised service
+        in the discovery response.
+      )
+
+      verifies_requirements 'hl7.fhir.us.davinci-crd_2.2.1@found-24'
+
+      input :cds_services
+      input :crd_discovery_service_ignore_list,
+            optional: true
+
+      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.'
+
+        ignored_service_ids = crd_discovery_service_ignore_list.to_s.split(',').map(&:strip).reject(&:blank?)
+        services
+          .select { |service| ignored_service_ids.include?(service['id']) }
+          .each do |service|
+            info "Ignoring service `#{service['id']}` because it is in the ignore list."
+          end
+        services_for_crd_validation = services.reject { |service| ignored_service_ids.include?(service['id']) }
+
+        prefetch_supported = services_for_crd_validation.any? { |service| service['prefetch'].present? }
+
+        skip_if !prefetch_supported, 'No CRD services advertised prefetch support'
+      end
+    end
+  end
+end

data/lib/davinci_crd_test_kit/server/v2.2.1/discovery/discovery_services_validation_test.rb

@@ -0,0 +1,121 @@
+require_relative '../../server_test_helper'
+
+module DaVinciCRDTestKit
+  module V221
+    class DiscoveryServicesValidationTest < Inferno::Test
+      include DaVinciCRDTestKit::ServerTestHelper
+
+      title 'Discovery response contains valid services'
+      id :crd_v221_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`.
+
+        Additionally, the [CRD
+        Spec](https://hl7.org/fhir/us/davinci-crd/2.2.1/en/deviations.html#crd-version-declaration)
+        states that "CRD servers SHALL declare at least one supported CRD
+        version for each supported hook" using the `davinci-crd.version`
+        extension.
+
+        This test checks for the presence of the required fields and
+        validates that they are of the correct type.
+
+        CDS services provided by the server to support use cases outside the
+        scope of the CRD specification can be provided in an ignore list input to
+        opt-out of CRD validation.
+
+        The test will be skipped if the server hosts no CRD CDS services.
+      )
+
+      verifies_requirements 'hl7.fhir.us.davinci-crd_2.2.1@dev-1'
+
+      input :cds_services
+      input :crd_discovery_service_ignore_list,
+            title: 'Service ID Ignore List',
+            description: %(
+              In the case that CDS services advertised on this server support
+              use cases outside the scope of the CRD specification, provide a
+              comma-separated list of service IDs to opt-out of CRD validation.
+              Ignored services will not be stored for use in later tests.  If
+              blank, all services are checked and saved.
+            ),
+            optional: true
+      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
+
+      EXTENSION_KEY = 'davinci-crd.version'.freeze
+
+      def required_fields
+        {
+          'hook' => String,
+          'description' => String,
+          'id' => String,
+          'extension' => Hash
+        }
+      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.'
+
+        ignored_service_ids = crd_discovery_service_ignore_list.to_s.split(',').map(&:strip).reject(&:blank?)
+        services
+          .select { |service| ignored_service_ids.include?(service['id']) }
+          .each do |service|
+            info "Ignoring service `#{service['id']}` because it is in the ignore list."
+          end
+        services_for_crd_validation = services.reject { |service| ignored_service_ids.include?(service['id']) }
+
+        service_hooks_to_ids = services_for_crd_validation.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(', ')
+
+        skip_if services.empty?, 'Server hosts no CDS Services.'
+        skip_if services_for_crd_validation.empty?, 'Ignore list excludes all CDS Services from validation.'
+
+        services_for_crd_validation.each do |service|
+          required_fields.each do |field, type|
+            assert(service[field], "Service `#{service['id']}` did not contain required field: `#{field}`")
+            assert(service[field].is_a?(type), "Service `#{service['id']}`: field `#{field}` is not of type #{type}")
+          end
+
+          assert service['extension'].key?(EXTENSION_KEY),
+                 "Service `#{service['id']}`: does not contain a `#{EXTENSION_KEY}` extension"
+          assert service['extension'][EXTENSION_KEY].is_a?(Array),
+                 "Service `#{service['id']}`: `#{EXTENSION_KEY}` extension is not of type Array"
+          assert service['extension'][EXTENSION_KEY].present?,
+                 "Service `#{service['id']}`: `#{EXTENSION_KEY}` extension is empty"
+          non_string_values = service['extension'][EXTENSION_KEY].reject { |value| value.is_a? String }
+          assert non_string_values.blank?,
+                 "Service `#{service['id']}`: `#{EXTENSION_KEY}` extension contains non-string values: " \
+                 "#{non_string_values.join(', ')}"
+
+          invalid_versions =
+            service['extension'][EXTENSION_KEY]
+              .reject { |version| version.match?(/\A[1-9]\d*\.\d+\Z/) }
+
+          assert invalid_versions.blank?,
+                 "Service `#{service['id']}`: `#{EXTENSION_KEY}` extension contains invalid " \
+                 "version strings: #{invalid_versions.join(', ')}"
+        end
+      end
+    end
+  end
+end

data/lib/davinci_crd_test_kit/server/v2.2.1/discovery/discovery_standard_prefetch_expressions_test.rb

@@ -0,0 +1,166 @@
+require_relative '../../server_test_helper'
+
+module DaVinciCRDTestKit
+  module V221
+    class DiscoveryStandardPrefetchExpressionsTest < Inferno::Test
+      include DaVinciCRDTestKit::ServerTestHelper
+
+      title 'Server uses standard prefetch expressions'
+      id :crd_v221_discovery_standard_prefetch_expressions
+      description %(
+        This test checks each prefetch expression value advertised by CRD services in the discovery
+        response against the standard prefetch expressions listed in the CRD IG for the service hook. If a prefetch
+        expression does not match one of the standard expressions for that hook, the test will add a warning.
+
+        These warnings should be checked individually, as the interpretation of the warning will depend on the server's
+        intent: For expressions that are intended to capture any of the data elements in that hook's set of
+        [standard prefetch queries](https://hl7.org/fhir/us/davinci-crd/2.2.1/en/foundation.html#appointment-book-prefetch),
+        it must match the corresponding expression in the IG, and the warning should be considered an error. Note that
+        the expression keys do not need to match and are ignored by this test. FHIRPath alternative ordering is also
+        ignored by this test.
+        For expressions that are meant to capture other data in addition to what is captured by the standard prefetch
+        queries, the warning can be ignored.
+      )
+
+      verifies_requirements 'hl7.fhir.us.davinci-crd_2.2.1@found-29'
+
+      input :cds_services
+      input :crd_discovery_service_ignore_list,
+            optional: true
+
+      ALL_HOOKS = [
+        'appointment-book',
+        'encounter-start',
+        'encounter-discharge',
+        'order-dispatch',
+        'order-select',
+        'order-sign'
+      ].freeze
+
+      def ignored_service_ids
+        crd_discovery_service_ignore_list.to_s.split(',').map(&:strip).reject(&:blank?)
+      end
+
+      def services_for_crd_validation(services)
+        services
+          .select { |service| ignored_service_ids.include?(service['id']) }
+          .each do |service|
+            info "Ignoring service `#{service['id']}` because it is in the ignore list."
+          end
+
+        services.reject { |service| ignored_service_ids.include?(service['id']) }
+      end
+
+      # rubocop:disable Layout/LineLength
+      def standard_prefetch_expressions(hook)
+        case hook
+        when 'appointment-book'
+          {
+            'patient' => 'Patient/{{context.patientId}}',
+            'encounter' => 'Encounter/{{context.encounterId}}',
+            'coverage' => 'Coverage?patient={{context.patientId}}&status=active',
+            'deviceRequests' => "DeviceRequest?_id={{context.appointments.entry.resource.basedOn.extension('http://hl7.org/fhir/StructureDefinition/alternate-reference').value.resolve().ofType(DeviceRequest).id}}",
+            'serviceRequests' => 'ServiceRequest?_id={{context.appointments.entry.resource.basedOn.resolve().ofType(ServiceRequest).id}}',
+            'medicationRequests' => "MedicationRequest?_id={{context.appointments.entry.resource.basedOn.extension('http://hl7.org/fhir/StructureDefinition/alternate-reference').value.resolve().ofType(MedicationRequest).id}}",
+            'devices' => 'Device?_id={{%deviceRequests.entry.resource.code.resolve().id}}',
+            'medications' => 'Medication?_id={{%medicationRequests.entry.resource.medication.resolve().id}}',
+            'practitionerRoles' => 'PractitionerRole?_id={{%encounter.participant.individual.resolve().ofType(PractitionerRole).id|context.appointments.entry.resource.participant.actor.resolve().ofType(PractitionerRole).id|%deviceRequests.entry.resource.performer.resolve().ofType(PractitionerRole).id|%deviceRequests.entry.resource.requester.resolve().ofType(PractitionerRole).id|%medicationRequests.entry.resource.performer.resolve().ofType(PractitionerRole).id|%medicationRequests.entry.resource.requester.resolve().ofType(PractitionerRole).id|%serviceRequests.entry.resource.performer.resolve().ofType(PractitionerRole).id|%serviceRequests.entry.resource.requester.resolve().ofType(PractitionerRole).id}}',
+            'practitioners' => 'Practitioner?_id={{%practitionerRoles.entry.resource.practitioner.resolve().id|%encounter.participant.individual.resolve().ofType(Practitioner).id|context.appointments.entry.resource.participant.actor.resolve().ofType(Practitioner).id|%deviceRequests.entry.resource.performer.resolve().ofType(Practitioner).id|%deviceRequests.entry.resource.requester.resolve().ofType(Practitioner).id|%medicationRequests.entry.resource.performer.resolve().ofType(Practitioner).id|%medicationRequests.entry.resource.requester.resolve().ofType(Practitioner).id|%serviceRequests.entry.resource.performer.resolve().ofType(Practitioner).id|%serviceRequests.entry.resource.requester.resolve().ofType(Practitioner).id}}',
+            'organizations' => 'Organization?_id={{%practitionerRoles.entry.resource.organization.resolve().id|%encounter.serviceProvider.resolve().ofType(Organization).id|%medicationRequests.entry.resource.dispenseRequest.performer.resolve().ofType(Organization).id|%serviceRequests.entry.resource.performer.resolve().ofType(Organization).id}}',
+            'locations' => 'Location?_id={{%practitionerRoles.entry.resource.location.resolve().id|%encounter.location.location.resolve().id|context.appointments.entry.resource.participant.actor.resolve().ofType(Location).id|%serviceRequests.entry.resource.locationReference.resolve().ofType(Location).id}}'
+          }
+        when 'encounter-start', 'encounter-discharge'
+          {
+            'patient' => 'Patient/{{context.patientId}}',
+            'encounter' => 'Encounter/{{context.encounterId}}',
+            'coverage' => 'Coverage?patient={{context.patientId}}&status=active',
+            'practitionerRoles' => 'PractitionerRole?_id={{%encounter.participant.individual.resolve().ofType(PractitionerRole).id}}',
+            'practitioners' => 'Practitioner?_id={{%practitionerRoles.entry.resource.practitioner.resolve().id|%encounter.participant.individual.resolve().ofType(Practitioner).id}}',
+            'organizations' => 'Organization?_id={{%practitionerRoles.entry.resource.organization.resolve().id|%encounter.serviceProvider.resolve().ofType(Organization).id}}',
+            'locations' => 'Location?_id={{%practitionerRoles.entry.resource.location.resolve().id|%encounter.location.location.resolve().id}}'
+          }
+        when 'order-dispatch'
+          {
+            'patient' => 'Patient/{{context.patientId}}',
+            'encounter' => 'Encounter/{{context.encounterId}}',
+            'coverage' => 'Coverage?patient={{context.patientId}}&status=active',
+            'communicationRequests' => 'CommunicationRequest?_id={{context.dispatchedOrders.resolve().ofType(CommunicationRequest).id}}',
+            'deviceRequests' => 'DeviceRequest?_id={{context.dispatchedOrders.resolve().ofType(DeviceRequest).id}}',
+            'medicationRequests' => 'MedicationRequest?_id={{context.dispatchedOrders.resolve().ofType(MedicationRequest).id}}',
+            'nutritionOrders' => 'NutritionOrder?_id={{context.dispatchedOrders.resolve().ofType(NutritionOrder).id}}',
+            'serviceRequests' => 'ServiceRequest?_id={{context.dispatchedOrders.resolve().ofType(ServiceRequest).id}}',
+            'visionPrescriptions' => 'VisionPrescription?_id={{context.dispatchedOrders.resolve().ofType(VisionPrescription).id}}',
+            'devices' => 'Device?_id={{%deviceRequests.entry.resource.code.resolve().id}}',
+            'medications' => 'Medication?_id={{%medicationRequests.entry.resource.medication.resolve().id}}',
+            'practitionerRoles' => 'PractitionerRole?_id={{%encounter.participant.individual.resolve().ofType(PractitionerRole).id|%communicationRequests.entry.resource.sender.resolve().ofType(PractitionerRole).id|%communicationRequests.entry.resource.recipient.resolve().ofType(PractitionerRole).id|%communicationRequests.entry.resource.requester.resolve().ofType(PractitionerRole).id|%deviceRequests.entry.resource.performer.resolve().ofType(PractitionerRole).id|%deviceRequests.entry.resource.requester.resolve().ofType(PractitionerRole).id|%medicationRequests.entry.resource.performer.resolve().ofType(PractitionerRole).id|%medicationRequests.entry.resource.requester.resolve().ofType(PractitionerRole).id|%serviceRequests.entry.resource.performer.resolve().ofType(PractitionerRole).id|%serviceRequests.entry.resource.requester.resolve().ofType(PractitionerRole).id|%nutritionOrders.entry.resource.orderer.resolve().ofType(PractitionerRole).id|%visionPrescriptions.entry.resource.prescriber.resolve().ofType(PractitionerRole).id}}',
+            'practitioners' => 'Practitioner?_id={{%practitionerRoles.entry.resource.practitioner.resolve().id|%encounter.participant.individual.resolve().ofType(Practitioner).id|%communicationRequests.entry.resource.sender.resolve().ofType(Practitioner).id|%communicationRequests.entry.resource.recipient.resolve().ofType(Practitioner).id|%communicationRequests.entry.resource.requester.resolve().ofType(Practitioner).id|%deviceRequests.entry.resource.performer.resolve().ofType(Practitioner).id|%deviceRequests.entry.resource.requester.resolve().ofType(Practitioner).id|%medicationRequests.entry.resource.performer.resolve().ofType(Practitioner).id|%medicationRequests.entry.resource.requester.resolve().ofType(Practitioner).id|%serviceRequests.entry.resource.performer.resolve().ofType(Practitioner).id|%serviceRequests.entry.resource.requester.resolve().ofType(Practitioner).id|%nutritionOrders.entry.resource.orderer.resolve().ofType(Practitioner).id|%visionPrescriptions.entry.resource.prescriber.resolve().ofType(Practitioner).id}}',
+            'organizations' => 'Organization?_id={{%practitionerRoles.entry.resource.organization.resolve().id|%encounter.serviceProvider.resolve().ofType(Organization).id|%communicationRequests.entry.resource.recipient.resolve().ofType(Organization).id|%communicationRequests.entry.resource.sender.resolve().ofType(Organization).id|%medicationRequests.entry.resource.dispenseRequest.performer.resolve().id|%serviceRequests.entry.resource.performer.resolve().ofType(Organization).id}}',
+            'locations' => 'Location?_id={{%practitionerRoles.entry.resource.location.resolve().id|%encounter.location.location.resolve().id|%serviceRequests.entry.resource.locationReference.resolve().id}}'
+          }
+        when 'order-select', 'order-sign'
+          {
+            'patient' => 'Patient/{{context.patientId}}',
+            'encounter' => 'Encounter/{{context.encounterId}}',
+            'coverage' => 'Coverage?patient={{context.patientId}}&status=active',
+            'devices' => 'Device?_id={{context.draftOrders.entry.resource.ofType(DeviceRequest).code.resolve().id}}',
+            'medications' => 'Medication?_id={{context.draftOrders.entry.resource.ofType(MedicationRequest).medication.resolve().id}}',
+            'practitionerRoles' => 'PractitionerRole?_id={{%encounter.participant.individual.resolve().ofType(PractitionerRole).id|context.draftOrders.entry.resource.sender.resolve().ofType(PractitionerRole).id|context.draftOrders.entry.resource.recipient.resolve().ofType(PractitionerRole).id|context.draftOrders.entry.resource.requester.resolve().ofType(PractitionerRole).id|context.draftOrders.entry.resource.performer.resolve().ofType(PractitionerRole).id|context.draftOrders.entry.resource.orderer.resolve().ofType(PractitionerRole).id|context.draftOrders.entry.resource.prescriber.resolve().ofType(PractitionerRole).id}}',
+            'practitioners' => 'Practitioner?_id={{%practitionerRoles.entry.resource.practitioner.resolve().id|%encounter.participant.individual.resolve().ofType(Practitioner).id|context.draftOrders.entry.resource.sender.resolve().ofType(Practitioner).id|context.draftOrders.entry.resource.recipient.resolve().ofType(Practitioner).id|context.draftOrders.entry.resource.requester.resolve().ofType(Practitioner).id|context.draftOrders.entry.resource.performer.resolve().ofType(Practitioner).id|context.draftOrders.entry.resource.orderer.resolve().ofType(Practitioner).id|context.draftOrders.entry.resource.prescriber.resolve().ofType(Practitioner).id}}',
+            'organizations' => 'Organization?_id={{%practitionerRoles.entry.resource.organization.resolve().id|%encounter.serviceProvider.resolve().ofType(Organization).id|context.draftOrders.entry.resource.dispenseRequest.performer.resolve().id|context.draftOrders.entry.resource.sender.resolve().ofType(Organization).id|context.draftOrders.entry.resource.recipient.resolve().ofType(Organization).id|context.draftOrders.entry.resource.performer.resolve().ofType(Organization).id}}',
+            'locations' => 'Location?_id={{%practitionerRoles.entry.resource.location.resolve().id|%encounter.location.location.resolve().id|context.draftOrders.entry.resource.locationReference.resolve().id}}'
+          }
+        end
+      end
+      # rubocop:enable Layout/LineLength
+
+      # The IG examples contain FHIRPath alternatives separated by `|`, and CDS Hooks prefetch field names can vary.
+      # Build a canonical signature so alternative ordering and `%prefetchKey` names do not affect matching.
+      def expression_signature(expression)
+        expression = expression.to_s
+        # CRD's standard expressions use one `{{...}}` token; split that token into its surrounding request string.
+        match = expression.match(/\A(.*?)\{\{(.*)\}\}(.*)\z/)
+        return expression unless match
+
+        prefix, fhirpath_expression, suffix = match.captures
+        alternatives =
+          fhirpath_expression
+            .split('|')
+            .map { |alternative| alternative.gsub(/%[A-Za-z][A-Za-z0-9_-]*/, '%prefetch') }
+            .uniq
+            .sort
+
+        [prefix, alternatives, suffix]
+      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.'
+
+        prefetch_services =
+          services_for_crd_validation(services)
+            .select { |service| service['prefetch'].is_a?(Hash) && service['prefetch'].present? }
+
+        skip_if prefetch_services.blank?, 'No CRD services advertised prefetch support'
+
+        prefetch_services.each do |service|
+          next unless ALL_HOOKS.include?(service['hook'])
+
+          standard_expression_signatures =
+            standard_prefetch_expressions(service['hook']).values.map { |expression| expression_signature(expression) }
+
+          service['prefetch'].each do |prefetch_key, prefetch_value|
+            next if standard_expression_signatures.include?(expression_signature(prefetch_value))
+
+            msg = "Service `#{service['id']}` advertises prefetch expression `#{prefetch_value}` " \
+                  "for hook `#{service['hook']}` in prefetch field `#{prefetch_key}`, which does not match " \
+                  'one of the standard CRD prefetch expressions for that hook.'
+            add_message('warning', msg)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/davinci_crd_test_kit/server/v2.2.1/interaction/server_invoke_hook_single_request_test.rb

@@ -0,0 +1,22 @@
+require_relative '../server_urls'
+require_relative '../../jobs/invoke_hook_no_special_requests'
+require_relative '../../server_abstract_invoke_hook_test'
+
+module DaVinciCRDTestKit
+  module V221
+    class InvokeHookSingleTest < ServerAbstractInvokeHookTest
+      include ServerURLs
+
+      title 'Inferno invokes the selected hook with the provided request body'
+      id :crd_v221_server_invoke_hook_single_request_test
+
+      def perform_invoke_hook_job(*)
+        Inferno::Jobs.perform(DaVinciCRDTestKit::Jobs::InvokeHookNoSpecialRequests, *)
+      end
+
+      def check_request_length(payloads)
+        skip_if payloads.length != 1, 'This test supports only one request body.'
+      end
+    end
+  end
+end

data/lib/davinci_crd_test_kit/server/v2.2.1/interaction/server_invoke_hook_test.rb

@@ -0,0 +1,17 @@
+require_relative '../server_urls'
+require_relative '../../server_abstract_invoke_hook_test'
+
+module DaVinciCRDTestKit
+  module V221
+    class ServerInvokeHookTest < ServerAbstractInvokeHookTest
+      include ServerURLs
+
+      title 'Inferno invokes the selected hook'
+      id :crd_v221_server_invoke_hook_test
+
+      def coverage_info_configuration_supported?
+        true
+      end
+    end
+  end
+end