davinci_dtr_test_kit 0.16.0 → 0.16.1

data/lib/davinci_dtr_test_kit/client_groups/adaptive_questionnaire/custom/dtr_custom_next_question_response_validation_test.rb

@@ -0,0 +1,95 @@
+module DaVinciDTRTestKit
+  class DTRCustomNextQuestionResponseValidationTest < Inferno::Test
+    id :dtr_custom_next_questionnaire_validation
+    title '[USER INPUT VERIFICATION] Custom Questionnaires for $next-question Responses are valid for this workflow'
+    description %(
+      Inferno will validate that the user-provided Questionnaire resources to be included in
+      each `$next-question` response are correct for this workflow.
+
+      The test verifies that:
+      1. All provided Questionnaires have the same ID as the contained Questionnaire in the
+         `QuestionnaireResponse` of the `$next-question` request.
+      2. Each provided Questionnaire includes all previously presented questions along with
+         the next question or set of questions.
+
+      If any of these conditions are not met, the test will fail.
+    )
+
+    input :custom_next_question_questionnaires,
+          title: 'Custom Questionnaire resources to include in each $next-question Response',
+          description: %(
+            Provide a JSON list of Questionnaire resources for Inferno to use when updating
+            the contained Questionnaire in the `QuestionnaireResponse` received in each
+            `$next-question` request.
+
+            Each `$next-question` request will correspond to the next item in the provided list,
+            and Inferno will replace the contained Questionnaire with the corresponding resource
+            before returning the updated `QuestionnaireResponse`.
+
+            The provided Questionnaires must contain the next question or set of questions in
+            sequence, ensuring a proper progression of the adaptive questionnaire workflow.
+          ),
+          type: 'textarea'
+
+    def next_request_tag
+      config.options[:next_tag]
+    end
+
+    def extract_link_ids(questionnaire_items)
+      questionnaire_items&.each_with_object([]) do |item, link_ids|
+        link_ids << item.linkId
+
+        link_ids.concat(extract_link_ids(item.item)) if item.item.present?
+      end
+    end
+
+    def validate_correctness_of_custom_next_questionnaire(custom_questionnaire, contained_questionnaire)
+      custom_items_link_ids = extract_link_ids(custom_questionnaire.item) || []
+      contained_items_link_ids = extract_link_ids(contained_questionnaire.item) || []
+      missing_items_ids = contained_items_link_ids - custom_items_link_ids
+
+      error_msg = %(
+        Custom Questionnaire must include all previous questions along with the next question or set of questions.
+      )
+      add_message('error', error_msg) if custom_items_link_ids.length <= contained_items_link_ids.length
+
+      error_msg = %(
+        Custom Questionnaire must include all previous questions. The following items are missing:
+        questions with Link ID `#{missing_items_ids.to_sentence}`.
+      )
+      add_message('error', error_msg) if missing_items_ids.present?
+    end
+
+    run do
+      load_tagged_requests next_request_tag
+      skip_if requests.blank?, 'A $next-question request must be made prior to running this test'
+      assert_valid_json custom_next_question_questionnaires, 'Custom $next-question Questionnaires is not valid JSON'
+
+      skip_if scratch[:contained_questionnaires].nil?, %(
+        Unable to validate user-provided Questionnaires: no valid `$next-question` requests
+        containing a Questionnaire were received.
+      )
+
+      custom_questionnaires = [JSON.parse(custom_next_question_questionnaires)].flatten
+      custom_questionnaires.each do |q|
+        custom_questionnaire = FHIR.from_contents(q.to_json)
+        assert custom_questionnaire, "The custom Questionnaire #{q[:id]} provided is not a valid FHIR resource"
+        assert_resource_type(:questionnaire, resource: custom_questionnaire)
+
+        contained_questionnaire = scratch[:contained_questionnaires].find { |cq| cq.id == custom_questionnaire.id }
+        assert contained_questionnaire, %(
+          Unable to validate the provided custom Questionnaire `#{q[:id]}`: no valid `$next-question` request
+          was found containing a Questionnaire with a matching ID.
+        )
+
+        validate_correctness_of_custom_next_questionnaire(custom_questionnaire, contained_questionnaire)
+      rescue Inferno::Exceptions::AssertionException => e
+        add_message('error', "Questionnaire `#{q[:id]}`: #{e.message}")
+        next
+      end
+
+      assert messages.none? { |message| message[:type] == 'error' },
+             'Custom Questionnaire provided is not valid for this workflow'
+    end
+  end
+end

data/lib/davinci_dtr_test_kit/client_groups/adaptive_questionnaire/custom/dtr_full_ehr_custom_adaptive_request_test.rb

@@ -0,0 +1,87 @@
+require_relative '../../../descriptions'
+require_relative '../../../urls'
+
+module DaVinciDTRTestKit
+  class DTRFullEHRCustomAdaptiveRequestTest < Inferno::Test
+    include URLs
+
+    id :dtr_full_ehr_custom_adative_request
+    title 'Client can complete the DTR Adaptive Questionnaire workflow'
+    description %(
+      This test waits for client requests to retrieve and progress through an adaptive questionnaire workflow.
+
+      1. **Questionnaire Package Request**: The client should invoke the `$questionnaire-package` operation
+         to retrieve the adaptive questionnaire package. Inferno will respond with the user-provided
+         empty adaptive questionnaire.
+
+      2. **Next Question Requests**: The client should invoke the `$next-question` operation to request
+         the next set of questions. Inferno will respond sequentially with the next Questionnaire from
+         the user-provided list. If a `$next-question` request is received when the list is empty,
+         Inferno will mark the `QuestionnaireResponse` as completed.
+    )
+    verifies_requirements 'hl7.fhir.us.davinci-dtr_2.0.1@165', 'hl7.fhir.us.davinci-dtr_2.0.1@262',
+                          'hl7.fhir.us.davinci-dtr_2.0.1@264'
+
+    config options: { accepts_multiple_requests: true }
+
+    input :custom_questionnaire_package_response, :custom_next_question_questionnaires
+    input :client_id,
+          title: 'Client Id',
+          type: 'text',
+          optional: true,
+          locked: true,
+          description: INPUT_CLIENT_ID_LOCKED
+
+    run do
+      assert_valid_json(
+        custom_questionnaire_package_response,
+        'Custom questionnaire package response is not a valid json'
+      )
+      assert_valid_json(custom_next_question_questionnaires, 'Custom next questionnaires input is not a valid json')
+
+      custom_qp = JSON.parse(custom_questionnaire_package_response)
+      custom_questionnaires = JSON.parse(custom_next_question_questionnaires)
+      assert custom_qp.present?, %(
+        Custom questionnaire package response is empty, please provide a custom questionnaire package response
+        for the $questionnaire-package request
+      )
+      assert custom_questionnaires.present?, %(
+        'Custom questionnaires list is empty, please provide a list of Custom Questionnaire resources
+        to include in each $next-question Response.
+      )
+
+      wait(
+        identifier: client_id,
+        message: %(
+          ### Adaptive Questionnaire Workflow
+
+          1. **Questionnaire Package Request**:
+             - Invoke the `$questionnaire-package` operation by sending a POST request to the following endpoint
+               to retrieve the adaptive questionnaire package:
+
+               `#{questionnaire_package_url}`
+
+             - Inferno will respond with the user-provided empty adaptive questionnaire.
+
+          2. **Next Question Requests**:
+             - After receiving the questionnaire package, invoke the `$next-question` operation by sending
+               a POST request to the following endpoint:
+
+               `#{next_url}`
+
+             - Repeat this request **multiple times**, once for each Questionnaire provided in the user-supplied list.
+             - Inferno will sequentially respond with the corresponding Questionnaire from the list.
+             - If a `$next-question` request is received when the list is empty, Inferno will mark
+               the `QuestionnaireResponse` as completed.
+
+          Inferno will wait for all expected requests to be made.
+
+          ### Continuing the Tests
+
+          Once all required `$next-question` requests have been made,
+          [Click here](#{resume_pass_url}?token=#{client_id}) to continue.
+        )
+      )
+    end
+  end
+end

data/lib/davinci_dtr_test_kit/client_groups/adaptive_questionnaire/custom/dtr_full_ehr_custom_adaptive_workflow_group.rb

@@ -0,0 +1,136 @@
+require_relative '../../../tags'
+require_relative '../../full_ehr/dtr_full_ehr_launch_attestation_test'
+require_relative 'dtr_full_ehr_custom_adaptive_request_test'
+require_relative '../../shared/dtr_questionnaire_package_request_validation_test'
+require_relative '../dtr_adaptive_next_question_request_validation_test'
+require_relative '../dtr_adaptive_response_validation_test'
+require_relative '../../shared/dtr_custom_questionnaire_package_validation_test'
+require_relative '../../shared/dtr_custom_questionnaire_libraries_test'
+require_relative 'dtr_custom_next_question_response_validation_test'
+require_relative '../../shared/dtr_custom_questionnaire_extensions_test'
+require_relative '../../shared/dtr_custom_questionnaire_expressions_test'
+require_relative '../../shared/dtr_prepopulation_attestation_test'
+require_relative '../../shared/dtr_prepopulation_override_attestation_test'
+require_relative '../../full_ehr/dtr_full_ehr_store_attestation_test'
+
+module DaVinciDTRTestKit
+  class DTRFullEHRCustomAdaptiveWorkflowGroup < Inferno::TestGroup
+    id :dtr_full_ehr_custom_adaptive_workflow
+    title 'Adaptive Questionnaire Workflow'
+    description %(
+      This group validates that a DTR Full EHR client can perform a full DTR Adaptive Questionnaire workflow.
+      Testers will provide a custom adaptive Questionnaire package for the test, along with a list
+      (JSON array) of Questionnaires to be included in each `$next-question` response.
+
+      As part of this workflow, the Full EHR system must demonstrate its ability to:
+
+      1. Request the Questionnaire using the `$questionnaire-package` operation.
+      2. Support the tester in completing the questionnaire through multiple `$next-question` interactions, including:
+         - Rendering the questionnaire.
+         - Pre-populating answers into the questionnaire.
+         - Allowing the tester to manually enter responses, including overriding pre-populated answers.
+      3. Complete and store the `QuestionnaireResponse` for future use.
+
+      Inferno will process `$next-question` requests dynamically:
+      - Each request will receive the next Questionnaire from the provided list.
+      - If a `$next-question` request is received when the list is empty, Inferno will mark
+        the `QuestionnaireResponse` as completed.
+
+      At least two answers should be pre-populated across all sets of questions.
+    )
+    run_as_group
+    config(
+      options: { form_type: 'adaptive', next_tag: "custom_#{CLIENT_NEXT_TAG}" },
+      inputs: {
+        custom_questionnaire_package_response: {
+          name: 'adaptive_custom_questionnaire_package_response',
+          title: 'Custom Questionnaire Package Response JSON for Adaptive form',
+          description: %(
+              A JSON PackageBundle may be provided here to replace Inferno's response to
+              the $questionnaire-package request. Note: Ensure that the questionnaire package
+              has an empty Adaptive Questionnaire.
+            )
+        }
+      }
+    )
+
+    group do
+      id :dtr_full_ehr_custom_adaptive_retrieval
+      title 'Retrieving the Adaptive Questionnaire'
+
+      # Test 0: attest to launch
+      test from: :dtr_full_ehr_launch_attest,
+           config: {
+             options: {
+               attestation_message: 'I attest that DTR has been launched in the context of a patient with data that will exercise pre-population logic in the provided static questionnaire resulting in at least 2 pre-populated answers.' # rubocop:disable Layout/LineLength
+             }
+           },
+           title: 'Launch DTR (Attestation)'
+      # Test 1: Recieve questionnaire-package and next-question requests
+      test from: :dtr_full_ehr_custom_adative_request
+      # Test 2: validate the $questionnaire-package request body
+      test from: :dtr_qp_request_validation
+      # Test 3: validate the $next-question requests body
+      test from: :dtr_adaptive_next_question_request_validation
+      # Test 4: validate the QuestionnaireResponse in the input parameter
+      test from: :dtr_adaptive_response_validation do
+        description %(
+          Verify that all submitted QuestionnaireResponse resources meet the following criteria:
+          - Conform to the [SDCQuestionnaireResponseAdapt](http://hl7.org/fhir/uv/sdc/StructureDefinition/sdc-questionnaireresponse-adapt).
+          - Include source extensions indicating whether answers were manually entered,
+            automatically pre-populated, or manually overridden (for `completed` QuestionnaireResponse).
+          - Provide answers for all required items in their contained Questionnaire.
+        )
+        input :custom_next_question_questionnaires
+      end
+      # Test 5: validate the user provided $questionnaire-package response
+      test from: :dtr_custom_qp_validation
+      # Test 6: verify the custom response has the necessary libraries for pre-population
+      test from: :dtr_custom_questionnaire_libraries
+      # Test 7: validate the user provided $next-question questionnaires
+      test from: :dtr_custom_next_questionnaire_validation
+      # Test 8: verify the custom responses has the necessary extensions for pre-population
+      test from: :dtr_custom_questionnaire_extensions do
+        title %(
+          [USER INPUT VERIFICATION] Custom Questionnaires for $next-question Responses contain extensions
+          necessary for pre-population
+        )
+        input :custom_next_question_questionnaires
+      end
+      # Test 9: verify custom responses has necessary expressions for pre-population
+      test from: :dtr_custom_questionnaire_expressions do
+        title %(
+          [USER INPUT VERIFICATION] Custom Questionnaires for $next-question Responses contain items with
+          expressions necessary for pre-population
+        )
+        input :custom_next_question_questionnaires
+      end
+    end
+
+    group do
+      title 'Attestation: Questionnaire Pre-Population and Rendering'
+      description %(
+        This group verifies that the tester has properly followed pre-population and rendering
+        directives while interacting with and filling out the questionnaire.
+
+        After retrieving and completing the questionnaire in their client system, the tester will
+        attest that:
+        1. The questionnaire was pre-populated as expected, with at least two answers pre-populated
+          across all sets of questions.
+        2. The questionnaire was rendered correctly according to its defined structure.
+        3. They were able to manually enter responses, including overriding pre-populated answers.
+      )
+      test from: :dtr_prepopulation_attest
+      test from: :dtr_prepopulation_override_attest
+    end
+
+    group do
+      title 'Attestation: QuestionnaireResponse Completion and Storage'
+      description %(
+        The tester will attest to the completion of the questionnaire such that the results are stored for later use.
+      )
+
+      test from: :dtr_full_ehr_store_attest
+    end
+  end
+end

data/lib/davinci_dtr_test_kit/client_groups/adaptive_questionnaire/custom/dtr_smart_app_custom_adaptive_request_test.rb

@@ -0,0 +1,171 @@
+require_relative '../../../urls'
+
+module DaVinciDTRTestKit
+  class DTRSmartAppCustomAdaptiveRequestTest < Inferno::Test
+    include URLs
+
+    id :dtr_smart_app_custom_adative_request
+    title 'Client can complete the DTR Adaptive Questionnaire workflow'
+    description %(
+      This test waits for client requests to retrieve and progress through an adaptive questionnaire workflow.
+
+      1. **Questionnaire Package Request**: The client should invoke the `$questionnaire-package` operation
+         to retrieve the adaptive questionnaire package. Inferno will respond with the user-provided
+         empty adaptive questionnaire.
+
+      2. **Next Question Requests**: The client should invoke the `$next-question` operation to request
+         the next set of questions. Inferno will respond sequentially with the next Questionnaire from
+         the user-provided list. If a `$next-question` request is received when the list is empty,
+         Inferno will mark the `QuestionnaireResponse` as completed.
+    )
+    config options: { accepts_multiple_requests: true }
+    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 :adaptive_smart_patient_id,
+          optional: true,
+          title: 'SMART App Launch Patient ID (Custom Adaptive)',
+          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 :adaptive_smart_fhir_context,
+          optional: true,
+          title: 'SMART App Launch fhirContext (Custom Adaptive)',
+          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 :adaptive_ehr_bundle,
+          optional: true,
+          title: 'EHR-available resources (Custom Adaptive)',
+          type: 'textarea',
+          description: %(
+            Resources available from the EHR needed to drive the custom adaptive 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 :custom_questionnaire_package_response, :custom_next_question_questionnaires
+
+    def example_client_jwt_payload_part
+      Base64.strict_encode64({ inferno_client_id: client_id }.to_json).delete('=')
+    end
+
+    run do
+      assert_valid_json(
+        custom_questionnaire_package_response,
+        'Custom questionnaire package response is not a valid json'
+      )
+      assert_valid_json(custom_next_question_questionnaires, 'Custom next questionnaires input is not a valid json')
+
+      custom_qp = JSON.parse(custom_questionnaire_package_response)
+      custom_questionnaires = JSON.parse(custom_next_question_questionnaires)
+      assert custom_qp.present?, %(
+        Custom questionnaire package response is empty, please provide a custom questionnaire package response
+        for the $questionnaire-package request
+      )
+      assert custom_questionnaires.present?, %(
+        'Custom questionnaires list is empty, please provide a list of Custom Questionnaire resources
+        to include in each $next-question Response.
+      )
+      # validate relevant inputs and provide warnings if they are bad
+      warning do
+        if adaptive_smart_fhir_context
+          assert_valid_json(adaptive_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 adaptive_ehr_bundle
+          assert_valid_json(adaptive_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(adaptive_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 "Open in new window" or "Open in new tab".)
+                      else
+                        %(Launch the SMART App from your EHR.)
+                      end
+      inferno_prompt_cont = %(As the DTR app steps through the launch steps, Inferno will wait and respond to the app's
+                              requests for SMART configuration, authorization and access token.)
+
+      wait(
+        identifier: client_id,
+        message: %(
+          ### SMART App Launch
+
+          #{launch_prompt}
+
+          #{inferno_prompt_cont if smart_app_launch == 'ehr'}
+
+          ### Adaptive Questionnaire Workflow
+
+          1. **Questionnaire Package Request**:
+             - Invoke the `$questionnaire-package` operation by sending a POST request to the following endpoint
+               to retrieve the adaptive questionnaire package:
+
+               `#{questionnaire_package_url}`
+
+             - Inferno will respond with the user-provided empty adaptive questionnaire.
+
+          2. **Next Question Requests**:
+             - After receiving the questionnaire package, invoke the `$next-question` operation by sending
+               a POST request to the following endpoint:
+
+               `#{next_url}`
+
+             - Repeat this request **multiple times**, once for each Questionnaire provided in the user-supplied list.
+             - Inferno will sequentially respond with the corresponding Questionnaire from the list.
+             - If a `$next-question` request is received when the list is empty, Inferno will mark
+               the `QuestionnaireResponse` as completed.
+
+          Inferno will wait for all expected requests to be made.
+
+          ### Pre-population
+
+          Inferno will then wait for the client to complete Questionnaire pre-population. The client should make FHIR
+          GET requests using service base path:
+
+          `#{fhir_base_url}`
+
+          ### Request Identification
+
+          In order to identify requests for this session, Inferno will look for
+          an `Authorization` header with value:
+
+          ```
+          Bearer eyJhbGciOiJub25lIn0.#{example_client_jwt_payload_part}.
+          ```
+
+          ### Continuing the Tests
+
+          When the DTR application has finished loading the Questionnaire,
+          including any clinical data requests to support pre-population,
+          [Click here](#{resume_pass_url}?client_id=#{client_id}) to continue.
+        )
+      )
+    end
+  end
+end

data/lib/davinci_dtr_test_kit/client_groups/adaptive_questionnaire/custom/dtr_smart_app_custom_adaptive_workflow_group.rb

@@ -0,0 +1,146 @@
+require_relative '../../../tags'
+require_relative 'dtr_smart_app_custom_adaptive_request_test'
+require_relative '../../shared/dtr_questionnaire_package_request_validation_test'
+require_relative '../dtr_adaptive_next_question_request_validation_test'
+require_relative '../dtr_adaptive_response_validation_test'
+require_relative '../../shared/dtr_custom_questionnaire_package_validation_test'
+require_relative '../../shared/dtr_custom_questionnaire_libraries_test'
+require_relative '../../shared/dtr_custom_questionnaire_extensions_test'
+require_relative '../../shared/dtr_custom_questionnaire_expressions_test'
+require_relative 'dtr_custom_next_question_response_validation_test'
+require_relative '../../shared/dtr_prepopulation_attestation_test'
+require_relative '../../shared/dtr_prepopulation_override_attestation_test'
+require_relative '../../smart_app/dtr_smart_app_saving_questionnaire_response_group'
+require_relative '../../shared/dtr_questionnaire_response_prepopulation_test'
+
+module DaVinciDTRTestKit
+  class DTRSmartAppCustomAdaptiveWorkflowGroup < Inferno::TestGroup
+    id :dtr_smart_app_custom_adaptive_workflow
+    title 'Adaptive Questionnaire Workflow'
+    description %(
+      This group validates that a DTR SMART App client can perform a full DTR Adaptive Questionnaire workflow.
+      Testers will provide a custom adaptive Questionnaire package for the test, along with a list
+      (JSON array) of Questionnaires to be included in each `$next-question` response.
+
+      As part of this workflow, the SMART App system must demonstrate its ability to:
+
+      1. Request the Questionnaire using the `$questionnaire-package` operation.
+      2. Support the tester in completing the questionnaire through multiple `$next-question` interactions, including:
+         - Rendering the questionnaire.
+         - Pre-populating answers into the questionnaire.
+         - Allowing the tester to manually enter responses, including overriding pre-populated answers.
+      3. Provide the completed `QuestionnaireResponse` with appropriate indicators for pre-populated
+         and manually-entered data.
+
+      Inferno will process `$next-question` requests dynamically:
+      - Each `$next-question` request will correspond to the next item in the provided list.
+      - Inferno will sequentially return the corresponding Questionnaire from the list.
+      - If a `$next-question` request is received when the list is empty, Inferno will mark
+        the `QuestionnaireResponse` as completed.
+
+      At least two answers should be pre-populated across all sets of questions.
+    )
+    run_as_group
+
+    config(
+      options: {
+        smart_app: true,
+        form_type: 'adaptive',
+        next_tag: "custom_#{CLIENT_NEXT_TAG}"
+      },
+      inputs: {
+        custom_questionnaire_package_response: {
+          name: 'adaptive_custom_questionnaire_package_response',
+          title: 'Custom Questionnaire Package Response JSON for Adaptive form',
+          description: %(
+              A JSON PackageBundle may be provided here to replace Inferno's response to
+              the $questionnaire-package request. Note: Ensure that the questionnaire package
+              has an empty Adaptive Questionnaire.
+            )
+        }
+      }
+    )
+
+    group do
+      id :dtr_smart_app_custom_adaptive_retrieval
+      title 'Retrieving the Adaptive Questionnaire'
+
+      # Test 1: wait for the $questionnaire-package request and initial $next-question request
+      test from: :dtr_smart_app_custom_adative_request
+      # Test 2: validate the $questionnaire-package request body
+      test from: :dtr_qp_request_validation
+      # Test 3: validate the $next-question request body
+      test from: :dtr_adaptive_next_question_request_validation
+      # Test 4: validate the QuestionnaireResponse in the input parameter
+      test from: :dtr_adaptive_response_validation do
+        description %(
+          Verify that all submitted QuestionnaireResponse resources meet the following criteria:
+          - Conform to the [SDCQuestionnaireResponseAdapt](http://hl7.org/fhir/uv/sdc/StructureDefinition/sdc-questionnaireresponse-adapt).
+          - Include source extensions indicating whether answers were manually entered,
+            automatically pre-populated, or manually overridden (for `completed` QuestionnaireResponse).
+          - Provide answers for all required items in their contained Questionnaire.
+        )
+        input :custom_next_question_questionnaires
+      end
+      # Test 5: validate the user provided $questionnaire-package response
+      test from: :dtr_custom_qp_validation
+      # Test 6: verify the custom response has the necessary libraries for pre-population
+      test from: :dtr_custom_questionnaire_libraries
+      # Test 7: validate the user provided $next-question questionnaire
+      test from: :dtr_custom_next_questionnaire_validation
+      # Test 8: verify the custom response has the necessaru extensions for pre-population
+      test from: :dtr_custom_questionnaire_extensions do
+        title %(
+          [USER INPUT VERIFICATION] Custom Questionnaires for $next-question Responses contain extensions
+          necessary for pre-population
+        )
+        input :custom_next_question_questionnaires
+      end
+      # Test 9: verify custom response has necessary expressions for pre-population
+      test from: :dtr_custom_questionnaire_expressions do
+        title %(
+          [USER INPUT VERIFICATION] Custom Questionnaires for $next-question Responses contain items with
+          expressions necessary for pre-population
+        )
+        input :custom_next_question_questionnaires
+      end
+    end
+
+    group do
+      title 'Attestation: Questionnaire Pre-Population and Rendering'
+      description %(
+        This group verifies that the tester has properly followed pre-population and rendering
+        directives while interacting with and filling out the questionnaire.
+
+        After retrieving and completing the questionnaire in their client system, the tester will
+        attest that:
+        1. The questionnaire was pre-populated as expected, with at least two answers pre-populated
+          across all sets of questions.
+        2. The questionnaire was rendered correctly according to its defined structure.
+        3. They were able to manually enter responses, including overriding pre-populated answers.
+      )
+      test from: :dtr_prepopulation_attest
+      test from: :dtr_prepopulation_override_attest
+    end
+
+    group from: :dtr_smart_app_saving_qr do
+      config(
+        options: {
+          custom: true,
+          adaptive: true,
+          qr_profile_url: 'http://hl7.org/fhir/uv/sdc/StructureDefinition/sdc-questionnaireresponse-adapt'
+        }
+      )
+
+      test from: :dtr_qr_prepopulation,
+           uses_request: :questionnaire_response_save,
+           description: %(
+            The tester will complete the questionnaire such that a QuestionnaireResponse is
+            stored back into Inferno's EHR endpoint. The stored QuestionnaireResponse will be evaluated for:
+            - Has source extensions demonstrating answers that are manually entered,
+              automatically pre-populated, and manually overridden.
+            - Contains answers for all required items.
+           )
+    end
+  end
+end

data/lib/davinci_dtr_test_kit/client_groups/{dinner_adaptive → adaptive_questionnaire/dinner_order}/dtr_adaptive_next_question_retrieval_group.rb

@@ -1,6 +1,6 @@
-require_relative 'dtr_adaptive_next_question_request_test'
-require_relative 'dtr_adaptive_next_question_request_validation_test'
-require_relative 'dtr_adaptive_response_validation_test'
+require_relative '../dtr_adaptive_next_question_request_test'
+require_relative '../dtr_adaptive_next_question_request_validation_test'
+require_relative '../dtr_adaptive_response_validation_test'
 
 module DaVinciDTRTestKit
   class DTRAdaptiveNextQuestionRetrievalGroup < Inferno::TestGroup