davinci_dtr_test_kit 0.11.0 → 0.12.0

data/lib/davinci_dtr_test_kit/client_groups/resp_assist_device/dtr_resp_questionnaire_package_request_test.rb

@@ -10,39 +10,76 @@ module DaVinciDTRTestKit
       Inferno will wait for a DTR questionnaire package request from the client. Upon receipt, Inferno will generate and
       send a response.
     )
-    input :smart_app_launch, type: 'radio', title: 'SMART App Launch',
-                             description: 'How will the DTR SMART App launch?',
-                             options: { list_options: [{ label: 'Launch from Inferno', value: 'inferno' },
-                                                       { label: 'Launch from EHR', value: 'ehr' }] }
+    input :smart_app_launch,
+          type: 'radio',
+          title: 'SMART App Launch',
+          description: 'How will the DTR SMART App launch?',
+          options: { list_options: [{ label: 'EHR Launch from Inferno', value: 'ehr' },
+                                    { label: 'Standalone Launch', value: 'standalone' }] }
     input :client_id
-    input :launch_uri, optional: true, description: 'Required if "Launch from Inferno" is selected'
-    input :smart_patient_id, optional: true, title: 'SMART App Launch Patient ID (Respiratory Assist Device)',
-                             type: 'text',
-                             description: %(
-                               Patient instance id to be provided by Inferno as the `patient` as a part of the SMART app
-                               launch.
-                             )
-    input :smart_fhir_context, optional: true, title: 'SMART App Launch fhirContext (Respiratory Assist Device)',
-                               type: 'textarea',
-                               description: %(
-                                 References to be provided by Inferno as the `fhirContext` as a part of the SMART app
-                                 launch. These references help determine the behavior of the app. Referenced instances
-                                 may be providedin the "EHR-available resources" input.
-                               )
-    input :ehr_bundle, optional: true, title: 'EHR-available resources (Respiratory Assist Device)', type: 'textarea',
-                       description: %(
-                                 Resources available from the EHR needed to drive the respiratory assist device
-                                 workflow. Formatted as a FHIR bundle that contains resources, each with an `id`
-                                 property populated. Each instance present will be available for retrieval from
-                                 Inferno at the endpoint `[fhir-base]/[resource type]/[instance id].`
-                               )
+    input :launch_uri,
+          optional: true,
+          description: 'Required if "Launch from Inferno" is selected'
+    input :smart_patient_id,
+          optional: true,
+          title: 'SMART App Launch Patient ID (Respiratory Assist Device)',
+          type: 'text',
+          description: %(
+            Patient instance `id` to be provided by Inferno as the `patient` as a part of the SMART App
+            Launch.
+          ),
+          default: 'pat015'
+    input :smart_fhir_context,
+          optional: true,
+          title: 'SMART App Launch fhirContext (Respiratory Assist Device)',
+          type: 'textarea',
+          description: %(
+            References to be provided by Inferno as the `fhirContext` as a part of the SMART App
+            Launch. These references help determine the behavior of the app. Referenced instances
+            may be provided in the "EHR-available resources" input.
+          ),
+          default: JSON.pretty_generate([{ reference: 'Coverage/cov015' },
+                                         { reference: 'DeviceRequest/devreqe0470' }])
+    input :ehr_bundle,
+          optional: true,
+          title: 'EHR-available resources (Respiratory Assist Device)',
+          type: 'textarea',
+          description: %(
+            Resources available from the EHR needed to drive the respiratory assist device workflow.
+            Formatted as a FHIR bundle that contains resources, each with an `id` property populated. Each
+            instance present will be available for retrieval from Inferno at the endpoint
+
+            ```
+            [fhir-base]/[resource type]/[instance id]
+            ```
+          )
 
     def example_client_jwt_payload_part
       Base64.strict_encode64({ inferno_client_id: client_id }.to_json).delete('=')
     end
 
     run do
-      launch_prompt = if smart_app_launch == 'inferno'
+      # validate relevant inputs and provide warnings if they are bad
+      warning do
+        if smart_fhir_context
+          assert_valid_json(smart_fhir_context,
+                            'The **SMART App Launch fhirContext** input is not valid JSON, so it will not be included in
+                            the access token response.')
+        end
+      end
+
+      warning do
+        if ehr_bundle
+          assert_valid_json(ehr_bundle,
+                            'The **EHR-available resources** input is not valid JSON, so no tester-specified instances
+                              will be available to access from Inferno.')
+          assert(FHIR.from_contents(ehr_bundle).is_a?(FHIR::Bundle),
+                 'The **EHR-available resources** input does not contain a FHIR Bundle, so no tester-specified instances
+                 will be available to access from Inferno.')
+        end
+      end
+
+      launch_prompt = if smart_app_launch == 'ehr'
                         %(Launch the DTR SMART App from Inferno by right clicking
                           [this link](#{launch_uri}?iss=#{fhir_base_url}&launch=#{launch_uri})
                           and selecting or "Open in new window" or "Open in new tab".)
@@ -58,7 +95,7 @@ module DaVinciDTRTestKit
 
           #{launch_prompt}
 
-          #{inferno_prompt_cont if smart_app_launch == 'inferno'}
+          #{inferno_prompt_cont if smart_app_launch == 'ehr'}
 
           Then, Inferno will expect the SMART App to invoke the DTR Questionnaire Package operation by sending a POST
           request to

data/lib/davinci_dtr_test_kit/client_groups/shared/dtr_questionnaire_package_request_validation_test.rb

@@ -29,7 +29,7 @@ module DaVinciDTRTestKit
       assert input_params.present?, 'Request does not contain a recognized FHIR object'
       assert_resource_type(:parameters, resource: input_params)
       assert_valid_resource(resource: input_params,
-                            profile_url: 'http://hl7.org/fhir/us/davinci-dtr/StructureDefinition/dtr-qpackage-input-parameters')
+                            profile_url: 'http://hl7.org/fhir/us/davinci-dtr/StructureDefinition/dtr-qpackage-input-parameters|2.0.1')
     end
   end
 end

data/lib/davinci_dtr_test_kit/client_groups/shared/dtr_questionnaire_response_basic_conformance_test.rb

@@ -22,7 +22,7 @@ module DaVinciDTRTestKit
       assert_resource_type(:questionnaire_response, resource: questionnaire_response)
 
       assert_valid_resource(resource: questionnaire_response,
-                            profile_url: 'http://hl7.org/fhir/us/davinci-dtr/StructureDefinition/dtr-questionnaireresponse')
+                            profile_url: 'http://hl7.org/fhir/us/davinci-dtr/StructureDefinition/dtr-questionnaireresponse|2.0.1')
     end
   end
 end

data/lib/davinci_dtr_test_kit/client_groups/shared/dtr_questionnaire_response_pre_population_test.rb

@@ -21,6 +21,7 @@ module DaVinciDTRTestKit
     )
 
     run do
+      assert_valid_json(request.request_body)
       questionnaire_response = FHIR.from_contents(request.request_body)
       skip_if !questionnaire_response.present?, 'QuestionnaireResponse not received'
 

data/lib/davinci_dtr_test_kit/docs/dtr_full_ehr_suite_description_v201.md

@@ -0,0 +1,127 @@
+The Da Vinci DTR Test Kit Full EHR Suite validates the conformance of SMART apps
+to the STU 2 version of the HL7® FHIR®
+[Da Vinci Documentation Templates and Rules (DTR) Implementation Guide](https://hl7.org/fhir/us/davinci-dtr/STU2/).
+
+## Scope
+
+These tests are a **DRAFT** intended to allow app implementers to perform
+preliminary checks of their systems against DTR IG requirements and [provide
+feedback](https://github.com/inferno-framework/davinci-dtr-test-kit/issues)
+on the tests. Future versions of these tests may validate other
+requirements and may change the test validation logic.
+
+## Test Methodology
+
+Inferno will simulate a DTR payer server that will response to
+requests for questionnaires for the EHR under test to interact with. 
+The EHR will be expected to initiate requests to Inferno to elicit responses. Over the
+course of these interactions, Inferno will seek to observe conformant handling of 
+DTR workflows and requirements around the retrieval, completion, and storage of
+questionnaires.
+
+Tests within this suite are associated with specific questionnaires that the EHR will
+demonstrate completion of. In each case, the EHR under test will initiate a request to
+the payer server simulated by Inferno for a questionnaire using the 
+`$questionnaire-package` operation. Inferno will always return the specific questionnaire
+for the test being executed regardless of the input provided by the EHR, though it must
+be conformant. The EHR will then be asked to complete the questionnaire, including
+- Pre-populating answers based on directives in the questionnaire
+- Rendering the questionnaire for users and allowing them to make additional updates.
+  These tests can include specific directions on details to include in the completed
+  questionnaire.
+- Storing the completed questionnaire for future use as a FHIR QuestionnaireResponse.
+
+EHRs will be required to complete all questionnaires in the suite, which in aggregate
+contain all questionnaire features that apps must support. Currently, the suite includes
+one questionnaire:
+1. A fictious "dinner" questionnaire created for these tests. It tests basic
+   item rendering and pre-population.
+Additional questionnaires will be added in the future.
+
+All requests sent by the app will be checked 
+for conformance to the DTR IG requirements individually and used in aggregate to determine
+whether required features and functionality are present. HL7® FHIR® resources are
+validated with the Java validator using `tx.fhir.org` as the terminology server.
+
+## Running the Tests
+
+### Quick Start
+
+In order to run these tests, EHRs must be configured to interact with Inferno's simulated
+payer server endpoint. The endpoint will be `[URL prefix]/custom/dtr_full_ehr/fhir` where
+`[URL prefix]` can be inferred from the URL of the test session which will be of the form 
+`[URL prefix]/dtr_full_ehr/[session id]`.
+
+In order for Inferno to associate requests sent to locations under these base URLs with this session,
+it needs to know the bearer token that the EHR will send on requests, for which 
+there are two options.
+
+1. If you want to choose your own bearer token, then
+    1. Select the "2. Basic Workflows" test from the list on the left (or other target test). 
+    2. Click the '*Run All Tests*' button on the right.
+    3. In the "access_token" field, enter the bearer token that will be sent by the client 
+       under test (as part of the Authorization header - `Bearer <provided value>`).
+    4. Click the '*Submit*' button at the bottom of the dialog.
+2. If you want to use a client_id to obtain an access token, then
+    1. Click the '*Run All Tests*' button on the right.
+    2. Provide the EHR's registered id "client_id" field of the input (NOTE, Inferno 
+       doesn't support the registration API, so this must be obtained from another
+       system or configured manually).
+    3. Click the '*Submit*' button at the bottom of the dialog.
+    4. Make a token request that includes the specified client id to the
+        `[URL prefix]/custom/dtr_full_ehr/mock_auth/token` endpoint to get
+        an access token to use on the request of the requests.
+
+In either case, the tests will continue from that point. Further executions of tests under
+this session will also use the selected bearer token.
+
+Note: authentication options for these tests have not been finalized and are subject to change.
+
+### Postman-based Demo
+
+If you do not have a DTR Full EHR but would like to try the tests out, you can use
+[this Postman collection](https://github.com/inferno-framework/davinci-dtr-test-kit/blob/main/config/DTR%20Full%20EHR%20Tests%20Postman%20Demo.postman_collection.json)
+to make requests against Inferno. This does not include the capability to render and complete the
+questionnaires, but does have samples of correctly and incorrectly completed QuestionnaireResponses.
+To run the tests using this approach:
+
+1. Install [postman](https://www.postman.com/downloads/).
+1. Import [this Postman collection](https://github.com/inferno-framework/davinci-dtr-test-kit/blob/main/config/DTR%20Full%20EHR%20Tests%20Postman%20Demo.postman_collection.json).
+1. Start a Da Vinci DTR Full EHR Test Suite Session.
+1. Update the postman collection configuration variables found by opening the "DTR Full EHR
+   Tests Postman Demo" collection and selecting the "Variables" tab.
+   - **base_url**: corresponds to the where the test suite session is running. Defaults to 
+   `inferno.healthit.gov`. If running in another location, see guidance on the "Overview" tab
+   of the postman collection.
+   - **access_token**: note the "Current value" (update if desired) for use later.
+1. Return to Inferno and in the test list at the left, select *2 Static Questionnaire Workflow*.
+1. Click the "Run All Tests" button in the upper right.
+1. Add the **access_token** configured in postman to the Inferno input with the same name
+1. Click the "Submit" button in Inferno.
+1. Attest that the EHR has launched its DTR workflow in Inferno by clicking the link for the **true** response.
+1. Once the next wait dialog has appeared within Inferno asking for a `$questionnaire-package` 
+   request, use postman to submit the "Questionnaire Package for Dinner (Static)" request. Confirm
+   that the response that looks similar to the "Example Working Response" in postman
+   and click the link to continue the tests.
+1. Attest to the remainder of the tests as desired to get a sense for what is involved in testing
+   with an actual EHR implementation. To see what a valid QuestionnaireResponse looks like, see
+   the "Sample QuestionnaireResponse for Dinner (Static) ..." request in postman.
+
+## Limitations
+
+The DTR IG is a complex specification and these tests currently validate conformance to only
+a subset of IG requirements. Future versions of the test suite will test further
+features. A few specific features of interest are listed below.
+
+### Heavy Reliance on Attestations
+
+Currently, these test kits do not have access to the QuestionnaireResponse and so validation
+that the EHR performed CQL calculations and generated a conformant QuestionnaireResponse
+based on pre-population and manual answers is left to a user attestation rather than a
+mechanical check. Some level of mechanical checks are expected to be added in the future.
+
+### Questionnaire Feature Coverage
+
+Not all questionnaire features that are must support within the DTR IG are currently represented
+in questionnaires tested by the IG. Adaptive questionnaires are a notable omission.
+Additional questionnaires testing additional features will be added in the future.

data/lib/davinci_dtr_test_kit/docs/dtr_payer_server_suite_description_v201.md

@@ -81,9 +81,9 @@ If you would like to try out the tests but don't have a DTR payer server impleme
 you can run these tests against the DTR SMART Client test suite included in this test kit
 using the following steps:
 1. Start an Inferno session of the Da Vinci DTR SMART App Test Suite.
-1. Select test 2.1.1 *Static Questionnaire Workflow* from the menu on the left.
+1. Select test 1.1.1 *Retrieving the Static Questionnaire* from the menu on the left.
 1. Click the "Run All Tests" button in the upper right.
-1. In the "access_token" input, put `cnVuIHRvZ2V0aGVy`.
+1. In the "SMART App Launch" select `Standalone Launch` and in the "client_id" input, put `sample`.
 1. Click the "submit" button in the dialog that appears. The client tests will now be waiting for requests.
 1. Start an Inferno session of the DTR Payer Server test suite.
 1. Select test 1 *Static Questionnaire Package Retrieval* from the menu on the left.

data/lib/davinci_dtr_test_kit/dtr_full_ehr_suite.rb

@@ -1,7 +1,7 @@
 require_relative 'ext/inferno_core/runnable'
 require_relative 'ext/inferno_core/record_response_route'
 require_relative 'ext/inferno_core/request'
-require_relative 'client_groups/resp_assist_device/dtr_full_ehr_questionnaire_workflow_group'
+require_relative 'client_groups/dinner_static/dtr_full_ehr_questionnaire_workflow_group'
 require_relative 'auth_groups/oauth2_authentication_group'
 require_relative 'mock_payer'
 require_relative 'version'
@@ -9,19 +9,11 @@ require_relative 'version'
 module DaVinciDTRTestKit
   class DTRFullEHRSuite < Inferno::TestSuite
     extend MockPayer
+    extend MockAuthServer
 
     id :dtr_full_ehr
     title 'Da Vinci DTR Full EHR Test Suite'
-    description %(
-        # Da Vinci DTR Full EHR Test Suite
-
-        This suite validates that an EHR or other application can act
-        as a full DTR application requesting questionnaires from a
-        payer server and using local data to complete and store them.
-        Inferno will act as payer server returning questionnaires
-        in response to queries from the system under test and validating
-        that they can be completed as expected.
-      )
+    description File.read(File.join(__dir__, 'docs', 'dtr_full_ehr_suite_description_v201.md'))
 
     version VERSION
 
@@ -74,6 +66,6 @@ module DaVinciDTRTestKit
     end
 
     group from: :oauth2_authentication
-    group from: :dtr_full_ehr_questionnaire_workflow
+    group from: :dtr_full_ehr_static_dinner_questionnaire_workflow
   end
 end

data/lib/davinci_dtr_test_kit/dtr_questionnaire_response_validation.rb

@@ -88,7 +88,7 @@ module DaVinciDTRTestKit
         end
 
         origin_extension = find_extension(target_item_answer,
-                                          'http://hl7.org/fhir/us/davinci-dtr/StructureDefinition/information-origin')
+                                          'http://hl7.org/fhir/us/davinci-dtr/StructureDefinition/information-origin|2.0.1')
         source_extension = find_extension(origin_extension, 'source')
 
         unless source_extension.present?
@@ -134,7 +134,7 @@ module DaVinciDTRTestKit
 
         # check origin.source extension
         origin_extension = find_extension(answer,
-                                          'http://hl7.org/fhir/us/davinci-dtr/StructureDefinition/information-origin')
+                                          'http://hl7.org/fhir/us/davinci-dtr/StructureDefinition/information-origin|2.0.1')
         source_extension = find_extension(origin_extension, 'source')
 
         if source_extension.present?

data/lib/davinci_dtr_test_kit/dtr_smart_app_suite.rb

@@ -61,7 +61,7 @@ module DaVinciDTRTestKit
       DTRSmartAppSuite.extract_client_id_from_query_params(request)
     end
 
-    record_response_route :post, EHR_AUTHORIZE_PATH, 'dtr_smart_app_authorize', method(:ehr_authorize),
+    record_response_route :post, EHR_AUTHORIZE_PATH, 'dtr_smart_app_ehr_authorize', method(:ehr_authorize),
                           resumes: ->(_) { false } do |request|
       DTRSmartAppSuite.extract_client_id_from_form_params(request)
     end

data/lib/davinci_dtr_test_kit/fixture_loader.rb

@@ -23,7 +23,7 @@ module DaVinciDTRTestKit
           [
             'fixtures/dinner_static/questionnaire_dinner_order_static.json',
             'fixtures/dinner_static/questionnaire_response_dinner_order_static.json',
-            ['dtr_smart_app_static_dinner_questionnaire_workflow']
+            ['dtr_smart_app_static_dinner_questionnaire_workflow', 'dtr_full_ehr_static_dinner_questionnaire_workflow']
           ],
           [
             'fixtures/dinner_adaptive/questionnaire_dinner_order_adaptive.json',

data/lib/davinci_dtr_test_kit/fixtures/dinner_adaptive/dinner_order_adaptive_next_question_hamburger.json

@@ -153,7 +153,7 @@
             },
             {
               "valueCoding": {
-                "code": "Pickels"
+                "code": "Pickles"
               }
             },
             {

data/lib/davinci_dtr_test_kit/fixtures/dinner_static/questionnaire_dinner_order_static.json

@@ -156,7 +156,7 @@
                   },
                   {
                     "valueCoding": {
-                      "code": "Pickels"
+                      "code": "Pickles"
                     }
                   },
                   {

data/lib/davinci_dtr_test_kit/mock_auth_server.rb

@@ -60,22 +60,20 @@ module DaVinciDTRTestKit
       token = JWT.encode({ inferno_client_id: client_id }, nil, 'none')
       response = { access_token: token, token_type: 'bearer', expires_in: 3600 }
       test_input = JSON.parse(test_result.input_json)
-      smart_app_launch_input = test_input.find { |input| input['name'] == 'smart_app_launch' }
 
-      if smart_app_launch_input.present? && smart_app_launch_input['value'] == 'inferno'
-        fhir_context_input = test_input.find { |input| input['name'] == 'smart_fhir_context' }
-        fhir_context_input_value = fhir_context_input['value'] if fhir_context_input.present?
-        fhir_context = fhir_context_input_value || [
-          { reference: 'Coverage/cov015' },
-          { reference: 'DeviceRequest/devreqe0470' }
-        ]
+      fhir_context_input = test_input.find { |input| input['name'] == 'smart_fhir_context' }
+      fhir_context_input_value = fhir_context_input['value'] if fhir_context_input.present?
+      begin
+        fhir_context = JSON.parse(fhir_context_input_value)
+      rescue StandardError
+        fhir_context = nil
+      end
+      response.merge!({ fhirContext: fhir_context }) if fhir_context
 
-        smart_patient_input = test_input.find { |input| input['name'] == 'smart_patient_id' }
-        smart_patient_input_value = smart_patient_input['value'] if smart_patient_input.present?
-        smart_patient = smart_patient_input_value || 'pat015'
+      smart_patient_input = test_input.find { |input| input['name'] == 'smart_patient_id' }
+      smart_patient_input_value = smart_patient_input['value'] if smart_patient_input.present?
+      response.merge!({ patient: smart_patient_input_value }) if smart_patient_input_value
 
-        response.merge!({ patient: smart_patient, fhirContext: fhir_context })
-      end
       request.response_body = response.to_json
       request.response_headers = { 'Access-Control-Allow-Origin' => '*' }
       request.status = 200
@@ -102,7 +100,13 @@ module DaVinciDTRTestKit
       encoded_jwt = URI.decode_www_form(request.request_body).to_h['client_assertion']
       return unless encoded_jwt.present?
 
-      jwt_payload = JWT.decode(encoded_jwt, nil, false)&.first # skip signature verification
+      jwt_payload =
+        begin
+          JWT.decode(encoded_jwt, nil, false)&.first # skip signature verification
+        rescue StandardError
+          nil
+        end
+
       jwt_payload['iss'] || jwt_payload['sub'] if jwt_payload.present?
     end
 
@@ -120,7 +124,13 @@ module DaVinciDTRTestKit
 
     def extract_client_id_from_bearer_token(request)
       token = extract_bearer_token(request)
-      JWT.decode(token, nil, false)&.first&.dig('inferno_client_id')
+      jwt =
+        begin
+          JWT.decode(token, nil, false)
+        rescue StandardError
+          nil
+        end
+      jwt&.first&.dig('inferno_client_id')
     end
 
     # Header expected to be a bearer token of the form "Bearer: <token>"

data/lib/davinci_dtr_test_kit/mock_ehr.rb

@@ -49,9 +49,14 @@ module DaVinciDTRTestKit
       end
 
       # Respond with user-inputted resource if there is one that matches the request
-      ehr_bundle_input = JSON.parse(test_result.input_json).find { |input| input['name'] == 'ehr_bundle' }
-      ehr_bundle_input_value = ehr_bundle_input_value = ehr_bundle_input['value'] if ehr_bundle_input.present?
-      ehr_bundle = FHIR.from_contents(ehr_bundle_input_value) if ehr_bundle_input_value.present?
+      begin
+        ehr_bundle_input = JSON.parse(test_result.input_json).find { |input| input['name'] == 'ehr_bundle' }
+        ehr_bundle_input_value = ehr_bundle_input_value = ehr_bundle_input['value'] if ehr_bundle_input.present?
+        ehr_bundle = FHIR.from_contents(ehr_bundle_input_value) if ehr_bundle_input_value.present?
+      rescue StandardError
+        ehr_bundle = nil
+      end
+
       if id.present? && ehr_bundle.present? && ehr_bundle.is_a?(FHIR::Bundle)
         matching_resource = ehr_bundle.entry&.find do |entry|
           entry.resource.is_a?(fhir_class) && entry.resource&.id == id

data/lib/davinci_dtr_test_kit/payer_server_groups/adaptive_next_questionnaire_expressions_test.rb

@@ -6,7 +6,7 @@ module DaVinciDTRTestKit
     id :dtr_v201_payer_adaptive_next_form_expressions_test
     title 'Questionnaire(s) contains items with expressions necessary for pre-population'
     description %(
-      Inferno checks that the payer server response has appropriate expressions and that expressions are
+      Inferno checks that the payer server response to $next-question operation has appropriate expressions and that expressions are
        written in cql.
     )
 

data/lib/davinci_dtr_test_kit/payer_server_groups/payer_server_adaptive_request_validation_test.rb

@@ -3,7 +3,7 @@ module DaVinciDTRTestKit
   class PayerAdaptiveFormRequestTest < Inferno::Test
     include URLs
     include DaVinciDTRTestKit::ValidationTest
-    title '[USER INPUT VALIDATION] Questionnaire Package request is valid'
+    title 'User Input Validation: Questionnaire Package request is valid'
     description %(
       This test validates the conformance of the client's request to the
       [DTR Questionnaire Package Input Parameters](http://hl7.org/fhir/us/davinci-dtr/StructureDefinition/dtr-qpackage-input-parameters)
@@ -13,32 +13,23 @@ module DaVinciDTRTestKit
       values. CodeableConcept element bindings will fail if none of their codings have a code/system belonging
       to the bound ValueSet. Quantity, Coding, and code element bindings will fail if their code/system are not found in
       the valueset.
-
-      This test may process multiple resources, labeling messages with the corresponding tested resources
-      in the order that they were received.
     )
     id :payer_server_adaptive_questionnaire_request_validation
 
     run do
       skip_if retrieval_method == 'Static', 'Performing only static flow tests - only one flow is required.'
+      profile_with_version = 'http://hl7.org/fhir/us/davinci-dtr/StructureDefinition/dtr-qpackage-input-parameters|2.0.1'
       if initial_adaptive_questionnaire_request.nil?
-        resources = load_tagged_requests(QUESTIONNAIRE_TAG)
-        using_manual_entry = false
+        requests = load_tagged_requests(QUESTIONNAIRE_TAG)
+        skip_if requests.blank?, 'No request resource received from the client.'
+        # making the assumption that only one request was made here - if there were multiple, we are only validating the first
+        resource_is_valid?(resource: FHIR.from_contents(requests[0].request[:body]), profile_url: profile_with_version)
       else
-        resources = initial_adaptive_questionnaire_request
-        using_manual_entry = true
+        request = FHIR.from_contents(initial_adaptive_questionnaire_request)
+        resource_is_valid?(resource: request, profile_url: profile_with_version)
       end
-      skip_if resources.nil?, 'No request resources to validate.'
-      perform_request_validation_test(
-        resources,
-        :parameters,
-        'http://hl7.org/fhir/us/davinci-dtr/StructureDefinition/dtr-qpackage-input-parameters',
-        questionnaire_package_url,
-        using_manual_entry
-      )
-    rescue Inferno::Exceptions::AssertionException => e
-      msg = e.message.to_s.strip
-      skip msg
+      errors_found = messages.any? { |message| message[:type] == 'error' }
+      skip_if errors_found, "Resource does not conform to the profile #{profile_with_version}"
     end
   end
 end

data/lib/davinci_dtr_test_kit/payer_server_groups/payer_server_adaptive_response_bundles_validation_test.rb

@@ -20,21 +20,21 @@ module DaVinciDTRTestKit
 
     run do
       skip_if retrieval_method == 'Static', 'Performing only static flow tests - only one flow is required.'
-      test_passed = false
-      profile_url = 'http://hl7.org/fhir/us/davinci-dtr/StructureDefinition/DTR-QPackageBundle'
+      test_passed = true
+      profile_url = 'http://hl7.org/fhir/us/davinci-dtr/StructureDefinition/DTR-QPackageBundle|2.0.1'
       assert !scratch[:adaptive_responses].nil?, 'No resources to validate.'
       scratch[:adaptive_responses].each_with_index do |resource, index|
         fhir_resource = FHIR.from_contents(resource.response[:body])
         fhir_resource.parameter.each do |param|
           resource_is_valid = validate_resource(param.resource, :bundle, profile_url, index)
-          test_passed = true if resource_is_valid
+          test_passed = false unless resource_is_valid
         rescue StandardError
           next
         end
       end
-      raise tests_failed[profile_url][0] if !test_passed && !tests_failed[profile_url].blank?
-
-      messages.clear if test_passed
+      if !test_passed && !tests_failed[profile_url].blank?
+        assert test_passed, "Not all returned resources conform to the profile: #{profile_url}"
+      end
     end
   end
 end

data/lib/davinci_dtr_test_kit/payer_server_groups/payer_server_adaptive_response_search_validation_test.rb

@@ -20,23 +20,23 @@ module DaVinciDTRTestKit
 
     run do
       skip_if retrieval_method == 'Static', 'Performing only static flow tests - only one flow is required.'
-      test_passed = false
-      profile_url = 'http://hl7.org/fhir/us/davinci-dtr/StructureDefinition/dtr-questionnaire-adapt-search'
+      test_passed = true
+      profile_url = 'http://hl7.org/fhir/us/davinci-dtr/StructureDefinition/dtr-questionnaire-adapt-search|2.0.1'
       assert !scratch[:adaptive_responses].nil?, 'No resources to validate.'
       scratch[:adaptive_responses].each_with_index do |resource, index|
         fhir_resource = FHIR.from_contents(resource.response[:body])
         fhir_resource.parameter.each do |param|
           param.resource.entry.each do |entry|
             resource_is_valid = validate_resource(entry.resource, :questionnaire, profile_url, index)
-            test_passed = true if resource_is_valid
+            test_passed = false unless resource_is_valid
           end
         rescue StandardError
           next
         end
       end
-      raise tests_failed[profile_url][0] if !test_passed && !tests_failed[profile_url].blank?
-
-      messages.clear if test_passed
+      if !test_passed && !tests_failed[profile_url].blank?
+        assert test_passed, "Not all returned resources conform to the profile: #{profile_url}"
+      end
     end
   end
 end