davinci_crd_test_kit 0.12.2 → 0.14.0

data/lib/davinci_crd_test_kit/server/v2.2.1/verify_request/service_request_optional_fields_validation_test.rb

@@ -0,0 +1,39 @@
+require_relative '../../server_hook_request_validation'
+require_relative '../../server_hook_helper'
+
+module DaVinciCRDTestKit
+  module V221
+    class ServiceRequestOptionalFieldsValidationTest < Inferno::Test
+      include DaVinciCRDTestKit::ServerHookRequestValidation
+      include DaVinciCRDTestKit::ServerHookHelper
+
+      title 'Service request optional fields are valid'
+      id :crd_v221_service_request_optional_fields_validation
+      description %(
+        This optional test reviews the user-submitted CRD service requests for the presence of optional fields:
+        `fhirAuthorization` and `prefetch`.
+
+        The test will not fail if these optional fields are missing from a service request; instead, it generates an
+        informational message.
+      )
+      optional
+
+      run do
+        load_tagged_requests(tested_hook_name)
+        skip_if requests.empty?, "No #{tested_hook_name} request was made in a previous test as expected."
+
+        requests.each_with_index do |request, index|
+          @request_number = index + 1
+          request_body = json_parse(request.request_body)
+          if request_body.blank?
+            add_message('error', "#{request_number}Hook request body cannot be empty.")
+            next
+          end
+
+          hook_request_optional_fields_check(request_body, ig_version: 'v221')
+        end
+        no_error_validation('Some service requests have invalid optional fields.')
+      end
+    end
+  end
+end

data/lib/davinci_crd_test_kit/server/v2.2.1/verify_request/service_request_required_fields_validation_test.rb

@@ -0,0 +1,40 @@
+require_relative '../../server_hook_request_validation'
+require_relative '../../server_hook_helper'
+
+module DaVinciCRDTestKit
+  module V221
+    class ServiceRequestRequiredFieldsValidationTest < Inferno::Test
+      include DaVinciCRDTestKit::ServerHookRequestValidation
+      include DaVinciCRDTestKit::ServerHookHelper
+
+      title 'Service requests contain required fields'
+      id :crd_v221_service_request_required_fields_validation
+      description %(
+        This test validates all CRD service requests provided by the user, ensuring each includes all required fields
+        specified in the [CDS Hooks spec section on Calling a CDS Service](https://cds-hooks.hl7.org/2.0/#calling-a-cds-service):
+        `hook`, `hookInstance`, and `context`. Furthermore, the test checks for the conditional presence of the
+        `fhirServer` field if `fhirAuthorization` is included.
+      )
+      input :invoked_hook
+      output :contexts
+
+      run do
+        load_tagged_requests(tested_hook_name)
+        skip_if requests.empty?, "No #{tested_hook_name} request was made in a previous test as expected."
+        contexts = []
+        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)
+          hook_request_required_fields_check(request_body, invoked_hook, ig_version: 'v221')
+        end
+
+        output contexts: contexts.to_json
+
+        no_error_validation('Some service requests made are not valid.')
+      end
+    end
+  end
+end

data/lib/davinci_crd_test_kit/server/v2.2.1/verify_response/additional_orders_validation_test.rb

@@ -0,0 +1,66 @@
+require_relative '../../server_test_helper'
+require_relative '../../server_hook_helper'
+require_relative '../../../cross_suite/suggestion_actions_validation'
+require_relative '../../../cross_suite/cards_identification'
+require_relative '../../../cross_suite/cards_validation'
+
+module DaVinciCRDTestKit
+  module V221
+    class AdditionalOrdersValidationTest < Inferno::Test
+      include DaVinciCRDTestKit::ServerTestHelper
+      include DaVinciCRDTestKit::SuggestionActionsValidation
+      include DaVinciCRDTestKit::ServerHookHelper
+      include DaVinciCRDTestKit::CardsIdentification
+      include DaVinciCRDTestKit::CardsValidation
+
+      title 'Additional Orders cards are valid'
+      id :crd_v221_additional_orders_card_validation
+      description %(
+        This test validates that an [Additional Orders as companions/prerequisites](https://hl7.org/fhir/us/davinci-crd/STU2/cards.html#identify-additional-orders-as-companionsprerequisites-for-current-order)
+        card was received. It does so by:
+        - Filtering cards with the following criteria:
+          - For each suggestion in the card's suggestions array, all actions have a type of 'create'
+            and the action's resource type is one of the expected types: CommunicationRequest, Device,
+            DeviceRequest, Medication, MedicationRequest, NutritionOrder, ServiceRequest, or VisionPrescription.
+        - Then, for each valid Additional Orders card retrieved, verifying that each action within the
+        card's suggestions complies with their respective profiles as specified in the
+        [CRD IG section on Additional Orders as companions/prerequisites](https://hl7.org/fhir/us/davinci-crd/STU2/cards.html#identify-additional-orders-as-companionsprerequisites-for-current-order):
+          - [crd-profile-communicationrequest](https://hl7.org/fhir/us/davinci-crd/STU2/StructureDefinition-profile-communicationrequest.html)
+          - [crd-profile-device](https://hl7.org/fhir/us/davinci-crd/STU2/StructureDefinition-profile-device.html)
+          - [crd-profile-deviceRequest](https://hl7.org/fhir/us/davinci-crd/STU2/StructureDefinition-profile-devicerequest.html)
+          - [us-core-medication](http://hl7.org/fhir/us/core/STU3.1.1/StructureDefinition-us-core-medication.html)
+          - [crd-profile-medicationRequest](https://hl7.org/fhir/us/davinci-crd/STU2/StructureDefinition-profile-medicationrequest.html)
+          - [crd-profile-nutritionOrder](https://hl7.org/fhir/us/davinci-crd/STU2/StructureDefinition-profile-nutritionorder.html)
+          - [crd-profile-serviceRequest](https://hl7.org/fhir/us/davinci-crd/STU2/StructureDefinition-profile-servicerequest.html)
+          - [crd-profile-visionPrescription](https://hl7.org/fhir/us/davinci-crd/STU2/StructureDefinition-profile-visionprescription.html).
+
+        The test will skip if no Additional Orders cards are found.
+      )
+
+      verifies_requirements 'hl7.fhir.us.davinci-crd_2.2.1@resp-57',
+                            'hl7.fhir.us.davinci-crd_2.2.1@resp-58'
+
+      optional
+      input :valid_cards_with_suggestions
+
+      run do
+        parsed_cards = parse_json(valid_cards_with_suggestions)
+        additional_orders_cards = parsed_cards.filter do |card|
+          additional_orders_response_type?(card)
+        end
+        skip_if additional_orders_cards.blank?,
+                "#{tested_hook_name} hook response does not include Additional Orders as companion/prerequisite cards."
+
+        additional_orders_cards.each do |card|
+          card['suggestions'].each do |suggestion|
+            actions_check(suggestion['actions'], ig_version: 'v221')
+          end
+
+          additional_orders_check(card)
+        end
+
+        no_error_validation('Some Additional Order cards are not valid. See messages for more information.')
+      end
+    end
+  end
+end

data/lib/davinci_crd_test_kit/server/v2.2.1/verify_response/all_responses_include_coverage_information_test.rb

@@ -0,0 +1,123 @@
+require_relative '../../server_test_helper'
+require_relative '../../server_hook_helper'
+require_relative '../../../cross_suite/cards_identification'
+require_relative '../../../cross_suite/profiles_and_resource_types'
+
+module DaVinciCRDTestKit
+  module V221
+    class AllResponsesIncludeCoverageInformationTest < Inferno::Test
+      include DaVinciCRDTestKit::ServerTestHelper
+      include DaVinciCRDTestKit::ServerHookHelper
+      include DaVinciCRDTestKit::CardsIdentification
+
+      title 'Hook responses include Coverage Information system actions'
+      id :crd_v221_all_responses_include_coverage_information
+      description %(
+        This test validates that a [Coverage
+        Information](https://hl7.org/fhir/us/davinci-crd/2.2.1/en/cards.html#coverage-information-response-type)
+        system action was returned for every hook call, unless the resource
+        which is the focus of the hook call already includes a
+        [coverage-information
+        extension](https://hl7.org/fhir/us/davinci-crd/2.2.1/en/StructureDefinition-ext-coverage-information.html).
+        It does so by:
+        - First checking for the presence of actions with a `resource` element
+          of the following types:
+          - For `appointment-book`: Appointment
+          - For `order-sign` or `order-dispatch`: CommunicationRequest,
+            DeviceRequest, MedicationRequest, NutritionOrder, ServiceRequest, or
+            VisionPrescription
+        - Then, checking whether each resource contains the coverage-information extension
+        - Finally verifying that the response to each hook call where the
+          resource did not contain a coverage-information extension includes
+          coverage information system action
+      )
+
+      verifies_requirements 'hl7.fhir.us.davinci-crd_2.2.1@hook-16',
+                            'hl7.fhir.us.davinci-crd_2.2.1@resp-28'
+
+      input :invoked_hook
+
+      def target_resources
+        {
+          'appointment-book' => ['Appointment'],
+          'order-sign' => ProfilesAndResourceTypes::ORDER_RESOURCE_TYPES,
+          'order-dispatch' => ProfilesAndResourceTypes::ORDER_RESOURCE_TYPES,
+          'order-select' => ProfilesAndResourceTypes::ORDER_RESOURCE_TYPES,
+          'encounter-start' => ['Encounter'],
+          'encounter-discharge' => ['Encounter']
+        }[tested_hook_name]
+      end
+
+      def hook_bundle_field_name
+        {
+          'appointment-book' => 'appointments',
+          'order-sign' => 'draftOrders'
+        }[tested_hook_name]
+      end
+
+      def resources_contain_coverage_information_extension?(resources)
+        resources.all? do |resource|
+          resource.extension&.any? do |extension|
+            extension.url == 'http://hl7.org/fhir/us/davinci-crd/StructureDefinition/ext-coverage-information'
+          end
+        end
+      end
+
+      def order_resources(hook_call_body)
+        bundle = FHIR::Bundle.new(hook_call_body.dig('context', hook_bundle_field_name))
+        bundle.entry.map(&:resource).select { |resource| target_resources.include? resource.resourceType }
+      end
+
+      run do
+        successful_hook_calls_without_coverage_information = 0
+        coverage_information_system_actions_received = 0
+
+        load_tagged_requests(tested_hook_name)
+
+        requests.each do |request|
+          next if request.status != 200
+
+          hook_call_body = JSON.parse(request.request_body)
+
+          # TODO: handle when default value for coverage-info is false
+          next if hook_call_body.dig('extension', 'davinci-crd.configuration', 'coverage-info') == false
+
+          resources = order_resources(hook_call_body)
+
+          next if resources_contain_coverage_information_extension?(resources)
+
+          successful_hook_calls_without_coverage_information += 1
+
+          hook_call_response = JSON.parse(request.response_body)
+
+          system_actions = hook_call_response['systemActions']
+
+          next if system_actions.blank?
+
+          system_actions_resources =
+            system_actions
+              .select { |action| action['type'] == 'update' }
+              .select { |action| target_resources.include? action['resource']['resourceType'] }
+              .map { |action| FHIR.from_contents(action['resource'].to_json) }
+
+          next unless resources_contain_coverage_information_extension?(system_actions_resources)
+
+          coverage_information_system_actions_received += 1
+        rescue JSON::ParserError => e
+          warning(e.message)
+          next
+        end
+
+        skip_if successful_hook_calls_without_coverage_information.zero?,
+                'No successful hook calls were made with resources which did not already ' \
+                'contain a coverage-information extension.'
+
+        assert successful_hook_calls_without_coverage_information == coverage_information_system_actions_received,
+               "#{successful_hook_calls_without_coverage_information} successful hook calls " \
+               'without a coverage-information extension were made, but only ' \
+               "#{coverage_information_system_actions_received} of the responses contained " \
+               'a coverage information system action.'
+      end
+    end
+  end
+end

data/lib/davinci_crd_test_kit/server/v2.2.1/verify_response/card_optional_fields_validation_test.rb

@@ -0,0 +1,57 @@
+require_relative '../../server_test_helper'
+require_relative '../../server_hook_request_validation'
+require_relative '../../../cross_suite/cards_validation'
+
+module DaVinciCRDTestKit
+  module V221
+    class CardOptionalFieldsValidationTest < Inferno::Test
+      include DaVinciCRDTestKit::ServerTestHelper
+      include DaVinciCRDTestKit::ServerHookRequestValidation
+      include DaVinciCRDTestKit::CardsValidation
+
+      title 'Cards contain valid optional fields'
+      id :crd_v221_card_optional_fields_validation
+      description %(
+        This test checks for the presence and validity of optional fields in a card,
+        but only if the card's required fields are valid. As specified in the
+        [CDS Hooks specification section on Card Attributes](https://cds-hooks.hl7.org/2.0/#card-attributes),
+        the optional fields include `uuid`, `detail`, `suggestions`, `overrideReasons`, and `links`.
+
+        Additionally, the test validates the presence of the conditional field `selectionBehavior`
+        only if the `suggestions` field is present.
+      )
+      optional
+      input :valid_cards
+      output :valid_cards_with_links, :valid_cards_with_suggestions
+
+      verifies_requirements 'hl7.fhir.us.davinci-crd_2.2.1@resp-3',
+                            'hl7.fhir.us.davinci-crd_2.2.1@resp-13',
+                            'hl7.fhir.us.davinci-crd_2.2.1@resp-18',
+                            'hl7.fhir.us.davinci-crd_2.2.1@resp-19',
+                            'hl7.fhir.us.davinci-crd_2.2.1@resp-22'
+
+      def cards_with_suggestions
+        @cards_with_suggestions ||= []
+      end
+
+      def cards_with_links
+        @cards_with_links ||= []
+      end
+
+      run do
+        parsed_cards = parse_json(valid_cards)
+        parsed_cards.each do |card|
+          if valid_card_with_optionals?(card, 'v221')
+            cards_with_links << card if card['links']
+            cards_with_suggestions << card if card['suggestions']
+          end
+        end
+
+        output valid_cards_with_links: cards_with_links.to_json
+        output valid_cards_with_suggestions: cards_with_suggestions.to_json
+
+        no_error_validation('Some cards with valid required fields have invalid optional fields.')
+      end
+    end
+  end
+end

data/lib/davinci_crd_test_kit/server/v2.2.1/verify_response/coverage_info_configuration_test.rb

@@ -0,0 +1,83 @@
+require_relative '../../../cross_suite/cards_identification'
+require_relative '../../server_hook_helper'
+require_relative '../server_urls'
+
+module DaVinciCRDTestKit
+  module V221
+    class CoverageInfoConfigurationTest < Inferno::Test
+      include DaVinciCRDTestKit::CardsIdentification
+      include DaVinciCRDTestKit::ServerHookHelper
+      include DaVinciCRDTestKit::V221::ServerURLs
+
+      title 'Coverage Information configuration option suppresses coverage-info responses'
+      id :crd_v221_coverage_info_configuration
+      description %(
+        This test checks follow-up hook requests made with
+        `extension.davinci-crd.configuration.coverage-info` set to `false` after prior successful hook requests
+        returned coverage-info content.
+
+        CRD Servers SHALL behave in the manner prescribed by supported configuration information received from
+        the CRD Client. When `coverage-info` is `false`, responses must not include coverage-info cards or
+        coverage-information/form-completion system actions.
+      )
+
+      verifies_requirements 'hl7.fhir.us.davinci-crd_2.2.1@dev-14',
+                            'hl7.fhir.us.davinci-crd_2.2.1@resp-28'
+
+      def coverage_info_message(cards, actions)
+        card_summaries = cards.map { |card| card['summary'] }.compact
+        action_descriptions = actions.map { |action| action['description'] }.compact
+
+        'Coverage-info disabled server response included coverage-info content despite ' \
+          "`#{COVERAGE_INFO_CONFIGURATION_CODE}` being set to `false`. " \
+          "Cards: #{card_summaries.join(', ')}. System actions: #{action_descriptions.join(', ')}."
+      end
+
+      def primary_hook?
+        ['appointment-book', 'order-sign', 'order-dispatch'].include? tested_hook_name
+      end
+
+      def parsed_body(json)
+        JSON.parse(json)
+      rescue JSON::ParserError
+        nil
+      end
+
+      run do
+        load_tagged_requests(tested_hook_name, COVERAGE_INFO_DISABLED_TAG)
+
+        if requests.empty?
+          message = "No successful #{tested_hook_name} response contained coverage-info content to suppress."
+          if primary_hook?
+            skip message
+          else
+            omit message
+          end
+        end
+
+        requests.each do |request|
+          unless request.status == 200
+            add_message(
+              'error',
+              "Coverage-info disabled server request returned HTTP #{request.status}; expected HTTP 200."
+            )
+            next
+          end
+
+          response_body = parsed_body(request.response_body)
+          unless response_body.is_a?(Hash)
+            add_message('error', 'Coverage-info disabled server response was not valid JSON.')
+            next
+          end
+
+          cards, actions = coverage_info_content(response_body)
+          next if cards.empty? && actions.empty?
+
+          add_message('error', coverage_info_message(cards, actions))
+        end
+
+        assert_no_error_messages('Coverage-info configuration responses were not valid. Check messages for details.')
+      end
+    end
+  end
+end

data/lib/davinci_crd_test_kit/server/v2.2.1/verify_response/coverage_information_system_action_received_test.rb

@@ -0,0 +1,65 @@
+require_relative '../../server_test_helper'
+require_relative '../../server_hook_helper'
+require_relative '../../../cross_suite/cards_identification'
+
+module DaVinciCRDTestKit
+  module V221
+    class CoverageInformationSystemActionReceivedTest < Inferno::Test
+      include DaVinciCRDTestKit::ServerTestHelper
+      include DaVinciCRDTestKit::ServerHookHelper
+      include DaVinciCRDTestKit::CardsIdentification
+
+      title 'Server returns a Coverage Information system action'
+      id :crd_v221_coverage_info_system_action_received
+      description %(
+        This test validates that a [Coverage Information](https://hl7.org/fhir/us/davinci-crd/STU2/cards.html#coverage-information)
+        system action was returned. It does so by:
+        - First checking for the presence of actions with a `resource` element of the following types:
+          - For `appointment-book`: Appointment
+          - For `order-sign` or `order-dispatch`: DeviceRequest, MedicationRequest, NutritionOrder,
+            ServiceRequest, or VisionPrescription
+        - Then, among the target actions, checking if their resource has the [coverage-information extension](http://hl7.org/fhir/us/davinci-crd/StructureDefinition/ext-coverage-information).
+      )
+      # verifies_requirements 'hl7.fhir.us.davinci-crd_2.0.1@272', 'hl7.fhir.us.davinci-crd_2.0.1@273',
+      #                       'hl7.fhir.us.davinci-crd_2.0.1@274', 'hl7.fhir.us.davinci-crd_2.0.1@275',
+      #                       'hl7.fhir.us.davinci-crd_2.0.1@276', 'hl7.fhir.us.davinci-crd_2.0.1@277'
+
+      input :valid_system_actions, :invoked_hook
+      output :coverage_info
+
+      def resources_by_hook
+        shared_resources = [
+          'DeviceRequest', 'MedicationRequest', 'NutritionOrder',
+          'ServiceRequest', 'VisionPrescription'
+        ]
+        {
+          'appointment-book' => ['Appointment'],
+          'order-sign' => shared_resources,
+          'order-dispatch' => shared_resources,
+          'order-select' => shared_resources,
+          'encounter-start' => ['Encounter'],
+          'encounter-discharge' => ['Encounter']
+        }
+      end
+
+      run do
+        parsed_actions = parse_json(valid_system_actions)
+        target_resources = resources_by_hook[invoked_hook]
+
+        target_actions = parsed_actions.select do |action|
+          resource = FHIR.from_contents(action['resource'].to_json)
+          target_resources.include?(resource&.resourceType)
+        end
+
+        coverage_info_system_actions = target_actions.select do |action|
+          coverage_information_response_type?(action)
+        end
+
+        assert coverage_info_system_actions.present?,
+               "Coverage Information system action was not returned in the #{tested_hook_name} hook response."
+
+        output coverage_info: coverage_info_system_actions.to_json
+      end
+    end
+  end
+end

data/lib/davinci_crd_test_kit/server/v2.2.1/verify_response/coverage_information_system_action_validation_test.rb

@@ -0,0 +1,184 @@
+require_relative '../../server_hook_request_validation'
+require_relative '../../server_test_helper'
+require_relative '../../server_hook_helper'
+require_relative 'hook_request_resource_resolution'
+
+module DaVinciCRDTestKit
+  module V221
+    class CoverageInformationSystemActionValidationTest < Inferno::Test
+      include DaVinciCRDTestKit::ServerHookRequestValidation
+      include DaVinciCRDTestKit::ServerTestHelper
+      include DaVinciCRDTestKit::ServerHookHelper
+      include HookRequestResourceResolution
+
+      COVERAGE_INFO_EXT_URL = 'http://hl7.org/fhir/us/davinci-crd/StructureDefinition/ext-coverage-information'.freeze
+
+      title 'Coverage Information system actions are valid'
+      id :crd_v221_coverage_info_system_action_validation
+      description %(
+        This test validates all [Coverage Information](https://hl7.org/fhir/us/davinci-crd/STU2/cards.html#coverage-information)
+        system actions received. It verifies the following for each action:
+        - The action type is `update`.
+        - The resource within the action conforms its respective FHIR profile.
+        - The resource does not change any data elements other than adding or modifying
+          the `coverage-information` extension.
+
+        Additionally, the test examines the `coverage-info` extensions within the resource to ensure that:
+        - Entries referencing differing coverage have distinct `coverage-assertion-ids` and `satisfied-pa-ids`
+        (if present).
+        - Entries referencing the same coverage have the same `coverage-assertion-ids` and `satisfied-pa-ids`
+        (if present).
+      )
+
+      verifies_requirements 'hl7.fhir.us.davinci-crd_2.2.1@resp-32',
+                            'hl7.fhir.us.davinci-crd_2.2.1@resp-37',
+                            'hl7.fhir.us.davinci-crd_2.2.1@resp-47',
+                            'hl7.fhir.us.davinci-crd_2.2.1@resp-48',
+                            'hl7.fhir.us.davinci-crd_2.2.1@resp-52'
+
+      input :coverage_info
+      input :mock_ehr_bundle, optional: true
+
+      def find_extension_value(extension, url, *properties)
+        found_extension = extension.extension.find { |ext| ext.url == url }
+        return nil unless found_extension
+
+        properties.reduce(found_extension) do |current, prop|
+          return current unless current.respond_to?(prop)
+
+          current.send(prop)
+        end
+      end
+
+      def extract_and_group_coverage_info(resource)
+        resource.extension.each_with_object({}) do |extension, grouped_extensions|
+          next unless extension.url == COVERAGE_INFO_EXT_URL
+
+          coverage_key = find_extension_value(extension, 'coverage', 'valueReference', 'reference')
+          grouped_extensions[coverage_key] ||= []
+          grouped_extensions[coverage_key] << extension
+        end
+      end
+
+      # For the same coverage, ensure coverage-assertion-ids and satisfied-pa-ids are the same.
+      # For different coverages, ensure coverage-assertion-ids and satisfied-pa-ids are distinct.
+      def multiple_extensions_conformance_check(grouped_coverage_info, resource)
+        resource_ref = "#{resource.resourceType}/#{resource.id}"
+        assertion_ids_across_coverages = Set.new
+        pa_ids_across_coverages = Set.new
+
+        grouped_coverage_info.each do |coverage, extensions|
+          coverage_assertion_ids = collect_extensions_id(extensions, 'coverage-assertion-id', 'valueString').uniq
+          satisfied_pa_ids = collect_extensions_id(extensions, 'satisfied-pa-id', 'valueString').uniq.compact
+          assert coverage_assertion_ids.length == 1,
+                 same_coverage_conformance_error_msg(resource_ref, coverage, 'coverage-assertion-ids')
+
+          assert satisfied_pa_ids.length <= 1,
+                 same_coverage_conformance_error_msg(resource_ref, coverage, 'satisfied-pa-ids')
+
+          assertion_id = coverage_assertion_ids.first
+          assert !assertion_ids_across_coverages.include?(assertion_id),
+                 different_coverage_conformance_error_msg(resource_ref, 'coverage-assertion-ids')
+          assertion_ids_across_coverages.add(assertion_id)
+          pa_id = satisfied_pa_ids.first
+          next unless pa_id
+
+          assert !pa_ids_across_coverages.include?(pa_id),
+                 different_coverage_conformance_error_msg(resource_ref, 'satisfied-pa-ids')
+          pa_ids_across_coverages.add(pa_id)
+        end
+      end
+
+      def collect_extensions_id(extensions, url, *properties)
+        extensions.map do |extension|
+          find_extension_value(extension, url, *properties)
+        end
+      end
+
+      def same_coverage_conformance_error_msg(resource_ref, coverage, id_name)
+        "#{resource_ref}: extension has multiple repetitions of coverage `#{coverage}` with different #{id_name}."
+      end
+
+      def different_coverage_conformance_error_msg(resource_ref, id_name)
+        "#{resource_ref}: extensions referencing differing coverage SHALL have distinct #{id_name}."
+      end
+
+      def normalize_value(value)
+        case value
+        when Hash
+          value.transform_values { |child| normalize_value(child) }
+        when Array
+          value.map { |child| normalize_value(child) }.sort_by(&:to_json)
+        else
+          value
+        end
+      end
+
+      def strip_coverage_info_extensions(resource_hash)
+        normalized_hash = resource_hash.deep_dup
+        return normalized_hash unless normalized_hash['extension'].is_a?(Array)
+
+        normalized_hash['extension'] = normalized_hash['extension'].reject do |extension|
+          extension['url'] == COVERAGE_INFO_EXT_URL
+        end
+        normalized_hash.delete('extension') if normalized_hash['extension'].empty?
+        normalized_hash
+      end
+
+      def verify_only_coverage_info_changed(action)
+        request = matching_request_for_action(action)
+        source_resource = find_action_source_resource(action, request)
+        updated_resource_hash = action['resource']
+        resource_ref = "#{updated_resource_hash['resourceType']}/#{updated_resource_hash['id']}"
+        unless source_resource
+          messages << {
+            type: 'warning',
+            message: 'Inferno could not resolve the original source resource for Coverage Information systemAction ' \
+                     "targeting #{resource_ref}, so it could not verify that only coverage-information extensions " \
+                     'were changed.'
+          }
+          return
+        end
+
+        source_resource_hash = source_resource.to_hash
+
+        source_without_coverage_info = normalize_value(strip_coverage_info_extensions(source_resource_hash))
+        updated_without_coverage_info = normalize_value(strip_coverage_info_extensions(updated_resource_hash))
+
+        assert source_without_coverage_info == updated_without_coverage_info,
+               "#{resource_ref}: resource content changed outside the coverage-information extension."
+      end
+
+      def coverage_info_system_action_check(coverage_info_system_action)
+        type = coverage_info_system_action['type']
+        assert type, '`type` field is missing.'
+        assert type == 'update', "`type` must be `update`, but was `#{type}`"
+
+        resource = FHIR.from_contents(coverage_info_system_action['resource'].to_json)
+        profile_url = structure_definition_map('v221')[resource.resourceType]
+        resource_is_valid?(resource:, profile_url:)
+
+        grouped_coverage_info = extract_and_group_coverage_info(resource)
+        multiple_extensions_conformance_check(grouped_coverage_info, resource)
+        verify_only_coverage_info_changed(coverage_info_system_action)
+      end
+
+      run do
+        load_tagged_requests(tested_hook_name)
+        parsed_coverage_info = parse_json(coverage_info)
+        error_messages = []
+        parsed_coverage_info.each do |action|
+          coverage_info_system_action_check(action)
+        rescue Inferno::Exceptions::AssertionException => e
+          error_messages << "Coverage Info system action `#{action}`: #{e.message}"
+        end
+
+        error_messages.each do |msg|
+          messages << { type: 'error', message: msg }
+        end
+
+        assert_no_error_messages 'Some Coverage Info system actions are not valid.'
+      end
+    end
+  end
+end