davinci_crd_test_kit 0.9.0 → 0.9.1

data/lib/davinci_crd_test_kit/client_tests/encounter_start_receive_request_test.rb

@@ -7,10 +7,11 @@ module DaVinciCRDTestKit
     id :crd_encounter_start_request
     title 'Request received for encounter-start hook'
     description %(
-      This test waits for an incoming [encounter-start](https://hl7.org/fhir/us/davinci-crd/STU2/hooks.html#encounter-start)
-      hook request and responds to the client with the response types selected as an input.
+      This test waits for multiple incoming [encounter-start](https://hl7.org/fhir/us/davinci-crd/STU2/hooks.html#encounter-start)
+      hook requests and responds to the client with the response types selected as an input.
       )
-    receives_request :encounter_start
+
+    config options: { accepts_multiple_requests: true }
 
     input :iss
     input :encounter_start_selected_response_types,
@@ -20,7 +21,8 @@ module DaVinciCRDTestKit
             response type that will be returned for this hook is the `Instructions` card type.
           ),
           type: 'checkbox',
-          default: ['instructions'],
+          default: ['coverage_information', 'external_reference', 'instructions'],
+          optional: true,
           options: {
             list_options: [
               {
@@ -49,6 +51,14 @@ module DaVinciCRDTestKit
               }
             ]
           }
+    input :encounter_start_custom_response,
+          title: 'Custom response for encounter-start hook requests',
+          description: %(
+            A JSON string may be provided here to replace the normal response
+            from the hook request endpoint
+          ),
+          type: 'textarea',
+          optional: true
 
     run do
       wait(
@@ -56,11 +66,13 @@ module DaVinciCRDTestKit
         message: %(
           **Encounter Start CDS Service Test**:
 
-          Invoke the encounter-start hook and send a request to:
+          Invoke the encounter-start hook and send requests to:
 
           `#{encounter_start_url}`
 
-          Inferno will process the request and return CDS cards if successful.
+          Inferno will process the requests and return CDS cards if successful.
+
+          [Click here](#{resume_pass_url}?token=enounter-start%20#{iss}) when you have finished submitting requests.
         )
       )
     end

data/lib/davinci_crd_test_kit/client_tests/hook_request_optional_fields_test.rb

@@ -2,7 +2,8 @@ require_relative '../client_hook_request_validation'
 
 module DaVinciCRDTestKit
   class HookRequestOptionalFieldsTest < Inferno::Test
-    include DaVinciCRDTestKit::ClientHookRequestValidation
+    include ClientHookRequestValidation
+    include URLs
 
     id :crd_hook_request_optional_fields
     title 'Hook request contains optional fields'
@@ -22,20 +23,35 @@ module DaVinciCRDTestKit
     )
     optional
 
+    def hook_name
+      config.options[:hook_name]
+    end
+
     output :client_fhir_server
     output :client_access_token,
            optional: true
 
-    uses_request :hook_request
-
     run do
-      assert_valid_json(request.request_body)
-      request_body = JSON.parse(request.request_body)
-
-      client_fhir_server = hook_request_optional_fields_check(request_body)
-
-      output client_fhir_server: client_fhir_server[:fhir_server_uri],
-             client_access_token: client_fhir_server[:fhir_access_token]
+      load_tagged_requests(hook_name)
+      skip_if requests.empty?, "No #{hook_name} requests were made in a previous test as expected."
+      client_fhir_server = nil
+      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
+
+        fhir_server_info = hook_request_optional_fields_check(request_body)
+        client_fhir_server ||= fhir_server_info
+      end
+
+      unless client_fhir_server.nil?
+        output client_fhir_server: client_fhir_server[:fhir_server_uri],
+               client_access_token: client_fhir_server[:fhir_access_token]
+      end
+      no_error_validation('Some service requests contain invalid optional fields.')
     end
   end
 end

data/lib/davinci_crd_test_kit/client_tests/hook_request_required_fields_test.rb

@@ -2,7 +2,7 @@ require_relative '../client_hook_request_validation'
 
 module DaVinciCRDTestKit
   class HookRequestRequiredFieldsTest < Inferno::Test
-    include DaVinciCRDTestKit::ClientHookRequestValidation
+    include ClientHookRequestValidation
     include URLs
 
     id :crd_hook_request_required_fields
@@ -20,21 +20,30 @@ module DaVinciCRDTestKit
         a request for
     )
 
-    uses_request :hook_request
-
-    def hook_url
-      base_url + config.options[:hook_path]
-    end
-
     def hook_name
       config.options[:hook_name]
     end
 
-    run do
-      assert_valid_json(request.request_body)
-      request_body = JSON.parse(request.request_body)
+    output :contexts, :prefetches
 
-      hook_request_required_fields_check(request_body, hook_name)
+    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)
+      end
+
+      output contexts: contexts.to_json,
+             prefetches: prefetches.to_json
+      no_error_validation('Some service requests made are not valid.')
     end
   end
 end

data/lib/davinci_crd_test_kit/client_tests/hook_request_valid_context_test.rb

@@ -1,4 +1,5 @@
 require_relative '../client_hook_request_validation'
+
 module DaVinciCRDTestKit
   class HookRequestValidContextTest < Inferno::Test
     include URLs
@@ -33,9 +34,8 @@ module DaVinciCRDTestKit
       The client must provide its FHIR server URL and access token in the hook request in order to run
       this test.
     )
-    uses_request :hook_request
 
-    input :client_fhir_server
+    input :contexts, :client_fhir_server
     input :client_access_token,
           optional: true
 
@@ -49,14 +49,18 @@ module DaVinciCRDTestKit
     end
 
     run do
-      assert_valid_json(request.request_body)
-      request_body = JSON.parse(request.request_body)
-
-      hook_context = request_body['context']
-
-      assert(hook_context, 'Hook request does not contain required `context` field')
-
-      hook_request_context_check(hook_context, hook_name)
+      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)
+        end
+      end
       no_error_validation('Context is not valid.')
     end
   end

data/lib/davinci_crd_test_kit/client_tests/hook_request_valid_prefetch_test.rb

@@ -1,7 +1,8 @@
-require_relative '../urls'
+require_relative '../client_hook_request_validation'
 
 module DaVinciCRDTestKit
   class HookRequestValidPrefetchTest < Inferno::Test
+    include ClientHookRequestValidation
     include URLs
 
     id :crd_hook_request_valid_prefetch
@@ -19,7 +20,7 @@ module DaVinciCRDTestKit
     )
     optional
 
-    uses_request :hook_request
+    input :contexts, :prefetches
 
     def hook_name
       config.options[:hook_name]
@@ -31,121 +32,37 @@ module DaVinciCRDTestKit
                            )))['services']
     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',
-        'Coverage' => 'http://hl7.org/fhir/us/davinci-crd/StructureDefinition/profile-coverage',
-        'RelatedPerson' => 'http://hl7.org/fhir/StructureDefinition/RelatedPerson',
-        'Encounter' => 'http://hl7.org/fhir/us/davinci-crd/StructureDefinition/profile-encounter',
-        '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'
-      }
-    end
-
-    def validate_prefetch_coverage(received_resource, advertised_prefetch_key,
-                                   received_context_patient_id, advertised_status)
-      assert_resource_type('Bundle', resource: received_resource)
-      assert(received_resource.entry.any?, 'Bundle of coverage resources received from prefetch is empty')
-      coverage_resource = received_resource.entry.first.resource
-      assert_resource_type('Coverage', resource: coverage_resource)
-      assert_valid_resource(resource: coverage_resource,
-                            profile_url: structure_definition_map['Coverage'])
-
-      coverage_beneficiary_reference = coverage_resource.beneficiary
-      coverage_beneficiary_patient_id = coverage_beneficiary_reference.reference_id
-      assert(coverage_beneficiary_patient_id.present?,
-             "Could not get beneficiary reference id from `#{advertised_prefetch_key}` field's Coverage resource")
-
-      assert(coverage_beneficiary_patient_id == received_context_patient_id,
-             %(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}'))
-
-      coverage_status = coverage_resource.status
-      assert(coverage_status == advertised_status,
-             %(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)
-      assert_resource_type(context_field_resource_type, resource: received_resource)
-
-      if hook_name == 'order-dispatch'
-        assert_valid_resource(resource: received_resource)
-      else
-        assert_valid_resource(resource: received_resource,
-                              profile_url: structure_definition_map[context_field_resource_type])
-      end
-
-      received_prefetch_resource_id = received_resource.id
-      assert(received_prefetch_resource_id.present?,
-             "`#{advertised_prefetch_key}` field's FHIR resource does not contain the `id` field")
-      assert(received_prefetch_resource_id == context_field_id,
-             %(Expected `#{advertised_prefetch_key}` field's FHIR resource to have an `id` of '#{context_field_id}',
-             instead was '#{received_prefetch_resource_id}'))
+    def advertised_prefetch_fields
+      advertised_hook_service = cds_services_json.find { |service| service['hook'] == hook_name }
+      advertised_hook_service['prefetch']
     end
 
     run do
-      assert_valid_json(request.request_body)
-      request_body = JSON.parse(request.request_body)
-
-      received_prefetch = request_body['prefetch']
-      received_context = request_body['context']
-
-      skip_if received_prefetch.blank?, 'Received hook request does not contain the `prefetch` field.'
-      skip_if received_context.blank?,
-              %(Received hook request does not contain the `context` field which is needed to validate the `prefetch`
-              field)
-
-      advertised_hook_service = cds_services_json.find { |service| service['hook'] == hook_name }
-
-      advertised_prefetch_fields = advertised_hook_service['prefetch']
-
-      advertised_prefetch_fields.each do |advertised_prefetch_key, advertised_prefetch_template|
-        next unless received_prefetch[advertised_prefetch_key].present?
-
-        assert(received_prefetch[advertised_prefetch_key].is_a?(Hash),
-               "Prefetch field `#{advertised_prefetch_key}` is not of type `Hash`.")
-
-        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)
+      hook_contexts = json_parse(contexts)
+      hook_prefetches = json_parse(prefetches)
+
+      if hook_contexts && hook_prefetches
+        skip_if(hook_prefetches.none? do |prefetch|
+          prefetch_index = hook_prefetches.find_index(prefetch)
+          prefetch.present? && hook_contexts[prefetch_index].present?
+        end, "No #{hook_name} requests contained both the `context` and `prefetch` field.")
+
+        hook_prefetches.each_with_index do |prefetch, index|
+          @request_number = index + 1
+          context = hook_contexts[index]
+
+          info "#{request_number}Received hook request does not contain the `prefetch` field." if prefetch.blank?
+          if context.blank?
+            info %(#{request_number}Received hook request does not contain the `context` field
+            which is needed to validate the `prefetch` field)
           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)
+          next if prefetch.blank? || context.blank?
+
+          hook_request_prefetch_check(advertised_prefetch_fields, prefetch, context)
         end
       end
+      no_error_validation('Prefetch is not valid.')
     end
   end
 end

data/lib/davinci_crd_test_kit/client_tests/order_dispatch_receive_request_test.rb

@@ -7,13 +7,14 @@ module DaVinciCRDTestKit
     id :crd_order_dispatch_request
     title 'Request received for order-dispatch hook'
     description %(
-        This test waits for an incoming [order-dispatch](https://hl7.org/fhir/us/davinci-crd/STU2/hooks.html#order-dispatch)
-        hook request and responds to the client with the response types selected as an input. This hook is a 'primary'
+        This test waits for multiple incoming [order-dispatch](https://hl7.org/fhir/us/davinci-crd/STU2/hooks.html#order-dispatch)
+        hook requests and responds to the client with the response types selected as an input. This hook is a 'primary'
         hook, meaning that CRD Servers SHALL, at minimum, return a [Coverage Information](https://hl7.org/fhir/us/davinci-crd/STU2/StructureDefinition-ext-coverage-information.html)
         system action for these hooks, even if the response indicates that further information is needed or that the
         level of detail provided is insufficient to determine coverage.
       )
-    receives_request :order_dispatch
+
+    config options: { accepts_multiple_requests: true }
 
     input :iss
     input :order_dispatch_selected_response_types,
@@ -23,7 +24,8 @@ module DaVinciCRDTestKit
             response type that will be returned for this hook is the `Coverage Information` card type.
           ),
           type: 'checkbox',
-          default: ['coverage_information'],
+          default: ['coverage_information', 'external_reference', 'instructions'],
+          optional: true,
           options: {
             list_options: [
               {
@@ -60,6 +62,14 @@ module DaVinciCRDTestKit
               }
             ]
           }
+    input :order_dispatch_custom_response,
+          title: 'Custom response for order-dispatch hook requests',
+          description: %(
+            A JSON string may be provided here to replace the normal response
+            from the hook request endpoint
+          ),
+          type: 'textarea',
+          optional: true
 
     run do
       wait(
@@ -67,11 +77,13 @@ module DaVinciCRDTestKit
         message: %(
           **Order Dispatch CDS Service Test**:
 
-          Invoke the order-dispatch hook and send a request to:
+          Invoke the order-dispatch hook and send requests to:
 
           `#{order_dispatch_url}`
 
-          Inferno will process the request and return CDS cards if successful.
+          Inferno will process the requests and return CDS cards if successful.
+
+          [Click here](#{resume_pass_url}?token=order-dispatch%20#{iss}) when you have finished submitting requests.
         )
       )
     end

data/lib/davinci_crd_test_kit/client_tests/order_select_receive_request_test.rb

@@ -7,10 +7,11 @@ module DaVinciCRDTestKit
     id :crd_order_select_request
     title 'Request received for order-select hook'
     description %(
-      This test waits for an incoming [order-select](https://hl7.org/fhir/us/davinci-crd/STU2/hooks.html#order-select)
-      hook request and responds to the client with the response types selected as an input.
+      This test waits for multiple incoming [order-select](https://hl7.org/fhir/us/davinci-crd/STU2/hooks.html#order-select)
+      hook requests and responds to the client with the response types selected as an input.
       )
-    receives_request :order_select
+
+    config options: { accepts_multiple_requests: true }
 
     input :iss
     input :order_select_selected_response_types,
@@ -20,7 +21,8 @@ module DaVinciCRDTestKit
             response type that will be returned for this hook is the `Instructions` card type.
           ),
           type: 'checkbox',
-          default: ['instructions'],
+          default: ['coverage_information', 'external_reference', 'instructions'],
+          optional: true,
           options: {
             list_options: [
               {
@@ -57,6 +59,14 @@ module DaVinciCRDTestKit
               }
             ]
           }
+    input :order_select_custom_response,
+          title: 'Custom response for order-select hook requests',
+          description: %(
+            A JSON string may be provided here to replace the normal response
+            from the hook request endpoint
+          ),
+          type: 'textarea',
+          optional: true
 
     run do
       wait(
@@ -64,11 +74,13 @@ module DaVinciCRDTestKit
         message: %(
           **Order Select CDS Service Test**:
 
-          Invoke the order-select hook and send a request to:
+          Invoke the order-select hook and send requests to:
 
           `#{order_select_url}`
 
-          Inferno will process the request and return CDS cards if successful.
+          Inferno will process the requests and return CDS cards if successful.
+
+          [Click here](#{resume_pass_url}?token=order-select%20#{iss}) when you have finished submitting requests.
         )
       )
     end

data/lib/davinci_crd_test_kit/client_tests/order_sign_receive_request_test.rb

@@ -7,13 +7,14 @@ module DaVinciCRDTestKit
     id :crd_order_sign_request
     title 'Request received for order-sign hook'
     description %(
-        This test waits for an incoming [order-sign](https://hl7.org/fhir/us/davinci-crd/STU2/hooks.html#order-sign)
-        hook request and responds to the client with the response types selected as an input. This hook is a 'primary'
+        This test waits for multiple incoming [order-sign](https://hl7.org/fhir/us/davinci-crd/STU2/hooks.html#order-sign)
+        hook requests and responds to the client with the response types selected as an input. This hook is a 'primary'
         hook, meaning that CRD Servers SHALL, at minimum, return a [Coverage Information](https://hl7.org/fhir/us/davinci-crd/STU2/StructureDefinition-ext-coverage-information.html)
         system action for these hooks, even if the response indicates that further information is needed or that the
         level of detail provided is insufficient to determine coverage.
       )
-    receives_request :order_sign
+
+    config options: { accepts_multiple_requests: true }
 
     input :iss
     input :order_sign_selected_response_types,
@@ -23,7 +24,8 @@ module DaVinciCRDTestKit
             response type that will be returned for this hook is the `Coverage Information` card type.
           ),
           type: 'checkbox',
-          default: ['coverage_information'],
+          default: ['coverage_information', 'external_reference', 'instructions'],
+          optional: true,
           options: {
             list_options: [
               {
@@ -60,6 +62,14 @@ module DaVinciCRDTestKit
               }
             ]
           }
+    input :order_sign_custom_response,
+          title: 'Custom response for order-sign hook requests',
+          description: %(
+            A JSON string may be provided here to replace the normal response
+            from the hook request endpoint
+          ),
+          type: 'textarea',
+          optional: true
 
     run do
       wait(
@@ -67,11 +77,13 @@ module DaVinciCRDTestKit
         message: %(
           **Order Sign CDS Service Test**:
 
-          Invoke the order-sign hook and send a request to:
+          Invoke the order-sign hook and send requests to:
 
           `#{order_sign_url}`
 
-          Inferno will process the request and return CDS cards if successful.
+          Inferno will process the requests and return CDS cards if successful.
+
+          [Click here](#{resume_pass_url}?token=order-sign%20#{iss}) when you have finished submitting requests.
         )
       )
     end