davinci_crd_test_kit 0.12.2 → 0.14.0

data/lib/davinci_crd_test_kit/{hook_request_field_validation.rb → cross_suite/hook_request_field_validation.rb}

@@ -1,12 +1,12 @@
+require_relative 'requests_logical_model_validation'
+require_relative '../server/server_base_urls'
+require_relative 'profiles_and_resource_types'
+
 module DaVinciCRDTestKit
   module HookRequestFieldValidation
-    def request_number
-      if @request_number.blank?
-        ''
-      else
-        "Request #{@request_number}: "
-      end
-    end
+    include RequestsLogicalModelValidation
+    include ServerBaseURLs
+    include ProfilesAndResourceTypes
 
     def json_parse(json)
       JSON.parse(json)
@@ -15,6 +15,115 @@ module DaVinciCRDTestKit
       false
     end
 
+    def hook_request_required_fields_check(request_body, hook_name, ig_version: 'v201') # rubocop:disable Lint/UnusedMethodArgument
+      hook_request_required_fields_check_presence_and_types(request_body)
+
+      if request_body['hook'] != hook_name
+        add_message('error',
+                    "#{request_number}The `hook` field should be #{hook_name}, but was #{request_body['hook']}")
+      end
+
+      if request_body['fhirAuthorization'].present? && request_body['fhirServer'].blank?
+        add_message('error', %(
+                    #{request_number}Missing `fhirServer` field: If `fhirAuthorization` is provided, this field is
+                    #REQUIRED.))
+      end
+
+      return unless request_body['hookInstance'].present? && !guid?(request_body['hookInstance'])
+
+      add_message('error', "#{request_number}`hookInstance` field must be a globally unique UUID.")
+    end
+
+    def hook_request_optional_fields_check(request_body, ig_version: 'v201') # rubocop:disable Lint/UnusedMethodArgument
+      hook_request_optional_fields_check_type(request_body)
+
+      defined_fields = hook_required_fields.keys + hook_optional_fields.keys
+      request_body.keys.reject { |field| defined_fields.include?(field) }.each do |field|
+        if request_body[field].blank?
+          add_message('error', "#{request_number}Hook request field `#{field}` cannot be defined but blank.")
+        end
+      end
+
+      hook_request_fhir_auth_check(request_body)
+    end
+
+    def hook_request_context_check(context, hook_name, ig_version: 'v201')
+      required_fields =
+        if hook_name == 'order-dispatch'
+          context_required_order_dispatch_fields[ig_version]
+        else
+          context_required_fields_by_hook[hook_name]
+        end
+      required_fields.each do |field, type|
+        validate_presence_and_type(context, field, type,
+                                   "#{request_number}#{hook_name} request context")
+      end
+      context_validate_optional_fields(context, hook_name, ig_version:)
+      hook_specific_context_check(context, hook_name, ig_version:)
+    end
+
+    def hook_request_prefetch_check(advertised_prefetch_fields, received_prefetch, received_context, ig_version: 'v201')
+      received_prefetch.each do |received_prefetch_key, received_prefetch_hash|
+        unless advertised_prefetch_fields.key?(received_prefetch_key)
+          add_message('error', "#{request_number}Client sent non-requested Prefetch field `#{received_prefetch_key}`.")
+          next
+        end
+
+        unless received_prefetch_hash.is_a?(Hash)
+          add_message('error', "#{request_number}Prefetch field `#{received_prefetch_key}` is not of type `Hash`.")
+          next
+        end
+
+        received_prefetch_resource = FHIR.from_contents(received_prefetch[received_prefetch_key].to_json)
+        advertised_prefetch_template = advertised_prefetch_fields[received_prefetch_key]
+        if advertised_prefetch_template.include?('?')
+          advertised_prefetch_fhir_search = advertised_prefetch_template.gsub(/{|}/, '').split('?')
+          advertised_prefetch_resource_type = advertised_prefetch_fhir_search.first
+
+          if advertised_prefetch_resource_type == 'Coverage'
+            advertised_coverage_query_params = Rack::Utils.parse_nested_query(advertised_prefetch_fhir_search.last)
+
+            advertised_patient_token = advertised_coverage_query_params['patient']
+            advertised_context_patient_id_key = advertised_patient_token.split('.').last
+            received_context_patient_id = received_context[advertised_context_patient_id_key]
+
+            advertised_status_param = advertised_coverage_query_params['status']
+
+            validate_prefetch_coverages(received_prefetch_resource, received_prefetch_key, received_context_patient_id,
+                                        advertised_status_param, ig_version:)
+          end
+        else
+          advertised_prefetch_token = advertised_prefetch_template.gsub(/{|}/, '').split('/')
+          advertised_context_id = advertised_prefetch_token.last.split('.').last
+
+          if advertised_prefetch_token.length == 1
+            received_context_reference = FHIR::Reference.new(reference: received_context[advertised_context_id])
+            received_context_resource_type = received_context_reference.resource_type
+            received_context_id = received_context_reference.reference_id
+          else
+            received_context_id = received_context[advertised_context_id]
+            received_context_resource_type = advertised_prefetch_token.first
+          end
+          validate_prefetch_resource(received_prefetch_resource, received_prefetch_key,
+                                     received_context_resource_type, received_context_id, ig_version:)
+        end
+      end
+    end
+
+    def no_error_validation(message)
+      assert messages.none? { |msg| msg[:type] == 'error' }, message
+    end
+
+    private
+
+    def request_number
+      if @request_number.blank?
+        ''
+      else
+        "Request #{@request_number}: "
+      end
+    end
+
     def hook_required_fields
       {
         'hook' => String,
@@ -51,16 +160,28 @@ module DaVinciCRDTestKit
         'encounter-start' => common_context_fields.merge('encounterId' => String),
         'encounter-discharge' => common_context_fields.merge('encounterId' => String),
         'order-select' => common_context_fields.merge('selections' => Array, 'draftOrders' => Hash),
-        'order-dispatch' => { 'patientId' => String, 'order' => String, 'performer' => String },
         'order-sign' => common_context_fields.merge('draftOrders' => Hash)
       }.freeze
     end
 
+    def context_required_order_dispatch_fields
+      {
+        'v201' => { 'patientId' => String, 'order' => String, 'performer' => String },
+        'v221' => { 'patientId' => String, 'dispatchedOrders' => Array, 'performer' => String }
+      }
+    end
+
+    def context_optional_order_dispatch_fields
+      {
+        'v201' => { 'task' => Hash },
+        'v221' => { 'fulfillmentTasks' => Array }
+      }
+    end
+
     def context_optional_fields_by_hook
       {
         'appointment-book' => { 'encounterId' => String },
         'order-select' => { 'encounterId' => String },
-        'order-dispatch' => { 'task' => Hash },
         'order-sign' => { 'encounterId' => String }
       }.freeze
     end
@@ -82,29 +203,7 @@ module DaVinciCRDTestKit
       }.freeze
     end
 
-    def structure_definition_map
-      {
-        'Practitioner' => 'http://hl7.org/fhir/us/davinci-crd/StructureDefinition/profile-practitioner',
-        'PractitionerRole' => 'http://hl7.org/fhir/us/core/StructureDefinition/us-core-practitionerrole',
-        'Patient' => 'http://hl7.org/fhir/us/davinci-crd/StructureDefinition/profile-patient',
-        'Encounter' => 'http://hl7.org/fhir/us/davinci-crd/StructureDefinition/profile-encounter',
-        'Appointment' => 'http://hl7.org/fhir/us/davinci-crd/StructureDefinition/profile-appointment',
-        'DeviceRequest' => 'http://hl7.org/fhir/us/davinci-crd/StructureDefinition/profile-devicerequest',
-        'MedicationRequest' => 'http://hl7.org/fhir/us/davinci-crd/StructureDefinition/profile-medicationrequest',
-        'NutritionOrder' => 'http://hl7.org/fhir/us/davinci-crd/StructureDefinition/profile-nutritionorder',
-        'ServiceRequest' => 'http://hl7.org/fhir/us/davinci-crd/StructureDefinition/profile-servicerequest',
-        'VisionPrescription' => 'http://hl7.org/fhir/us/davinci-crd/StructureDefinition/profile-visionprescription',
-        'Medication' => 'http://hl7.org/fhir/us/core/StructureDefinition/us-core-medication',
-        'Device' => 'http://hl7.org/fhir/us/davinci-crd/StructureDefinition/profile-device',
-        'CommunicationRequest' => 'http://hl7.org/fhir/us/davinci-crd/StructureDefinition/profile-communicationrequest',
-        'Task' => 'http://hl7.org/fhir/us/davinci-crd/StructureDefinition/profile-taskquestionnaire',
-        'Coverage' => 'http://hl7.org/fhir/us/davinci-crd/StructureDefinition/profile-coverage',
-        'Location' => 'http://hl7.org/fhir/us/davinci-crd/StructureDefinition/profile-location',
-        'Organization' => 'http://hl7.org/fhir/us/davinci-crd/StructureDefinition/profile-organization'
-      }.freeze
-    end
-
-    def hook_request_required_fields_check(request_body, hook_name)
+    def hook_request_required_fields_check_presence_and_types(request_body)
       hook_required_fields.each do |field, type|
         if request_body[field].blank?
           add_message('error', "#{request_number}Hook request did not contain required field: `#{field}`")
@@ -112,22 +211,10 @@ module DaVinciCRDTestKit
         end
 
         unless request_body[field].is_a?(type)
-          add_message('error', "#{request_number}Hook request field #{field} is not of type #{type}")
+          add_message('error', "#{request_number}Hook request field `#{field}` is not of type #{type}")
           next
         end
       end
-
-      if request_body['hook'] != hook_name
-        add_message('error',
-                    "#{request_number}The `hook` field should be #{hook_name}, but was #{request_body['hook']}")
-        return
-      end
-
-      return unless request_body['fhirAuthorization'].present? && request_body['fhirServer'].blank?
-
-      add_message('error', %(
-                  #{request_number}Missing `fhirServer` field: If `fhirAuthorization` is provided, this field is
-                  #REQUIRED.))
     end
 
     def fhir_auth_fields_valid?(fhir_authorization_required_fields, fhir_authorization)
@@ -138,10 +225,18 @@ module DaVinciCRDTestKit
           fhir_auth_valid = false
         end
         unless fhir_authorization[field].is_a?(type)
-          add_message('error', "#{request_number}`fhirAuthorization` field #{field} is not of type #{type}")
+          add_message('error', "#{request_number}`fhirAuthorization` field `#{field}` is not of type #{type}")
+          fhir_auth_valid = false
+        end
+      end
+
+      fhir_authorization.keys.reject { |field| fhir_authorization_required_fields.key?(field) }.each do |field|
+        if fhir_authorization[field].blank?
+          add_message('error', "#{request_number}`fhirAuthorization` field `#{field}` cannot be defined but blank.")
           fhir_auth_valid = false
         end
       end
+
       fhir_auth_valid
     end
 
@@ -174,20 +269,25 @@ module DaVinciCRDTestKit
       { fhir_server_uri: request_body['fhirServer'], fhir_access_token: access_token }
     end
 
-    def hook_request_optional_fields_check(request_body)
+    def hook_request_optional_fields_check_type(request_body)
       hook_optional_fields.each do |field, type|
-        info "#{request_number}Hook request did not contain optional field: `#{field}`" if request_body[field].blank?
+        if request_body[field].blank?
+          if request_body.key?(field)
+            add_message('error', "#{request_number}Hook request field `#{field}` cannot be defined but blank.")
+          else
+            info "#{request_number}Hook request did not contain optional field: `#{field}`"
+          end
+        end
 
         if request_body[field] && !request_body[field].is_a?(type)
-          add_message('error', "#{request_number}Hook request field #{field} is not of type #{type}")
+          add_message('error', "#{request_number}Hook request field `#{field}` is not of type #{type}")
         end
       end
-      hook_request_fhir_auth_check(request_body)
     end
 
-    def validate_presence_and_type(object, field_name, type, description = '')
+    def validate_presence_and_type(object, field_name, type, description = '', required: true)
       value = object[field_name]
-      unless value
+      if required && !value
         error_msg = "#{description} does not contain required field `#{field_name}`: #{description} `#{object}`."
         add_message('error', error_msg)
         return
@@ -197,44 +297,33 @@ module DaVinciCRDTestKit
       unless is_valid_type
         error_msg = type == 'URL' ? 'is not a valid URL' : "is not of type `#{type}`"
         add_message('error', "#{description} field `#{field_name}` #{error_msg}: #{description} `#{object}`.")
-        return
       end
 
-      return unless value.blank?
+      return if value.present?
 
       error_msg = "#{description} field `#{field_name}` should not be an empty #{type}: #{description} `#{object}`."
       add_message('error', error_msg)
     end
 
-    def hook_request_context_check(context, hook_name)
-      required_fields = context_required_fields_by_hook[hook_name]
-      required_fields.each do |field, type|
-        validate_presence_and_type(context, field, type,
-                                   "#{request_number}#{hook_name} request context")
-      end
-      context_validate_optional_fields(context, hook_name)
-      hook_specific_context_check(context, hook_name)
-    end
-
-    def hook_specific_context_check(context, hook_name)
+    def hook_specific_context_check(context, hook_name, ig_version: 'v201')
       case hook_name
       when 'appointment-book'
-        appointment_book_context_check(context)
+        appointment_book_context_check(context, ig_version:)
       when 'encounter-start', 'encounter-discharge'
-        encounter_start_or_discharge_context_check(context, hook_name)
+        encounter_start_or_discharge_context_check(context, hook_name, ig_version:)
       when 'order-select', 'order-sign'
-        order_select_or_sign_context_check(context, hook_name)
+        order_select_or_sign_context_check(context, hook_name, ig_version:)
       when 'order-dispatch'
-        order_dispatch_context_check(context)
+        order_dispatch_context_check(context, ig_version:)
       end
     end
 
-    def hook_user_type_check(context, hook_name)
+    def hook_user_type_check(context, hook_name, ig_version: 'v201')
       supported_resource_types = context_user_types_by_hook[hook_name]
-      resource_reference_check(context['userId'], 'userId', supported_resource_types:)
+      resource_reference_check(context['userId'], 'userId', supported_resource_types:, ig_version:)
     end
 
-    def resource_reference_check(reference, field_name, supported_resource_types: nil)
+    def resource_reference_check(reference, field_name, supported_resource_types: nil, ig_version: 'v201')
       return unless reference.is_a?(String) && valid_reference_format?(reference, field_name)
 
       resource_type, resource_id = reference.split('/')
@@ -248,7 +337,9 @@ module DaVinciCRDTestKit
         return
       end
 
-      query_and_validate_id_field(resource_type, resource_id) if client_test? && !field_name.include?('selections')
+      return unless client_test? && !field_name.include?('selections')
+
+      query_and_validate_id_field(resource_type, resource_id, ig_version:)
     end
 
     def valid_reference_format?(reference, field_name)
@@ -262,14 +353,14 @@ module DaVinciCRDTestKit
       false
     end
 
-    def id_only_fields_check(hook_name, context, id_fields)
+    def id_only_fields_check(hook_name, context, id_fields, ig_version: 'v201')
       id_fields.each do |field|
         resource_id = context[field]
         next unless resource_id.is_a?(String) && valid_id_format?(field, hook_name, resource_id)
 
         if client_test?
           resource_type = field.split(/(?=[A-Z])/).first.capitalize
-          query_and_validate_id_field(resource_type, resource_id)
+          query_and_validate_id_field(resource_type, resource_id, ig_version:)
         end
       end
     end
@@ -285,7 +376,7 @@ module DaVinciCRDTestKit
       true
     end
 
-    def bundle_entries_check(context, context_field_name, bundle, resource_types, status = nil)
+    def bundle_entries_check(context, context_field_name, bundle, resource_types, status = nil, ig_version: 'v201') # rubocop:disable Metrics/CyclomaticComplexity
       bundle.entry.each do |entry|
         resource_id = entry.resource.id
         next unless resource_id.blank?
@@ -305,7 +396,11 @@ module DaVinciCRDTestKit
       status_check(context, context_field_name, status, target_resources)
 
       target_resources.each do |resource|
-        resource_is_valid?(resource:, profile_url: structure_definition_map[resource.resourceType])
+        if resource.resourceType == 'Appointment' && ig_version == 'v221'
+          check_appointment_conformance(resource, { 'context' => context, 'fhirServer' => fhir_url }, '', '2.2.1')
+        else
+          resource_is_valid?(resource:, profile_url: structure_definition_map(ig_version)[resource.resourceType])
+        end
       end
     end
 
@@ -334,11 +429,12 @@ module DaVinciCRDTestKit
       nil
     end
 
-    def context_selections_check(context, selections, order_refs, expected_resource_types)
+    def context_selections_check(context, selections, order_refs, expected_resource_types, ig_version: 'v201')
       return unless selections.is_a?(Array)
 
       selections.each do |reference|
-        resource_reference_check(reference, 'selections item', supported_resource_types: expected_resource_types)
+        resource_reference_check(reference, 'selections item', supported_resource_types: expected_resource_types,
+                                                               ig_version:)
         next if order_refs.include?(reference)
 
         error_msg = "#{request_number}`selections` field must reference FHIR resources in `draftOrders`. " \
@@ -347,25 +443,26 @@ module DaVinciCRDTestKit
       end
     end
 
-    def appointment_book_context_check(context)
-      hook_user_type_check(context, 'appointment-book')
-      id_only_fields_check('appointment-book', context, ['patientId'])
+    def appointment_book_context_check(context, ig_version: 'v201')
+      hook_user_type_check(context, 'appointment-book', ig_version:)
+      id_only_fields_check('appointment-book', context, ['patientId'], ig_version:)
 
       appointment_bundle = parse_fhir_bundle_from_context('appointments', context)
       return if appointment_bundle.blank?
 
       expected_resource_types = ['Appointment']
-      bundle_entries_check(context, 'appointments', appointment_bundle, expected_resource_types, 'proposed')
+      bundle_entries_check(context, 'appointments', appointment_bundle, expected_resource_types, 'proposed',
+                           ig_version:)
     end
 
-    def encounter_start_or_discharge_context_check(context, hook_name)
-      hook_user_type_check(context, hook_name)
-      id_only_fields_check(hook_name, context, ['patientId', 'encounterId'])
+    def encounter_start_or_discharge_context_check(context, hook_name, ig_version: 'v201')
+      hook_user_type_check(context, hook_name, ig_version:)
+      id_only_fields_check(hook_name, context, ['patientId', 'encounterId'], ig_version:)
     end
 
-    def order_select_or_sign_context_check(context, hook_name)
-      hook_user_type_check(context, hook_name)
-      id_only_fields_check(hook_name, context, ['patientId'])
+    def order_select_or_sign_context_check(context, hook_name, ig_version: 'v201')
+      hook_user_type_check(context, hook_name, ig_version:)
+      id_only_fields_check(hook_name, context, ['patientId'], ig_version:)
 
       draft_orders_bundle = parse_fhir_bundle_from_context('draftOrders', context)
       return if draft_orders_bundle.blank?
@@ -375,28 +472,25 @@ module DaVinciCRDTestKit
         'ServiceRequest', 'VisionPrescription'
       ]
 
-      bundle_entries_check(context, 'draftOrders', draft_orders_bundle, expected_resource_types)
+      bundle_entries_check(context, 'draftOrders', draft_orders_bundle, expected_resource_types, ig_version:)
 
       return unless hook_name == 'order-select'
 
       order_refs = draft_orders_bundle.entry.map(&:resource).map do |resource|
         "#{resource.resourceType}/#{resource.id}"
       end
-      context_selections_check(context, context['selections'], order_refs, expected_resource_types)
+      context_selections_check(context, context['selections'], order_refs, expected_resource_types, ig_version:)
     end
 
-    def order_dispatch_context_check(context)
-      id_only_fields_check('order-dispatch', context, ['patientId'])
+    def order_dispatch_context_check(context, ig_version: 'v201')
+      id_only_fields_check('order-dispatch', context, ['patientId'], ig_version:)
       order_supported_resource_type = [
         'DeviceRequest', 'MedicationRequest', 'NutritionOrder',
         'ServiceRequest', 'VisionPrescription'
       ]
-      resource_reference_check(context['order'], 'order', supported_resource_types: order_supported_resource_type)
-      resource_reference_check(context['performer'], 'performer')
-    end
-
-    def no_error_validation(message)
-      assert messages.none? { |msg| msg[:type] == 'error' }, message
+      resource_reference_check(context['order'], 'order', supported_resource_types: order_supported_resource_type,
+                                                          ig_version:)
+      resource_reference_check(context['performer'], 'performer', ig_version:)
     end
 
     def valid_url?(url)
@@ -406,42 +500,55 @@ module DaVinciCRDTestKit
       false
     end
 
-    def query_and_validate_id_field(resource_type, resource_id)
+    def guid?(string)
+      uuid_regex = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i
+      uuid_regex.match?(string.to_s)
+    end
+
+    def query_and_validate_id_field(resource_type, resource_id, ig_version: 'v201')
       fhir_read(resource_type, resource_id)
       status = request.response[:status]
       unless status == 200
-        add_message('error', "#{request_number}Unexpected response status: expected 200, but received #{status}")
+        add_message('error',
+                    "#{request_number}Unexpected response status when reading '#{resource_type}/#{resource_id}': " \
+                    "expected 200, but received #{status}")
         return
       end
       unless resource.resourceType == resource_type
-        add_message('error', %(
-          #{request_number}Unexpected resource type: Expected `#{resource_type}`. Got
-          `#{resource.resourceType}`.
-        ))
+        add_message('error',
+                    "#{request_number}Unexpected resource type when reading '#{resource_type}/#{resource_id}': " \
+                    "#Expected `#{resource_type}`. Got `#{resource.resourceType}`.")
         return
       end
       unless resource.id == resource_id
-        add_message('error', %(
-          #{request_number}Requested resource with id #{resource_id}, received resource with id #{resource.id}
-          ))
+        add_message('error',
+                    "#{request_number}Unexpected resource id when reading '#{resource_type}/#{resource_id}': " \
+                    "Expected `#{resource_id}`. Got `#{resource.id}`.")
         return
       end
 
-      profile_url = hook_name == 'order-dispatch' ? nil : structure_definition_map[resource_type]
+      profile_url = hook_name == 'order-dispatch' ? nil : structure_definition_map(ig_version)[resource_type]
       resource_is_valid?(profile_url:)
     end
 
-    def context_validate_optional_fields(hook_context, hook_name)
-      hook_optional_context_fields = context_optional_fields_by_hook[hook_name]
+    def context_validate_optional_fields(hook_context, hook_name, ig_version: 'v201')
+      hook_optional_context_fields =
+        if hook_name == 'order-dispatch'
+          context_optional_order_dispatch_fields[ig_version]
+        else
+          context_optional_fields_by_hook[hook_name]
+        end
       return if hook_optional_context_fields.blank?
 
       hook_optional_context_fields.each do |field, type|
-        validate_presence_and_type(hook_context, field, type, "#{hook_name} request context") if hook_context[field]
+        if hook_context.key?(field)
+          validate_presence_and_type(hook_context, field, type, "#{hook_name} request context", required: false)
+        end
       end
 
       optional_field_keys = hook_optional_context_fields.keys
       if optional_field_keys.include?('encounterId') && hook_context['encounterId'].present?
-        id_only_fields_check(hook_name, hook_context, ['encounterId'])
+        id_only_fields_check(hook_name, hook_context, ['encounterId'], ig_version:)
       end
 
       validate_hash_fields(hook_context, optional_field_keys)
@@ -473,58 +580,11 @@ module DaVinciCRDTestKit
       end
     end
 
-    def hook_request_prefetch_check(advertised_prefetch_fields, received_prefetch, received_context)
-      advertised_prefetch_fields.each do |advertised_prefetch_key, advertised_prefetch_template|
-        next if received_prefetch[advertised_prefetch_key].blank?
-
-        unless received_prefetch[advertised_prefetch_key].is_a?(Hash)
-          add_message('error', "#{request_number}Prefetch field `#{advertised_prefetch_key}` is not of type `Hash`.")
-          next
-        end
-
-        received_prefetch_resource = FHIR.from_contents(received_prefetch[advertised_prefetch_key].to_json)
-
-        if advertised_prefetch_template.include?('?')
-          advertised_prefetch_fhir_search = advertised_prefetch_template.gsub(/{|}/, '').split('?')
-          advertised_prefetch_resource_type = advertised_prefetch_fhir_search.first
-
-          if advertised_prefetch_resource_type == 'Coverage'
-            advertised_coverage_query_params = Rack::Utils.parse_nested_query(advertised_prefetch_fhir_search.last)
-
-            advertised_patient_token = advertised_coverage_query_params['patient']
-            advertised_context_patient_id_key = advertised_patient_token.split('.').last
-            received_context_patient_id = received_context[advertised_context_patient_id_key]
-
-            advertised_status_param = advertised_coverage_query_params['status']
-
-            validate_prefetch_coverage(received_prefetch_resource, advertised_prefetch_key, received_context_patient_id,
-                                       advertised_status_param)
-          end
-        else
-          advertised_prefetch_token = advertised_prefetch_template.gsub(/{|}/, '').split('/')
-          advertised_context_id = advertised_prefetch_token.last.split('.').last
-
-          if advertised_prefetch_token.length == 1
-            received_context_reference = FHIR::Reference.new(reference: received_context[advertised_context_id])
-            received_context_resource_type = received_context_reference.resource_type
-            received_context_id = received_context_reference.reference_id
-          else
-            received_context_id = received_context[advertised_context_id]
-            received_context_resource_type = advertised_prefetch_token.first
-          end
-          validate_prefetch_resource(received_prefetch_resource, advertised_prefetch_key,
-                                     received_context_resource_type, received_context_id)
-        end
-      end
-    end
-
-    def validate_prefetch_coverage(received_resource, advertised_prefetch_key,
-                                   received_context_patient_id, advertised_status)
+    def validate_prefetch_coverages(received_resource, advertised_prefetch_key,
+                                    received_context_patient_id, advertised_status, ig_version: 'v201')
       unless received_resource.resourceType == 'Bundle'
-        add_message('error', %(
-          #{request_number}Unexpected resource type: Expected `Bundle`. Got
-          `#{received_resource.resourceType}`.
-        ))
+        add_message('error', "#{request_number}Unexpected resource type: Expected `Bundle`. Got " \
+                             "`#{received_resource.resourceType}`.")
         return
       end
 
@@ -533,76 +593,95 @@ module DaVinciCRDTestKit
         return
       end
 
-      coverage_resource = received_resource.entry.first.resource
+      if received_context_patient_id.blank?
+        add_message('error',
+                    "#{request_number}Cannot verify `coverage` patient id because no id provided in the context.")
+      end
+
+      received_resource.entry.each_with_index do |entry, index|
+        validate_prefetch_coverage(entry&.resource, advertised_prefetch_key,
+                                   received_context_patient_id, advertised_status, index, ig_version:)
+      end
+    end
+
+    def validate_prefetch_coverage(coverage_resource, advertised_prefetch_key,
+                                   received_context_patient_id, advertised_status, entry_index, ig_version: 'v201')
+      unless coverage_resource.present?
+        add_message('error', "#{request_number}Coverage Bundle entry #{entry_index + 1} had no resource")
+        return
+      end
+
       unless coverage_resource.resourceType == 'Coverage'
-        add_message('error', %(
-          #{request_number}Unexpected resource type: Expected `Coverage`. Got
-          `#{coverage_resource.resourceType}`.
-        ))
+        add_message('error', "#{request_number}Coverage Bundle entry #{entry_index + 1} - Unexpected resource type: " \
+                             "Expected `Coverage`. Got `#{coverage_resource.resourceType}`.")
         return
       end
 
       resource_is_valid?(resource: coverage_resource,
-                         profile_url: structure_definition_map['Coverage'])
+                         profile_url: structure_definition_map(ig_version)['Coverage'])
 
       coverage_beneficiary_reference = coverage_resource.beneficiary
       coverage_beneficiary_patient_id = coverage_beneficiary_reference.reference_id
       if coverage_beneficiary_patient_id.blank?
-        add_message('error', %(
-          #{request_number}Could not get beneficiary reference id from `#{advertised_prefetch_key}` field's Coverage
-          resource
-        ))
+        add_message('error', "#{request_number}Coverage Bundle entry #{entry_index + 1} - Could not get beneficiary " \
+                             "reference id from `#{advertised_prefetch_key}` field's Coverage resource")
         return
       end
 
-      if coverage_beneficiary_patient_id != received_context_patient_id
-        add_message('error', %(
-          #{request_number}Expected `#{advertised_prefetch_key}` field's Coverage resource to have a `beneficiary`
-          reference id of '#{received_context_patient_id}', instead was '#{coverage_beneficiary_patient_id}'
-        ))
+      if received_context_patient_id.present? && coverage_beneficiary_patient_id != received_context_patient_id
+        add_message('error', "#{request_number}Coverage Bundle entry #{entry_index + 1} - " \
+                             "Expected `#{advertised_prefetch_key}` field's Coverage resource to have a " \
+                             "`beneficiary` reference id of '#{received_context_patient_id}', " \
+                             "instead was '#{coverage_beneficiary_patient_id}`")
         return
       end
 
       coverage_status = coverage_resource.status
       return unless coverage_status != advertised_status
 
-      add_message('error', %(
-          #{request_number}Expected `#{advertised_prefetch_key}` field's Coverage resource to have a `status` of
-          '#{advertised_status}', instead was '#{coverage_status}'
-        ))
+      add_message('error', "#{request_number}Coverage Bundle entry #{entry_index + 1} - " \
+                           "Expected `#{advertised_prefetch_key}` field's Coverage resource to have a `status` of " \
+                           "'#{advertised_status}', instead was '#{coverage_status}'")
     end
 
     def validate_prefetch_resource(received_resource, advertised_prefetch_key, context_field_resource_type,
-                                   context_field_id)
-      unless received_resource.resourceType == context_field_resource_type
-        add_message('error', %(
-          #{request_number}Unexpected resource type: Expected `#{context_field_resource_type}`. Got
-          `#{received_resource.resourceType}`.
-        ))
-        return
-      end
+                                   context_field_id, ig_version: 'v201')
+      return unless prefetch_resource_type_correct?(received_resource, context_field_resource_type,
+                                                    "#{request_number}`#{advertised_prefetch_key}` - ")
 
       if hook_name == 'order-dispatch'
         resource_is_valid?(resource: received_resource)
       else
         resource_is_valid?(resource: received_resource,
-                           profile_url: structure_definition_map[context_field_resource_type])
+                           profile_url: structure_definition_map(ig_version)[context_field_resource_type])
       end
 
-      received_prefetch_resource_id = received_resource.id
-      if received_prefetch_resource_id.blank?
-        add_message('error', %(
-          #{request_number}#{advertised_prefetch_key}` field's FHIR resource does not contain the `id` field
-        ))
-        return
+      prefetch_resource_id_correct?(received_resource, context_field_id,
+                                    "#{request_number}`#{advertised_prefetch_key}` - ")
+    end
+
+    def prefetch_resource_type_correct?(resource, expected_type, error_prefix)
+      if expected_type.present?
+        return true if resource.resourceType == expected_type
+
+        add_message(:error, "#{error_prefix}Prefetched resource has the wrong resource type. " \
+                            "Expected `#{expected_type}`, got `#{resource.resourceType}`.")
+      else
+        add_message(:error, "#{error_prefix}No resource type provided to verify prefetched resource against.")
       end
+      false
+    end
 
-      return unless received_prefetch_resource_id != context_field_id
+    def prefetch_resource_id_correct?(resource, expected_id, error_prefix)
+      if expected_id.present?
+        return true if resource.id == expected_id
 
-      add_message('error', %(
-        #{request_number}Expected `#{advertised_prefetch_key}` field's FHIR resource to have an `id` of
-        '#{context_field_id}', instead was '#{received_prefetch_resource_id}'
-      ))
+        add_message(:error, "#{error_prefix}Prefetched resource has the wrong resource id. " \
+                            "Expected `#{expected_id}`, got `#{resource.id}`.")
+      else
+        add_message(:error, "#{error_prefix}No resource id provided to verify prefetched resource against.")
+      end
+      false
     end
   end
 end