davinci_crd_test_kit 0.12.2 → 0.14.0

data/lib/davinci_crd_test_kit/client/v2.2.1/crd_client_suite.rb

@@ -0,0 +1,229 @@
+require_relative 'client_fhir_api_group'
+require_relative 'client_hooks_group'
+require_relative 'client_cross_hook_group'
+require_relative 'client_registration_group'
+require_relative 'client_long_running_hook_group'
+require_relative '../endpoints/cds_services_discovery_handler'
+require_relative '../../cross_suite/tags'
+require_relative 'client_urls'
+require_relative '../crd_client_options'
+require_relative '../endpoints/hook_request_endpoint'
+require_relative '../../ext/inferno_core/runnable'
+require 'us_core_test_kit/generated/v3.1.1/us_core_test_suite'
+require 'us_core_test_kit/generated/v6.1.0/us_core_test_suite'
+require 'us_core_test_kit/generated/v7.0.0/us_core_test_suite'
+
+module DaVinciCRDTestKit
+  module V221
+    class CRDClientSuite < Inferno::TestSuite
+      id :crd_client_v221
+      title 'Da Vinci CRD Client v2.2.1 Test Suite'
+      description <<~DESCRIPTION
+        The Da Vinci CRD Client v2.2.1 Test Suite tests the conformance of systems to the
+        capabilities of a CRD client as described in [version 2.2.1](https://hl7.org/fhir/us/davinci-crd/2.2.1)
+        of the Da Vinci Coverage Requirements Discovery (CRD) Implementation Guide.
+
+        Detailed information about this test suite can be found in the
+        [client section](https://github.com/inferno-framework/davinci-crd-test-kit/wiki/Client-Details) of the
+        [CRD Test Kit Wiki](https://github.com/inferno-framework/davinci-crd-test-kit/wiki), including:
+        - [What testers need to successfully execute these tests](https://github.com/inferno-framework/davinci-crd-test-kit/wiki/Client-Instructions-v2.2.1#pre-execution-setup-and-required-information),
+        - [Minimal](https://github.com/inferno-framework/davinci-crd-test-kit/wiki/Client-Instructions-v2.2.1#quick-start)
+          and [complete](https://github.com/inferno-framework/davinci-crd-test-kit/wiki/Client-Instructions-v2.2.1#additional-testing-options)
+          instructions for executing against a client system, and
+        - How to [interpret test results](https://github.com/inferno-framework/davinci-crd-test-kit/wiki/Client-Instructions-v2.2.1#interpreting-results).
+      DESCRIPTION
+
+      suite_summary <<~SUMMARY
+        The Da Vinci CRD Client v2.2.1 Test Suite tests the conformance of client systems
+        to [version 2.2.1 of the Da Vinci Coverage Requirements Discovery (CRD)
+        Implementation Guide](https://hl7.org/fhir/us/davinci-crd/2.2.1).
+      SUMMARY
+
+      links [
+        {
+          label: 'Implementation Guide',
+          url: 'https://hl7.org/fhir/us/davinci-crd/2.2.1'
+        },
+        {
+          label: 'Report Issue',
+          url: 'https://github.com/inferno-framework/davinci-crd-test-kit/issues'
+        },
+        {
+          label: 'Open Source',
+          url: 'https://github.com/inferno-framework/davinci-crd-test-kit'
+        },
+        {
+          label: 'Download',
+          url: 'https://github.com/inferno-framework/davinci-crd-test-kit/releases'
+        }
+      ]
+
+      requirement_sets(
+        {
+          identifier: 'hl7.fhir.us.davinci-crd_2.2.1',
+          title: 'Da Vinci Coverage Requirements Discovery (CRD) v2.2.1',
+          actor: 'CRD Client'
+        },
+        {
+          identifier: 'cds-hooks_3.0.0-ballot',
+          title: 'CDS Hooks 3.0.0-ballot',
+          actor: 'Client'
+        },
+        {
+          identifier: 'cds-hooks-library_1.0.1',
+          title: 'CDS Hooks Library',
+          actor: 'Client',
+          requirements: 'referenced'
+        },
+        {
+          identifier: 'hl7.fhir.us.core_3.1.1',
+          title: 'US Core Implementation Guide v3.1.1',
+          actor: 'Server',
+          suite_options: {
+            us_core_version: CRDClientOptions::US_CORE_3
+          }
+        },
+        {
+          identifier: 'hl7.fhir.us.core_6.1.0',
+          title: 'US Core Implementation Guide v6.1.0',
+          actor: 'Server',
+          suite_options: {
+            us_core_version: CRDClientOptions::US_CORE_6
+          }
+        },
+        {
+          identifier: 'hl7.fhir.us.core_7.0.0',
+          title: 'US Core Implementation Guide v7.0.0',
+          actor: 'Server',
+          suite_options: {
+            us_core_version: CRDClientOptions::US_CORE_7
+          }
+        }
+      )
+
+      verifies_requirements 'cds-hooks_3.0.0-ballot@1', # use of json for everything verified across the whole suite
+                            'cds-hooks_3.0.0-ballot@15', # use of POST verified by suite endpoint setup
+                            'cds-hooks_3.0.0-ballot@208', # use of CORS endpoints defined in the suite
+                            'hl7.fhir.us.davinci-crd_2.2.1@impl-3' # suite verifies system interactions
+
+      CRD_MESSAGE_FILTERS = [
+        /\A\S+: \S+: URL value '.*' does not resolve/,
+        %r{This element is not allowed by the profile http://hl7\.org/fhir/tools/StructureDefinition/CDSHooksExtensions\|1\.1\.2},
+        /CDSHooksRequest.extension: Unrecognized property/,
+        /No definition could be found for URL value/
+      ].freeze
+
+      US_CORE_3_MESSAGE_FILTERS = CRD_MESSAGE_FILTERS +
+                                  USCoreTestKit::USCoreV311::USCoreTestSuite::VALIDATION_MESSAGE_FILTERS
+
+      US_CORE_6_MESSAGE_FILTERS = CRD_MESSAGE_FILTERS +
+                                  USCoreTestKit::USCoreV610::USCoreTestSuite::VALIDATION_MESSAGE_FILTERS
+
+      US_CORE_7_MESSAGE_FILTERS = CRD_MESSAGE_FILTERS +
+                                  USCoreTestKit::USCoreV700::USCoreTestSuite::VALIDATION_MESSAGE_FILTERS
+
+      fhir_resource_validator required_suite_options: { us_core_version: CRDClientOptions::US_CORE_3 } do
+        igs('hl7.fhir.us.davinci-crd#2.2.1')
+
+        validation_context do
+          snomedCT '731000124108' # explicit snomedCT expansion parameter
+        end
+
+        exclude_message do |message|
+          US_CORE_3_MESSAGE_FILTERS.any? { |match_template| message.message.match?(match_template) }
+        end
+      end
+
+      fhir_resource_validator required_suite_options: { us_core_version: CRDClientOptions::US_CORE_6 } do
+        igs('hl7.fhir.us.davinci-crd#2.2.1')
+
+        validation_context do
+          snomedCT '731000124108' # explicit snomedCT expansion parameter
+        end
+
+        exclude_message do |message|
+          US_CORE_6_MESSAGE_FILTERS.any? do |match_template|
+            message.message.match?(match_template)
+          end
+        end
+      end
+
+      fhir_resource_validator required_suite_options: { us_core_version: CRDClientOptions::US_CORE_7 } do
+        igs('hl7.fhir.us.davinci-crd#2.2.1')
+
+        validation_context do
+          snomedCT '731000124108' # explicit snomedCT expansion parameter
+        end
+
+        exclude_message do |message|
+          US_CORE_7_MESSAGE_FILTERS.any? do |match_template|
+            message.message.match?(match_template)
+          end
+        end
+      end
+
+      suite_option :us_core_version,
+                   title: 'US Core Version',
+                   list_options: [
+                     {
+                       label: 'US Core 3.1.1',
+                       value: CRDClientOptions::US_CORE_3
+                     },
+                     {
+                       label: 'US Core 6.1.0',
+                       value: CRDClientOptions::US_CORE_6
+                     },
+                     {
+                       label: 'US Core 7.0.0',
+                       value: CRDClientOptions::US_CORE_7
+                     }
+                   ]
+
+      def self.extract_token_from_query_params(request)
+        request.query_parameters['token']
+      end
+
+      route :get, DISCOVERY_PATH, CDSServicesDiscoveryHandler
+      route :get, PREFETCH_DISCOVERY_PATH, CDSServicesDiscoveryHandler
+
+      allow_cors APPOINTMENT_BOOK_PATH, ENCOUNTER_START_PATH, ENCOUNTER_DISCHARGE_PATH, ORDER_DISPATCH_PATH,
+                 ORDER_SELECT_PATH, ORDER_SIGN_PATH, DISCOVERY_PATH
+      suite_endpoint :post, APPOINTMENT_BOOK_PATH, HookRequestEndpoint
+      suite_endpoint :post, ENCOUNTER_START_PATH, HookRequestEndpoint
+      suite_endpoint :post, ENCOUNTER_DISCHARGE_PATH, HookRequestEndpoint
+      suite_endpoint :post, ORDER_DISPATCH_PATH, HookRequestEndpoint
+      suite_endpoint :post, ORDER_SELECT_PATH, HookRequestEndpoint
+      suite_endpoint :post, ORDER_SIGN_PATH, HookRequestEndpoint
+
+      allow_cors APPOINTMENT_BOOK_PREFETCH_SUBSET_PATH, ENCOUNTER_START_PREFETCH_SUBSET_PATH,
+                 ENCOUNTER_DISCHARGE_PREFETCH_SUBSET_PATH, ORDER_DISPATCH_PREFETCH_SUBSET_PATH,
+                 ORDER_SELECT_PREFETCH_SUBSET_PATH, ORDER_SIGN_PREFETCH_SUBSET_PATH,
+                 PREFETCH_DISCOVERY_PATH
+      suite_endpoint :post, APPOINTMENT_BOOK_PREFETCH_SUBSET_PATH, HookRequestEndpoint
+      suite_endpoint :post, ENCOUNTER_START_PREFETCH_SUBSET_PATH, HookRequestEndpoint
+      suite_endpoint :post, ENCOUNTER_DISCHARGE_PREFETCH_SUBSET_PATH, HookRequestEndpoint
+      suite_endpoint :post, ORDER_DISPATCH_PREFETCH_SUBSET_PATH, HookRequestEndpoint
+      suite_endpoint :post, ORDER_SELECT_PREFETCH_SUBSET_PATH, HookRequestEndpoint
+      suite_endpoint :post, ORDER_SIGN_PREFETCH_SUBSET_PATH, HookRequestEndpoint
+
+      resume_test_route :get, RESUME_PASS_PATH do |request|
+        CRDClientSuite.extract_token_from_query_params(request)
+      end
+      resume_test_route :get, RESUME_FAIL_PATH, result: 'fail' do |request|
+        CRDClientSuite.extract_token_from_query_params(request)
+      end
+
+      group do
+        id :crd_v221_client_hook_invocation
+        title 'Hook Invocation'
+
+        group from: :crd_v221_client_registration
+        group from: :crd_v221_client_hooks
+        group from: :crd_v221_client_cross_hook
+        group from: :crd_v221_client_long_running_hook
+      end
+
+      group from: :crd_v221_client_fhir_api
+    end
+  end
+end

data/lib/davinci_crd_test_kit/client/v2.2.1/cross_hook/client_card_must_support_coverage_information_test.rb

@@ -0,0 +1,63 @@
+require_relative '../../../cross_suite/cards_identification'
+require_relative '../../tagged_request_load_helper'
+
+module DaVinciCRDTestKit
+  module V221
+    class ClientCardMustSupportCoverageInformationTest < Inferno::Test
+      include CardsIdentification
+      include TaggedRequestLoadHelper
+
+      title 'Client supports the Coverage Information response type'
+      id :crd_v221_client_card_must_support_coverage_information
+      description <<~DESCRIPTION
+        During this test, Inferno will verify that the client demonstrated support for the [Coverage Information](https://hl7.org/fhir/us/davinci-crd/2.2.1/en/cards.html#coverage-information)
+        response type for this hook. At least one hook invocation received during this group must have returned a Coverage Information action.
+        Additionally, all [coverage-information extension](https://hl7.org/fhir/us/davinci-crd/2.2.1/en/StructureDefinition-ext-coverage-information.html)
+        must support elements must be demonstrated across all the returned actions.
+
+        If this test fails, adjust the [cards returned by Inferno's simulated CRD server](https://github.com/inferno-framework/davinci-crd-test-kit/wiki/Controlling-Simulated-Responses)
+        and/or the hook requests made by the client during the Hooks tests such that Coverage Information actions are returned
+        that cover the full scope of the [coverage-information extension](https://hl7.org/fhir/us/davinci-crd/2.2.1/en/StructureDefinition-ext-coverage-information.html)
+        and support for them is demonstrated.
+      DESCRIPTION
+
+      verifies_requirements 'hl7.fhir.us.davinci-crd_2.2.1@resp-14'
+
+      def metadata
+        @metadata ||= YAML.load_file(
+          File.join(__dir__, '..', '..', '..', 'cross_suite', 'coverage-information_stu221_metadata.yml')
+        )
+      end
+
+      class MustSupportMetadataHolder
+        attr_accessor :metadata
+
+        def initialize(metadata)
+          self.metadata = metadata
+        end
+
+        def must_supports
+          @must_supports ||= {
+            extensions: metadata[:must_supports][:extensions] || [],
+            slices: metadata[:must_supports][:slices] || [],
+            elements: metadata[:must_supports][:elements] || []
+          }
+        end
+      end
+
+      run do
+        loaded_requests = requests_to_analyze
+        skip_if loaded_requests.blank?, 'No hook requests received.'
+
+        sorted_cards = sorted_cards_from_requests(loaded_requests)
+
+        assert sorted_cards['actions'][COVERAGE_INFORMATION_RESPONSE_TYPE].present?,
+               'Support for the Coverage Information response type not demonstrated.'
+
+        coverage_information_extensions = extract_coverage_information_extensions(sorted_cards)
+        assert_must_support_elements_present(coverage_information_extensions, COVERAGE_INFO_EXT_URL,
+                                             metadata: MustSupportMetadataHolder.new(metadata))
+      end
+    end
+  end
+end

data/lib/davinci_crd_test_kit/client/v2.2.1/cross_hook/client_fhirpath_collection_as_comma_delimited_string_test.rb

@@ -0,0 +1,60 @@
+module DaVinciCRDTestKit
+  module V221
+    class ClientFHIRPathCollectionAsCommaDelimitedStringTest < Inferno::Test
+      title 'Client correctly interprets collections when substituting FHIRPath results in prefetch templates'
+      id :crd_v221_client_fhir_path_collection_as_comma_delimited_string
+      description <<~DESCRIPTION
+        The CDS Hooks specification requires that when a FHIRPath token in A
+        prefetch template resolves to a collection of datatypes (e.g., resource ids),
+        then the collection gets turned into a comma-delimited string when instantiating
+        the prefetch template.
+
+        During this test, Inferno will verify that during a previously-run hook test,
+        there was at least one instance of a prefetch template that has a
+        token which Inferno expects to result in a collection with multiple unique members.
+        Note that this does not test whether the client correctly
+        handles the collection, which is checked by the
+        "Hook requests include the requested prefetch data" test.
+
+        This test relies on the evaluation performed by the "Hook requests include the
+        requested prefetch data" test present in each hook-specific "Requests" group. One of these groups
+        must have been run and resulted in a "Hook requests include the requested prefetch data"
+        test that outputs "demonstrates_fhirpath_collection_as_comma_delimited_string" as true.
+      DESCRIPTION
+
+      verifies_requirements 'cds-hooks_3.0.0-ballot@239', 'cds-hooks_3.0.0-ballot@242'
+
+      run do
+        completeness_tests = find_completeness_tests
+        pass_if completeness_tests_demonstrate_collection_token_substitution?(completeness_tests)
+
+        skip 'No prefetch template requiring FHIRPath collection token substitution demonstrated. ' \
+             'Perform more complex hook requests and re-run.'
+      end
+
+      def find_completeness_tests
+        hooks_group = self.class.parent.parent.groups.find do |group|
+          group.id.to_s.include?('crd_v221_client_hooks')
+        end
+        hooks_group.groups.map do |group|
+          group.groups.flat_map(&:tests).find do |test|
+            test.id.to_s.include?('crd_v221_hook_request_prefetch_complete')
+          end
+        end.compact
+      end
+
+      def completeness_tests_demonstrate_collection_token_substitution?(prefetch_completeness_tests)
+        results_repo = Inferno::Repositories::Results.new
+        results = results_repo.current_results_for_test_session_and_runnables(test_session_id,
+                                                                              prefetch_completeness_tests)
+
+        results.any? do |result|
+          result.outputs.any? do |output|
+            output['name'] == 'demonstrates_fhirpath_collection_as_comma_delimited_string' &&
+              output['value'] == 'true'
+          end
+        end
+      end
+    end
+  end
+end

data/lib/davinci_crd_test_kit/client/v2.2.1/cross_hook/client_hook_instances_unique_test.rb

@@ -0,0 +1,45 @@
+require_relative '../../tagged_request_load_helper'
+require_relative '../../multi_request_message_helper'
+require_relative '../../../cross_suite/tags'
+
+module DaVinciCRDTestKit
+  module V221
+    class ClientHookInstancesUniqueTest < Inferno::Test
+      include TaggedRequestLoadHelper
+      include MultiRequestMessageHelper
+
+      title 'Client does not reuse hookInstance values'
+      id :crd_v221_client_hook_instances_unique
+      description <<~DESCRIPTION
+        The CDS Hooks specification requires that the `hookInstance` field of each hook
+        request be globally unique so that it can be used for tracking
+        and auditing.
+
+        During this test, Inferno will check that across all hook invocations performed during these
+        tests, the `hookInstance` field was never reused.
+      DESCRIPTION
+
+      verifies_requirements 'cds-hooks_3.0.0-ballot@25'
+
+      config(
+        options: {
+          crd_test_group: DUPLICATED_HOOK_INSTANCE_TAG
+        }
+      )
+
+      run do
+        duplicated_hook_instance_requests = load_hook_requests
+        reused_values = duplicated_hook_instance_requests.map.with_index do |request, request_index|
+          request_body = parse_json_request_entity(request.request_body, 'Request body', request_index)
+          next nil unless request_body.present?
+
+          request_body['hookInstance']
+        end.compact.uniq
+        reused_values.each { |hook_instance| load_tagged_requests(TagMethods.hook_instance_tag(hook_instance)) }
+
+        assert duplicated_hook_instance_requests.blank?,
+               "Inferno received hook requests that re-used `hookInstance` values: #{reused_values.join(', ')}"
+      end
+    end
+  end
+end

data/lib/davinci_crd_test_kit/client/v2.2.1/cross_hook/client_location_address_propagation_test.rb

@@ -0,0 +1,135 @@
+require_relative '../../../cross_suite/tags'
+require_relative '../../tagged_request_load_helper'
+
+module DaVinciCRDTestKit
+  module V221
+    class ClientLocationAddressPropagationTest < Inferno::Test
+      include TaggedRequestLoadHelper
+
+      title 'Client propagates addresses to child Location resources'
+      id :crd_v221_client_location_address_propagation
+      description <<~DESCRIPTION
+        The CRD IG requires that ([prof-13](https://hl7.org/fhir/us/davinci-crd/2.2.1/en/StructureDefinition-profile-location.html#ci-c-prof-13))
+        > If a Location is a fine-grained location such as a bed or room,
+        > the address SHALL be propagated from the higher-level location it is part of.
+
+        During this test, Inferno will verify that for all locations provided as a prefetched resource
+        and their parents (via the `partOf` element), if the Location has a parent Location (`partOf`) and
+        that parent Location's `address` element is populated, then the child Location's `address` element
+        must also be populated. The test will not verify the details of the address because Inferno cannot
+        easily determine whether a particular location is "fine-grained" so as to need the same address.
+        By requiring just population, this check allows for refinement of the address in the child
+        in addition to straight propagation.
+      DESCRIPTION
+
+      verifies_requirements 'hl7.fhir.us.davinci-crd_2.2.1@prof-13'
+
+      run do
+        skip_if loaded_requests.blank?, 'No hook requests received.'
+        pass_if prefetched_location_hash.blank?, 'No Location resources in use, so verification not needed.'
+
+        prefetched_location_hash.each_value do |location|
+          check_location_address_propagation(location)
+        end
+
+        assert_no_error_messages('Address propagation issues found. See Messages for details.')
+      end
+
+      # checks that the location has an address if a parent also has an address
+      def check_location_address_propagation(location, root_id = location.id)
+        return if location.address.present?
+        return unless location.partOf.present? && location.partOf.reference.present?
+
+        parent = prefetched_location_hash[location.partOf.reference]
+        parent = fetched_location_hash[location.partOf.reference] unless parent.present?
+        if parent.present?
+          check_location_conformance(parent, root_id)
+          if parent.address.present?
+            add_message('error', "Address missing on prefetched 'Location/#{root_id}': " \
+                                 "parent 'Location/#{parent.id}' has an address.")
+          else
+            check_location_address_propagation(parent, root_id)
+          end
+        else
+          add_message('error', "Unable to check address propagation prefetched 'Location/#{root_id}': " \
+                               "`partOf` reference '#{location.partOf.reference}' could not be fetched.")
+        end
+
+        nil
+      end
+
+      # skip profile check if in the prefetch hash (done elsewhere) or already checked
+      def check_location_conformance(location, root_id)
+        key = "Location/#{location.id}"
+        return if prefetched_location_hash.key?(key) || fetched_locations_checked_for_conformance.key?(key)
+
+        fetched_locations_checked_for_conformance[key] = location
+        validator_response_details = []
+        return if resource_is_valid?(resource: location, profile_url: 'http://hl7.org/fhir/us/davinci-crd/StructureDefinition/profile-location|2.2.1',
+                                     add_messages_to_runnable: false, validator_response_details:)
+
+        message_prefix = "Parent of prefetched 'Location/#{root_id}'"
+        add_message('error', "Location/#{location.id}: #{message_prefix} does not conform to the CRD Location profile.")
+        validator_response_details.each { |issue| add_message(issue.severity, "(#{message_prefix}) #{issue.message}") }
+      end
+
+      def fetched_locations_checked_for_conformance
+        @fetched_locations_checked_for_conformance ||= {}
+      end
+
+      def loaded_requests
+        @loaded_requests ||= requests_to_analyze
+      end
+
+      def prefetched_location_hash
+        @prefetched_location_hash ||= build_prefetched_locations_hash
+      end
+
+      def build_prefetched_locations_hash
+        loaded_requests.each_with_object({}) do |request, location_hash|
+          request_body = JSON.parse(request.request_body)
+          next unless request_body.is_a?(Hash)
+
+          prefetched_location_bundle = extract_prefetched_location_bundle(request_body)
+          next unless prefetched_location_bundle.present?
+
+          prefetched_location_bundle.entry.each do |entry|
+            add_location_to_hash(entry.resource, location_hash)
+          end
+        rescue JSON::ParserError
+          next
+        end
+      end
+
+      def extract_prefetched_location_bundle(request_body)
+        locations_data = request_body.dig('prefetch', 'locations') || request_body.dig('prefetch', 'locs')
+        locations = FHIR.from_contents(locations_data.to_json) if locations_data.present?
+        return locations if locations.is_a?(FHIR::Bundle)
+        return nil unless locations.is_a?(FHIR::Location)
+
+        FHIR::Bundle.new({ entry: [FHIR::Bundle::Entry.new({ resource: locations })] })
+      end
+
+      def fetched_location_hash
+        @fetched_location_hash ||= build_fetched_locations_hash
+      end
+
+      def build_fetched_locations_hash
+        load_tagged_requests(PARENT_LOCATION_FETCH_TAG, DATA_FETCH_TAG).each_with_object({}) do |request, location_hash|
+          add_location_to_hash(FHIR.from_contents(request.response_body), location_hash)
+        rescue JSON::ParserError
+          next
+        end
+      end
+
+      def add_location_to_hash(location, location_hash)
+        return unless location.is_a?(FHIR::Location) && location.id.present?
+
+        relative_reference = "#{location.resourceType}/#{location.id}"
+        return if location_hash.key?(relative_reference)
+
+        location_hash[relative_reference] = location
+      end
+    end
+  end
+end

data/lib/davinci_crd_test_kit/client/v2.2.1/cross_hook/client_prefetch_complete_and_subset_test.rb

@@ -0,0 +1,103 @@
+require_relative '../../tagged_request_load_helper'
+require_relative '../client_urls'
+
+module DaVinciCRDTestKit
+  module V221
+    class ClientPrefetchCompleteAndSubsetTest < Inferno::Test
+      include TaggedRequestLoadHelper
+
+      title 'Client can provide both the complete standard prefetch data set and a subset'
+      id :crd_v221_client_prefetch_complete_and_subset
+      description <<~DESCRIPTION
+        The CRD IG requires clients to be able to prefetch a standard set of resources that
+        payers are expected to need to evaluate coverage requirements. They are also
+        required to be able to prefetch a subset of these standard prefetch requirements
+        if a payer requests fewer in their service discovery responses because the payer
+        does not always need the complete set of standard prefetch resources to evaluate
+        coverage.
+
+        During this test, Inferno will verify that the client has demonstrated requests
+        - made against both of Inferno's simulated CRD servers,
+          one of which requests the all standard prefetch resources while the
+          other requests only a subset.
+        - which demonstrate the capability to distinguish the difference between
+          the two prefetch sets.
+
+        The CRD server that requests only a subset of the standard prefetch data does not request
+        resources referenced from the following elements. Request made to each Inferno service
+        endpoint with one of these elements populated with a reference to a resource not referenced
+        elsewhere will demonstrate the required capability.
+          - On an `appointment-book` hook request, an Appointment with a participant entry that
+            references a Practitioner or PractitionerRole resource in its actor element
+          - On an `encounter-start` or `encounter-discharge` hook request, an Encounter with a
+            referenced Location via the `location` element or referenced Organization via the
+            `serviceProvider` element.
+          - On an `order-select`, `order-sign`, or `order-dispatch` hook request, one of the following order resources:
+            - A CommunicationRequest, DeviceRequest, MedicationRequest, or ServiceRequest that references a Practitioner or PractitionerRole resource in its `requester` element, or
+            - A NutritionOrder that references a Practitioner or PractitionerRole resource in its `orderer` element
+            - A VisionPrescription that references a Practitioner or PractitionerRole resource in its `prescriber` element
+
+        This test relies on the evaluation performed by the "Hook requests include the
+        requested prefetch data" tests present in each hook-specific "Requests" group. One of these groups must
+        have been run and resulted in a "Hook requests include the
+        requested prefetch data" test that outputs
+        "demonstrates_prefetch_subset_distinct_from_complete" and
+        "demonstrates_prefetch_complete_distinct_from_subset" as true (does not have to be the
+        same test).
+      DESCRIPTION
+
+      verifies_requirements 'hl7.fhir.us.davinci-crd_2.2.1@found-25-A', 'hl7.fhir.us.davinci-crd_2.2.1@found-25-B'
+
+      run do
+        subset_prefetch_requests, complete_prefetch_requests =
+          requests_to_analyze.partition { |request| request.url.include?(PREFETCH_SUBSET_PREFIX) }
+        completeness_tests = find_completeness_tests
+        check_for_demonstration(subset_prefetch_requests, completeness_tests, :subset)
+        check_for_demonstration(complete_prefetch_requests, completeness_tests, :complete)
+
+        skip_if error_messages?,
+                'The client did not demonstrate both complete and subset prefetch capability. See Messages for details.'
+      end
+
+      def find_completeness_tests
+        hooks_group = self.class.parent.parent.groups.find do |group|
+          group.id.to_s.include?('crd_v221_client_hooks')
+        end
+        hooks_group.groups.map do |group|
+          group.groups.flat_map(&:tests).find do |test|
+            test.id.to_s.include?('crd_v221_hook_request_prefetch_complete')
+          end
+        end.compact
+      end
+
+      def check_for_demonstration(requests, completeness_tests, target_name)
+        unless requests.present?
+          add_message('error', "No requests made to the service endpoint requesting #{target_name} prefetch data.")
+          return
+        end
+
+        results_repo = Inferno::Repositories::Results.new
+        results = results_repo.current_results_for_test_session_and_runnables(test_session_id,
+                                                                              completeness_tests)
+        output_name =
+          if target_name == :subset
+            'demonstrates_prefetch_subset_distinct_from_complete'
+          else
+            'demonstrates_prefetch_complete_distinct_from_subset'
+          end
+
+        demonstrated = results.any? do |result|
+          result.outputs.any? do |output|
+            output['name'] == output_name &&
+              output['value'] == 'true'
+          end
+        end
+
+        return if demonstrated
+
+        add_message('error', "Requests made to the service endpoint requesting #{target_name} prefetch data " \
+                             'did not demonstrate a difference between the two levels of prefetch data.')
+      end
+    end
+  end
+end