davinci_crd_test_kit 0.13.0 → 0.14.0

data/lib/davinci_crd_test_kit/client/v2.0.1/verify_request/hook_request_prefetch_equals_queried_test.rb

@@ -0,0 +1,96 @@
+require_relative '../../../cross_suite/prefetch_contents_validation'
+
+module DaVinciCRDTestKit
+  module V201
+    class HookRequestPrefetchEqualsQueriedTest < Inferno::Test
+      include PrefetchContentsValidation
+
+      id :crd_v201_hook_request_prefetch_equals_queried
+      title 'Prefetched data is equivalent to queried data'
+      description %(
+        This test verifies that each key present in the incoming hook request's `prefetch` field is equivalent to the
+        data returned by a query to the fhir server using the parameterized prefetch template.
+
+        The queries will be performed after the hook response has been returned.
+      )
+      verifies_requirements 'cds-hooks_2.0@45'
+
+      input :client_fhir_server,
+            optional: true
+      input :client_access_token,
+            optional: true
+      input :override_access_token,
+            title: 'Prefetch Validation Override Bearer Token',
+            description: %(
+              Optionally provide a bearer token to use in place of the one provided in the hook request
+              when checking that the prefetched data is equivalent to what can be access via FHIR.
+              Use only if the bearer token in the request will not be valid even right after the hook
+              request is made. If provided it must have the same scope as the bearer token provided
+              in the hook request.
+            ),
+            optional: true
+
+      fhir_client do
+        url :client_fhir_server
+        bearer_token access_token
+      end
+
+      def access_token
+        override_access_token.present? ? override_access_token : client_access_token
+      end
+
+      def hook_name
+        config.options[:hook_name]
+      end
+
+      def crd_test_group
+        config.options[:crd_test_group]
+      end
+
+      def tags_to_load
+        crd_test_group.present? ? [hook_name, crd_test_group] : [hook_name]
+      end
+
+      def cds_services_json
+        JSON.parse(File.read(File.join(
+                               __dir__, '..', 'cds-services-v201.json'
+                             )))['services']
+      end
+
+      def advertised_prefetch_fields
+        advertised_hook_service = cds_services_json.find { |service| service['hook'] == hook_name }
+        advertised_hook_service['prefetch']
+      end
+
+      def no_error_validation(message)
+        assert messages.none? { |msg| msg[:type] == 'error' }, message
+      end
+
+      run do
+        hook_requests = load_tagged_requests(*tags_to_load)
+
+        skip_if hook_requests.blank?, 'No Hook Requests to verify.'
+
+        pass_if !prefetched_data?(hook_requests), 'No prefetched data provided.'
+
+        skip_if client_fhir_server.blank?,
+                'No FHIR server provided in the hook request to use to validate the prefetch data.'
+
+        if override_access_token.present?
+          add_message(:warning,
+                      'Override access token provided. Ensure that it has the same scope as used when ' \
+                      'prefetching data for the hook request.')
+        end
+
+        hook_requests.each_with_index do |request, index|
+          @request_number = index + 1
+          check_prefetch_data_against_query(request, advertised_prefetch_fields)
+        end
+
+        no_error_validation('Prefetched data does not match the requested queries.')
+
+        pass 'Prefetched data matches the requested queries.'
+      end
+    end
+  end
+end

data/lib/davinci_crd_test_kit/client/v2.0.1/verify_request/hook_request_required_fields_test.rb

@@ -0,0 +1,55 @@
+require_relative '../../client_hook_request_validation'
+require_relative '../client_urls'
+
+module DaVinciCRDTestKit
+  module V201
+    class HookRequestRequiredFieldsTest < Inferno::Test
+      include ClientHookRequestValidation
+      include ClientURLs
+
+      id :crd_v201_hook_request_required_fields
+      title 'Hook request contains required fields'
+      description %(
+        Under the [CDS hooks HTTP Request section](https://cds-hooks.hl7.org/2.0/#http-request_1), the specification
+        requires that a CDS service request SHALL include a JSON POST body with the following input fields:
+          * `hook` - *string*
+          * `hookInstance` - *string* containing a globally unique UUID
+          * `context` - *object*
+
+          Additionally, if the optional `fhirAuthorization` field is present, then the `fhirServer` field is required.
+
+          This test also checks that the `hook` field contains the correct CDS service name that the CDS client
+          is sending a request for
+      )
+
+      verifies_requirements 'cds-hooks_2.0@1', 'cds-hooks_2.0@18', 'cds-hooks_2.0@19',
+                            'cds-hooks_2.0@20', 'cds-hooks_2.0@22', 'cds-hooks_2.0@25'
+
+      def hook_name
+        config.options[:hook_name]
+      end
+
+      output :contexts, :prefetches
+
+      run do
+        load_tagged_requests(hook_name)
+        skip_if requests.empty?, "No #{hook_name} requests were made in a previous test as expected."
+        contexts = []
+        prefetches = []
+        requests.each_with_index do |request, index|
+          @request_number = index + 1
+          request_body = json_parse(request.request_body)
+          next if request_body.blank?
+
+          contexts << request_body['context'] if request_body['context'].is_a?(Hash)
+          prefetches << request_body['prefetch'] if request_body['prefetch'].is_a?(Hash)
+          hook_request_required_fields_check(request_body, hook_name, ig_version: 'v201')
+        end
+
+        output contexts: contexts.to_json,
+               prefetches: prefetches.to_json
+        no_error_validation('Some service requests made are not valid.')
+      end
+    end
+  end
+end

data/lib/davinci_crd_test_kit/client/v2.0.1/verify_request/hook_request_valid_context_test.rb

@@ -0,0 +1,70 @@
+require_relative '../../client_hook_request_validation'
+require_relative '../client_urls'
+
+module DaVinciCRDTestKit
+  module V201
+    class HookRequestValidContextTest < Inferno::Test
+      include ClientURLs
+      include ClientHookRequestValidation
+
+      id :crd_v201_hook_request_valid_context
+      title 'Hook request contains valid context'
+      description %(
+        As stated in the [CDS hooks specification](https://cds-hooks.hl7.org/2.0#http-request), a CDS service request's
+        `context` field contains hook-specific contextual data that the CDS service will need. The context is
+        specified in the hook definition to guide developers on the information available at the point in the
+        workflow when the hook is triggered.
+
+        The `context` requirements for each [hook specified in the CRD IG](https://hl7.org/fhir/us/davinci-crd/STU2/hooks.html)
+        can be found below:
+        * [appointment-book](https://cds-hooks.hl7.org/hooks/appointment-book/2023SepSTU1Ballot/appointment-book/)
+        * [encounter-start](https://cds-hooks.hl7.org/hooks/encounter-start/2023SepSTU1Ballot/encounter-start/)
+        * [encounter-discharge](https://cds-hooks.hl7.org/hooks/encounter-discharge/2023SepSTU1Ballot/encounter-discharge/)
+        * [order-select](https://cds-hooks.hl7.org/hooks/order-select/2023SepSTU1Ballot/order-select/)
+        * [order-dispatch](https://cds-hooks.hl7.org/hooks/order-dispatch/2023SepSTU1Ballot/order-dispatch/)
+        * [order-sign](https://cds-hooks.org/hooks/order-sign/)
+
+        This test performs the following:
+          * Verifies that the incoming hook request's `context` field contains the fields required by each hook and
+          that they are in the correct format
+          * Checks the optional fields and ensures they are in the correct format
+          * Validates any resources contained in a `context` field that contains a Bundle or FHIR resource
+          * Makes FHIR requests for any `context` fields that contain an id or reference and validates each resource
+          response against its corresponding CRD resource profile
+          * Check some specific `context` requirements for hooks that have special requirements for certain fields
+
+        The client must provide its FHIR server URL and access token in the hook request in order to run
+        this test.
+      )
+
+      input :contexts, :client_fhir_server
+      input :client_access_token,
+            optional: true
+
+      fhir_client do
+        url :client_fhir_server
+        bearer_token :client_access_token
+      end
+
+      def hook_name
+        config.options[:hook_name]
+      end
+
+      run do
+        hook_contexts = json_parse(contexts)
+        if hook_contexts
+          skip_if(hook_contexts.none?(&:present?), "No #{hook_name} requests contained the `context` field.")
+          hook_contexts.each_with_index do |context, index|
+            @request_number = index + 1
+            if context.blank?
+              add_message('error', "#{request_number}Missing required context field.")
+              next
+            end
+            hook_request_context_check(context, hook_name, ig_version: 'v201')
+          end
+        end
+        no_error_validation('Context is not valid.')
+      end
+    end
+  end
+end

data/lib/davinci_crd_test_kit/client/v2.0.1/verify_request/hook_request_valid_prefetch_test.rb

@@ -0,0 +1,62 @@
+require_relative '../../client_hook_request_validation'
+require_relative '../client_urls'
+
+module DaVinciCRDTestKit
+  module V201
+    class HookRequestValidPrefetchTest < Inferno::Test
+      include ClientHookRequestValidation
+      include ClientURLs
+
+      id :crd_v201_hook_request_valid_prefetch
+      title 'Hook request contains valid prefetched data'
+      description %(
+        As stated in the [CDS hooks specification](https://cds-hooks.hl7.org/2.0#http-request), a CDS service request's
+        `prefetch` field is an optional field that contains key/value pairs of FHIR queries that the service is
+        requesting the CDS client to perform and provide on each service call. The key is a string that describes
+        the type of data being requested and the value is a string representing the FHIR query.
+        See [Prefetch Template](https://cds-hooks.hl7.org/2.0#prefetch-template)
+        for more information about how the `prefetch` formatting works.
+
+        This test verifies that the incoming hook request's `prefetch` field is in a valid JSON format,
+        validates each contained resource against its corresponding CRD resource profile, and checks
+        that the data matches what is requested in by the
+        [prefetch templates published by Inferno's simulated CRD server](https://github.com/inferno-framework/davinci-crd-test-kit/blob/main/lib/davinci_crd_test_kit/client/v2.0.1/cds-services-v201.json).
+        Since prefetch support is not required, this test will pass if `prefetch` is not present or has no entries.
+      )
+      verifies_requirements 'hl7.fhir.us.davinci-crd_2.0.1@54', 'cds-hooks_2.0@30', 'cds-hooks_2.0@47'
+
+      input :contexts, :prefetches
+
+      def hook_name
+        config.options[:hook_name]
+      end
+
+      def cds_services_json
+        JSON.parse(File.read(File.join(
+                               __dir__, '..', 'cds-services-v201.json'
+                             )))['services']
+      end
+
+      def advertised_prefetch_fields
+        advertised_hook_service = cds_services_json.find { |service| service['hook'] == hook_name }
+        advertised_hook_service['prefetch']
+      end
+
+      run do
+        hook_contexts = json_parse(contexts)
+        hook_prefetches = json_parse(prefetches)
+
+        pass_if hook_prefetches.blank?, 'No prefetched data provided.'
+
+        hook_prefetches.each_with_index do |prefetch, index|
+          next if prefetch.blank?
+
+          @request_number = index + 1
+          context = hook_contexts[index].present? ? hook_contexts[index] : {}
+          hook_request_prefetch_check(advertised_prefetch_fields, prefetch, context, ig_version: 'v201')
+        end
+        no_error_validation('Prefetch is not valid.')
+      end
+    end
+  end
+end

data/lib/davinci_crd_test_kit/client/v2.0.1/verify_response/client_display_cards_attest.rb

@@ -0,0 +1,83 @@
+require_relative '../client_urls'
+require_relative '../../../cross_suite/cards_identification'
+
+module DaVinciCRDTestKit
+  module V201
+    class ClientCardDisplayAttest < Inferno::Test
+      include ClientURLs
+      include CardsIdentification
+
+      id :crd_v201_card_display_attest_test
+      title 'Check that returned decision support details are displayed to the user'
+      description %(
+        Since Inferno has no way to evaluate the client's UI, testers must manually
+        verify that the cards and system actions returned by Inferno are presented
+        to the user in an appopriate way that allows for consideration and action
+        if warranted.
+      )
+
+      def hook_name
+        config.options[:hook_name]
+      end
+
+      def crd_test_group
+        config.options[:crd_test_group]
+      end
+
+      def tags_to_load
+        crd_test_group.present? ? [hook_name, crd_test_group] : [hook_name]
+      end
+
+      def responded_card_types
+        list_card_types_in_requests(requests)
+      end
+
+      def format_responded_response_types
+        responded_card_types
+          .map do |response_type|
+          response_type_string =
+            response_type.split('_')
+              .map(&:capitalize)
+              .join(' ')
+              .prepend('- ')
+              .sub('Smart', 'SMART')
+              .sub('Create Update', 'Create/Update')
+              .sub('Companions Prerequisites', 'Companions/Prerequisites')
+              .sub('Card', '(card)')
+              .sub('Action', '(systemAction)')
+          response_type_string
+        end
+          .join("\n")
+      end
+
+      output :attest_true_url
+      output :attest_false_url
+
+      run do
+        load_tagged_requests(*tags_to_load)
+        skip_if responded_card_types.blank?, 'No responses sent to the client.'
+
+        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
+            **Card Display Attestation**:
+
+            I attest that the following CDS response types returned were processed by the
+            client system and displayed to the user:
+
+            #{format_responded_response_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.0.1/verify_response/inferno_response_validation.rb

@@ -0,0 +1,79 @@
+require_relative '../../../cross_suite/cards_validation'
+
+module DaVinciCRDTestKit
+  module V201
+    class InfernoResponseValidationTest < Inferno::Test
+      include CardsValidation
+
+      title 'Inferno CDS Service Response is Conformant'
+      description %(
+        This test verifies that each service response built by Inferno and returned to the client is conformant.
+        These responses must be conformant for the client to demonstrate its ability to accept CDS Service responses.
+
+        If this test fails when a custom response was provided, adjust the custom response template
+        and the submitted requests so that the response built by Inferno is conformant. See
+        the documentation for details on how Inferno builds a response from the provided
+        custom template.
+
+        If this test fails when Inferno mocked the response based on selected card types, please
+        report this failure to the Inferno team via github issues.
+      )
+      id :crd_v201_inferno_response_validation
+
+      input :custom_response_template, optional: true
+
+      def hook_name
+        config.options[:hook_name]
+      end
+
+      def crd_test_group
+        config.options[:crd_test_group]
+      end
+
+      def tags_to_load
+        crd_test_group.present? ? [hook_name, crd_test_group] : [hook_name]
+      end
+
+      def response_label(index = nil)
+        response_type = (custom_response_template.present? ? 'Custom built' : 'Mocked')
+        "#{response_type} response#{" #{index}" if index.present?}"
+      end
+
+      def valid_cards
+        @valid_cards ||= []
+      end
+
+      def validate_system_actions(system_actions)
+        return if system_actions.nil?
+
+        system_actions.each do |action|
+          action_fields_validation(action, ig_version: 'v201')
+        end
+      end
+
+      run do
+        load_tagged_requests(*tags_to_load)
+
+        skip_if request.blank?, "No #{response_label.downcase}s to verify."
+
+        entity_validated = false
+        requests.each_with_index do |request, index|
+          response_hash = JSON.parse(request.response_body)
+
+          next unless response_hash['cards'].present? || response_hash['systemActions'].present?
+
+          entity_validated = true
+          perform_cards_validation(response_hash['cards'], response_hash['systemActions'].present?, 'v201', index)
+          validate_system_actions(response_hash['systemActions'])
+        rescue JSON::ParserError
+          next
+        end
+
+        skip_if !entity_validated,
+                "No #{response_label.downcase} cards or system actions to verify returned by Inferno."
+
+        no_error_validation("Invalid Inferno #{response_label.downcase}(s). Check messages for issues found.")
+      end
+    end
+  end
+end

data/lib/davinci_crd_test_kit/client/v2.2.1/api/client_coverage_info_update_test.rb

@@ -0,0 +1,212 @@
+require_relative '../../../cross_suite/cards_identification'
+require_relative '../../tagged_request_load_helper'
+
+module DaVinciCRDTestKit
+  module V221
+    class ClientCoverageInfoUpdateTest < Inferno::Test
+      include CardsIdentification
+      include TaggedRequestLoadHelper
+
+      title "Client's FHIR server stores updates from coverage-information responses"
+      id :crd_v221_client_coverage_info_update
+      description <<~DESCRIPTION
+        This test verifies that when the client receives a [Coverage Information response type](https://hl7.org/fhir/us/davinci-crd/2.2.1/en/cards.html#coverage-information-response-type),
+        it stores the [coverage-information extension](https://hl7.org/fhir/us/davinci-crd/2.2.1/en/StructureDefinition-ext-coverage-information.html)
+        and makes it available when accessing the associated resource.
+
+        During this test, Inferno will find all [Coverage Information responses](https://hl7.org/fhir/us/davinci-crd/2.2.1/en/cards.html#coverage-information-response-type),
+        attempt to read the updated FHIR resource from the client's FHIR server, and verify
+        that the [coverage-information extension](https://hl7.org/fhir/us/davinci-crd/2.2.1/en/StructureDefinition-ext-coverage-information.html)
+        in the response is now present in the returned resource. When comparing the
+        [coverage-information extension](https://hl7.org/fhir/us/davinci-crd/2.2.1/en/StructureDefinition-ext-coverage-information.html)
+        in the response with what is returned from the client FHIR server, Inferno
+        expects that client stores and exposes the extension without modification, meaning
+        that the exact set of sub-extensions in the response and their values are present
+        in the stored version.
+
+        Inferno will not always be able to perform this check. CRD clients are not required
+        to expose FHIR read APIs for all request resource types, so resource types for which
+        the client's CapabilityStatement does not indicate read interaction support will be omitted.
+        Additionally, Inferno will not check complex cases where determining the expected
+        stored extensions is difficult. For example, when there are multiple Coverage Information
+        responses for a single resource or multiple coverage-information extensions in a
+        single Coverage Information response. Implementers are still responsible for storing updates
+        in these cases. To pass this test at least one target resource that Inferno can access must be found.
+        The stored [coverage-information extension](https://hl7.org/fhir/us/davinci-crd/2.2.1/en/StructureDefinition-ext-coverage-information.html)
+        must be correct for all resources checked by Inferno.
+      DESCRIPTION
+
+      verifies_requirements 'hl7.fhir.us.davinci-crd_2.2.1@found-36-B', 'hl7.fhir.us.davinci-crd_2.2.1@resp-46'
+
+      uses_request :capability_statement
+
+      run do
+        supported_resource_types = extract_supported_resource_types(resource) # extract before loading other requests
+
+        loaded_requests = requests_to_analyze # all requests for one hook or all requests for all hooks
+        skip_if loaded_requests.blank?, 'No hook requests found, run hook tests first.'
+
+        resources_to_check, unsupported = find_coverage_info_responses(loaded_requests)
+          .partition { |request_details| supported_resource_types.include?(request_details[:resource_type]) }
+        unsupported.each do |request_details|
+          add_message('info', "#{error_prefix(request_details)}Resource type #{request_details[:resource_type]} " \
+                              'is not supported by the client\'s FHIR API. This resource will not be verified.')
+        end
+        skip_if resources_to_check.blank?,
+                'No coverage-info responses found that Inferno could verify: ' \
+                're-run hook tests generating responses that Inferno can verify.'
+
+        resources_to_check.each do |resource_details|
+          check_for_stored_coverage_information_extension(resource_details)
+        end
+
+        assert_no_error_messages('Not all coverage-information extensions stored. See Messages for details.')
+      end
+
+      # important information to record:
+      # - relative resource reference (resource type + id)
+      # - coverage-information extension
+      # - position (response index + systemAction index)
+      def find_coverage_info_responses(requests)
+        all_responses = requests.flat_map.with_index do |request, request_index|
+          find_coverage_info_actions_in_response(request, request_index)
+        end
+
+        all_responses.group_by { |resource_details| [resource_details[:resource_type], resource_details[:target_id]] }
+          .filter_map do |(_type, _id), entries|
+            if entries.size > 1
+              add_message('info',
+                          "#{error_prefix(entries.first)}Multiple coverage-info responses found. Due to the " \
+                          'complexity of determining the expected state, this resource will not be verified.')
+              next
+            end
+
+            if entries.first[:coverage_information_extensions].size > 1
+              add_message('info',
+                          "#{error_prefix(entries.first)}Multiple coverage-information extensions found. Due to the " \
+                          'complexity of determining the expected state, this resource will not be verified.')
+              next
+            end
+
+            entries.first
+          end
+      end
+
+      def find_coverage_info_actions_in_response(request, request_index)
+        response = JSON.parse(request.response_body)
+        return [] unless response.is_a?(Hash) && response.key?('systemActions')
+
+        response['systemActions'].map.with_index do |action, action_index|
+          if coverage_information_response_type?(action)
+            extract_coverage_information_details(action, action_index, request_index)
+          end
+        end.compact
+      rescue JSON::ParserError
+        [] # no responses to check, error registered elsewhere
+      end
+
+      def extract_coverage_information_details(action, action_index, request_index)
+        {
+          request_index:,
+          action_index:,
+          resource_type: action.dig('resource', 'resourceType'),
+          target_id: action.dig('resource', 'id'),
+          coverage_information_extensions: FHIR.from_contents(action['resource'].to_json).extension.select do |ext|
+                                             ext.url == COVERAGE_INFO_EXT_URL
+                                           end
+        }
+      end
+
+      def extract_supported_resource_types(capability_statement)
+        return [] unless capability_statement.rest.is_a?(Array)
+
+        capability_statement.rest.select { |rest| rest.mode == 'server' }.flat_map do |rest|
+          next [] unless rest.resource.is_a?(Array)
+
+          rest.resource.select do |resource|
+            supports_read?(resource)
+          end.flat_map(&:type).compact
+        end.uniq
+      end
+
+      def supports_read?(resource)
+        resource.interaction&.any? do |interaction|
+          interaction.code == 'read'
+        end
+      end
+
+      def check_for_stored_coverage_information_extension(resource_details)
+        fhir_read resource_details[:resource_type], resource_details[:target_id]
+        unless resource.present? && resource.resourceType == resource_details[:resource_type]
+          add_message('error', "#{error_prefix(resource_details)}Unable to read target resource.")
+          return
+        end
+
+        stored_extensions = resource.extension.select { |ext| ext.url == COVERAGE_INFO_EXT_URL }
+        if stored_extensions.blank?
+          add_message('error', "#{error_prefix(resource_details)}coverage-information extension(s) not stored.")
+          return
+        end
+
+        difference_string = coverage_info_extension_differences(
+          resource_details[:coverage_information_extensions],
+          stored_extensions
+        )
+        return unless difference_string.present?
+
+        add_message('error', "#{error_prefix(resource_details)}#{difference_string}.")
+      end
+
+      def coverage_info_extension_differences(expected, actual)
+        raise ArgumentError, 'expected must contain exactly one coverage-information extension' if expected.size != 1
+
+        if expected.size != actual.size
+          return "Expected #{expected.size} coverage-information extension(s), found #{actual.size}."
+        end
+
+        differences = compare_coverage_info_sub_extensions(expected[0], actual[0])
+        return unless differences.present?
+
+        "Stored coverage-information extension does not match what was sent by the server: #{differences.join(', ')}"
+      end
+
+      def compare_coverage_info_sub_extensions(expected, actual)
+        expected_by_url = expected.extension.group_by(&:url)
+        actual_by_url = actual.extension.group_by(&:url)
+
+        (expected_by_url.keys | actual_by_url.keys).filter_map do |url|
+          compare_url_sub_extensions(url, expected_by_url, actual_by_url)
+        end
+      end
+
+      def compare_url_sub_extensions(url, expected_by_url, actual_by_url)
+        if !expected_by_url.key?(url)
+          "unexpected sub-extension '#{url}' found in stored resource"
+        elsif !actual_by_url.key?(url)
+          "sub-extension '#{url}' missing from stored resource"
+        elsif normalized_extensions(expected_by_url[url]) != normalized_extensions(actual_by_url[url])
+          "sub-extension '#{url}' value differs"
+        end
+      end
+
+      def normalized_extensions(extensions)
+        extensions.map { |e| normalize_extension(e.to_hash) }.sort_by(&:to_json)
+      end
+
+      # Recursively sort nested arrays so sub-extension order doesn't affect equality.
+      def normalize_extension(value)
+        case value
+        when Hash  then value.transform_values { |v| normalize_extension(v) }
+        when Array then value.map { |item| normalize_extension(item) }.sort_by(&:to_json)
+        else value
+        end
+      end
+
+      def error_prefix(resource_details)
+        "(Request #{resource_details[:request_index] + 1}) " \
+          "coverage-info systemAction #{resource_details[:action_index] + 1} " \
+          "targeting resource #{resource_details[:resource_type]}/#{resource_details[:target_id]}: "
+      end
+    end
+  end
+end

data/lib/davinci_crd_test_kit/client/v2.2.1/api/client_crd_update_verification_group.rb

@@ -0,0 +1,18 @@
+require_relative 'client_coverage_info_update_test'
+
+module DaVinciCRDTestKit
+  module V221
+    class ClientCRDUpdateVerificationGroup < Inferno::TestGroup
+      id :crd_v221_client_update_verification
+      title 'CRD Update Tests'
+      description %(
+        This CRD-specific group verifies that the client was able to
+        persist updates provided by the payer server as a part of
+        decision support responses.
+      )
+      run_as_group
+
+      test from: :crd_v221_client_coverage_info_update
+    end
+  end
+end