davinci_dtr_test_kit 0.12.0 → 0.14.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 5120a6592cc4d31933d917e3214c89c8d505cdf6f8c3d5065d000588988052a8
-  data.tar.gz: c850d248ab0ae414fe399d03749d781e9f8c186525d67ba76c0d9cbad509aa17
+  metadata.gz: ae91fb5204116f970359bf64adea2ee147946908cad1c0c2924af282b60b6881
+  data.tar.gz: 3b03d29e31aa196709ff778838cad35713a07dbc62da4d7b30b4cdfb2c78cff5
 SHA512:
-  metadata.gz: 852190bb650b3f15d3fe25e79a08ba78778aeb85f836f32f6ed5e925859f14196cfb9d5719246a625c85803db6a606526ee2e735669bed0d574adaac3b23b8d9
-  data.tar.gz: 30e796f34e0b3e6b9088a2883af8bda32f8ac26d945c66cc6d4070b925c0eb40b362b9f76036d62b07aef6cc89d41e8c133efbb95d1bfb01233aa0289bd5889b
+  metadata.gz: 8309214d76c859a568d6787cb04fdb973d87ca4c6e2fd1f49c0c373ed5984e468fe473b291bd98aff4af735ba7065b0fd55555f14baa532d49f7f578427213b4
+  data.tar.gz: 130304858f630e00eec87b24c03bf9e303d97a3d5d42624a722da74e7f1ba6aad14e91c70d914af0c5193278190a7eaf5a88dba24eda0ff3a6533aaee4a69421

data/lib/davinci_dtr_test_kit/client_groups/dinner_adaptive/dtr_adaptive_questionnaire_completion_group.rb

@@ -0,0 +1,23 @@
+require_relative 'dtr_adaptive_questionnaire_next_question_retrieval_group'
+
+module DaVinciDTRTestKit
+  class DTRAdaptiveQuestionnaireCompletionGroup < Inferno::TestGroup
+    id :dtr_adaptive_questionnaire_completion
+    title 'Completing the Adaptive Questionnaire'
+    description %(
+      The client makes a final $next-question call, including the answers to all required questions asked so far.
+      Inferno will validate that the request conforms to the [next question operation input parameters profile](http://hl7.org/fhir/uv/sdc/StructureDefinition/parameters-questionnaire-next-question-in)
+      and will update the status of the QuestionnaireResponse resource parameter to `complete`.
+      Inferno will also validate the completed QuestionnaireResponse conformance.
+    )
+
+    config(
+      options: {
+        next_question_prompt_title: 'Last Next Question Request'
+      }
+    )
+    run_as_group
+
+    group from: :dtr_adaptive_questionnaire_next_question_retrieval
+  end
+end

data/lib/davinci_dtr_test_kit/client_groups/dinner_adaptive/dtr_adaptive_questionnaire_followup_questions_group.rb

@@ -0,0 +1,26 @@
+require_relative 'dtr_adaptive_questionnaire_next_question_retrieval_group'
+
+module DaVinciDTRTestKit
+  class DTRAdaptiveQuestionnaireFollowupQuestionsGroup < Inferno::TestGroup
+    id :dtr_adaptive_questionnaire_followup_questions
+    title 'Retrieving the Next Question'
+    description %(
+      The client makes a subsequent call to request the next question or set of questions
+      using the $next-question operation, and including the answers to all required questions
+      in the questionnaire to this point.
+      Inferno will validate that the request conforms to the [next question operation input parameters profile](http://hl7.org/fhir/uv/sdc/StructureDefinition/parameters-questionnaire-next-question-in)
+      and will provide the next questions accordingly for the tester to complete and attest to pre-population
+      and questionnaire rendering.
+    )
+
+    config(
+      options: {
+        next_question_prompt_title: 'Follow-up Next Question Request'
+      }
+    )
+
+    run_as_group
+
+    group from: :dtr_adaptive_questionnaire_next_question_retrieval
+  end
+end

data/lib/davinci_dtr_test_kit/client_groups/dinner_adaptive/dtr_adaptive_questionnaire_next_question_request_test.rb

@@ -0,0 +1,93 @@
+require_relative '../../urls'
+
+module DaVinciDTRTestKit
+  class DTRAdaptiveQuestionnaireNextQuestionRequestTest < Inferno::Test
+    include URLs
+
+    id :dtr_adaptive_questionnaire_next_question_request
+    title 'Invoke the $next-question operation'
+    description %(
+      Inferno will wait for the client to invoke the $next-question operation to retrieve the next question
+      or set of questions.
+      Inferno will validate the request body and update the contained Questionnaire to include
+      the next question or set of questions.
+    )
+
+    input :access_token
+
+    def example_client_jwt_payload_part
+      Base64.strict_encode64({ inferno_client_id: access_token }.to_json).delete('=')
+    end
+
+    def request_identification
+      if config.options[:smart_app]
+        "eyJhbGciOiJub25lIn0.#{example_client_jwt_payload_part}"
+      else
+        access_token
+      end
+    end
+
+    def cont_test_description
+      <<~DESCRIPTION
+        ### 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}?token=#{access_token}) to continue.
+      DESCRIPTION
+    end
+
+    def next_question_prompt_title
+      config.options[:next_question_prompt_title]
+    end
+
+    def next_question_prompt
+      if next_question_prompt_title&.include?('Initial')
+        'Invoke the $next-question operation by sending a POST request to'
+      elsif next_question_prompt_title&.include?('Last')
+        'Answer the remaining questions and then make a final next-question request by sending a POST request to'
+      else
+        "Answer the 'What do you want for dinner' question and then make a next-question request by sending a POST " \
+          'request to'
+      end
+    end
+
+    def prompt_cont
+      if next_question_prompt_title&.include?('Initial')
+        %(Upon receipt, Inferno will provide the first set of questions to complete.)
+      elsif next_question_prompt_title&.include?('Last')
+        %(Upon receipt, Inferno will update the status of the QuestionnaireResponse
+        resource parameter to `complete`.)
+      else
+        %(Upon receipt, Inferno will provide the next set of questions to complete
+        based on previous answers.)
+      end
+    end
+
+    run do
+      wait(
+        identifier: access_token,
+        message: <<~MESSAGE
+          ### #{next_question_prompt_title}
+
+          #{next_question_prompt}
+
+          `#{next_url}`
+
+          #{prompt_cont}
+
+          ### Request Identification
+
+          In order to identify requests for this session, Inferno will look for
+          an `Authorization` header with value:
+
+          ```
+          Bearer #{request_identification}
+          ```
+
+          #{cont_test_description if config.options[:accepts_multiple_requests]}
+        MESSAGE
+      )
+    end
+  end
+end

data/lib/davinci_dtr_test_kit/client_groups/dinner_adaptive/dtr_adaptive_questionnaire_next_question_request_validation_test.rb

@@ -0,0 +1,62 @@
+require_relative '../../urls'
+
+module DaVinciDTRTestKit
+  class DTRAdaptiveQuestionnaireNextQuestionRequestValidationTest < Inferno::Test
+    include URLs
+
+    id :dtr_next_question_request_validation
+    title '$next-question request is valid'
+    description %(
+      Per the [OperationDefinition: Adaptive questionnaire next question](https://build.fhir.org/ig/HL7/sdc/OperationDefinition-Questionnaire-next-question.html#root)
+      section in the [Structured Data Capture IG](http://hl7.org/fhir/uv/sdc/ImplementationGuide/hl7.fhir.uv.sdc),
+      the request body for the `$next-question` operation should be a FHIR Parameters resource containing a
+      single parameter with:
+        - name: `questionnaire-response`
+        - resource: A `QuestionnaireResponse` resource
+
+      As outlined in the [FHIR Operation Request](https://hl7.org/fhir/r4/operations.html#request) section of the
+      FHIR specification, if an operation has exactly one input parameter of type Resource, it can also be invoked via
+      a POST request using that resource as the body (with no additional URL parameters).
+
+      This test validates the structure of the `$next-question` request body. It confirms that the body is either a
+      Parameters resource or a QuestionnaireResponse resource.
+
+      If it is a Parameters resource, it must contain one parameter named `questionnaire-response`
+      with a `resource` attribute set to a FHIR QuestionnaireResponse instance, as specified above.
+
+      The QuestionnaireResponse resource's structure and conformance will be validated
+      in the following test ('Adaptive QuestionnaireResponse is valid').
+    )
+
+    def assert_valid_resource_type(resource)
+      type = resource.resourceType
+      valid = ['Parameters', 'QuestionnaireResponse'].include?(type)
+      assert valid, "Request body not valid. Expected Parameters or QuestionnaireResponse, got #{type}"
+    end
+
+    def next_request_tag
+      config.options[:next_tag]
+    end
+
+    run do
+      load_tagged_requests next_request_tag
+      skip_if request.blank?, 'A $next-question request must be made prior to running this test'
+
+      assert request.url == next_url, "Request made to wrong URL: #{request.url}. Should instead be to #{next_url}"
+      assert_valid_json(request.request_body)
+      input_params = FHIR.from_contents(request.request_body)
+      assert input_params.present?, 'Request does not contain a recognized FHIR object'
+      assert_valid_resource_type(input_params)
+
+      if input_params.is_a?(FHIR::Parameters)
+        questionnaire_response_params = input_params.parameter.select { |param| param.name == 'questionnaire-response' }
+        qr_params_count = questionnaire_response_params.length
+        assert qr_params_count == 1,
+               "Input parameter must contain one `parameter:questionnaire-response` slice. Found #{qr_params_count}"
+
+        questionnaire_response =  questionnaire_response_params.first.resource
+        assert_resource_type(:questionnaire_response, resource: questionnaire_response)
+      end
+    end
+  end
+end

data/lib/davinci_dtr_test_kit/client_groups/dinner_adaptive/dtr_adaptive_questionnaire_next_question_retrieval_group.rb

@@ -0,0 +1,23 @@
+require_relative 'dtr_adaptive_questionnaire_next_question_request_test'
+require_relative 'dtr_adaptive_questionnaire_next_question_request_validation_test'
+require_relative 'dtr_adaptive_questionnaire_response_validation_test'
+
+module DaVinciDTRTestKit
+  class DTRAdaptiveQuestionnaireNextQuestionRetrievalGroup < Inferno::TestGroup
+    id :dtr_adaptive_questionnaire_next_question_retrieval
+    title 'Next Question Request and Validation'
+    description %(
+      Inferno will wait for the client system to request the next question (or set of questions) using the
+      $next-question operation and will return an updated QuestionnaireResponse with a contained Questionnaire
+      that includes the next question (or set of questions) for the tester to complete.
+      Inferno will then validate the conformance of the request.
+    )
+
+    # Test 1: wait for the $next-question request
+    test from: :dtr_adaptive_questionnaire_next_question_request
+    # Test 2: validate the $next-question request
+    test from: :dtr_next_question_request_validation
+    # Test 3: validate the QuestionnaireResponse in the input parameter
+    test from: :dtr_adaptive_questionnaire_response_validation
+  end
+end

data/lib/davinci_dtr_test_kit/client_groups/dinner_adaptive/dtr_adaptive_questionnaire_response_validation_test.rb

@@ -0,0 +1,66 @@
+require_relative '../../urls'
+require_relative '../../dtr_questionnaire_response_validation'
+
+module DaVinciDTRTestKit
+  class DTRAdaptiveQuestionnaireResponseValidationTest < Inferno::Test
+    include URLs
+    include DTRQuestionnaireResponseValidation
+
+    id :dtr_adaptive_questionnaire_response_validation
+    title 'Adaptive QuestionnaireResponse is valid'
+    description %(
+      This test validates the conformance of the Adative QuestionnaireResponse to the
+      [SDCQuestionnaireResponseAdapt](http://hl7.org/fhir/uv/sdc/StructureDefinition/sdc-questionnaireresponse-adapt)
+      structure. It verifies the presence of mandatory elements and that elements
+      with required bindings contain appropriate values.
+
+       It also ensures that all required questions are answered, and that the `origin.source`
+      extension is correct for each answer:
+        - `PBD.1` (Last Name) and `LOC.1` (Location): `auto`
+        - `PBD.2` (First Name): `override`
+        - `3` (all nested dinner questions): `manual`
+
+      Note: For the initial next-question request, only the conformance to the profile is checked
+      since neither the QuestionnaireResponse nor the contained Questionnaire will have any items,
+      as no questions are yet known.
+    )
+
+    def profile_url
+      'http://hl7.org/fhir/uv/sdc/StructureDefinition/sdc-questionnaireresponse-adapt'
+    end
+
+    def next_request_tag
+      config.options[:next_tag]
+    end
+
+    run do
+      load_tagged_requests next_request_tag
+      skip_if request.blank?, 'A $next-question request must be made prior to running this test'
+
+      assert request.url == next_url, "Request made to wrong URL: #{request.url}. Should instead be to #{next_url}"
+      assert_valid_json(request.request_body)
+      input_params = FHIR.from_contents(request.request_body)
+      skip_if input_params.blank?, 'Request does not contain a recognized FHIR object'
+
+      questionnaire_response = nil
+      if input_params.is_a?(FHIR::QuestionnaireResponse)
+        questionnaire_response = input_params
+      elsif input_params.is_a?(FHIR::Parameters)
+        questionnaire_response = input_params.parameter&.find do |param|
+          param.name == 'questionnaire-response'
+        end&.resource
+      end
+
+      skip_if questionnaire_response.nil?, 'QuestionnaireResponse resource not provided.'
+      verify_basic_conformance(questionnaire_response.to_json, profile_url)
+
+      questionnaire = questionnaire_response.contained.find { |res| res.resourceType == 'Questionnaire' }
+      check_origin_sources(questionnaire.item, questionnaire_response.item, expected_overrides: ['PBD.2'])
+
+      required_link_ids = extract_required_link_ids(questionnaire.item)
+      check_answer_presence(questionnaire_response.item, required_link_ids)
+
+      assert(messages.none? { |m| m[:type] == 'error' }, 'QuestionnaireResponse is not correct, see error message(s)')
+    end
+  end
+end

data/lib/davinci_dtr_test_kit/client_groups/dinner_adaptive/dtr_full_ehr_adaptive_dinner_questionnaire_workflow_group.rb

@@ -0,0 +1,76 @@
+require_relative '../../tags'
+require_relative 'dtr_full_ehr_adaptive_questionnaire_initial_retrieval_group'
+require_relative '../full_ehr/dtr_full_ehr_prepopulation_attestation_test'
+require_relative '../full_ehr/dtr_full_ehr_prepopulation_override_attestation_test'
+require_relative 'dtr_adaptive_questionnaire_followup_questions_group'
+require_relative 'dtr_adaptive_questionnaire_completion_group'
+
+module DaVinciDTRTestKit
+  class DTRFullEHRAdaptiveDinnerQuestionnaireWorkflowGroup < Inferno::TestGroup
+    id :dtr_full_ehr_adaptive_dinner_questionnaire_workflow
+    title 'Adaptive Questionnaire Workflow'
+    description %(
+      This test validates that a DTR Full EHR client can perform a full DTR Adaptive Questionnaire workflow
+      using a mocked questionnaire requesting what a patient wants for dinner. The client system must
+      demonstrate their ability to:
+
+      1. Fetch the adaptive questionnaire package
+        ([DinnerOrderAdaptive](https://github.com/inferno-framework/davinci-dtr-test-kit/blob/main/lib/davinci_dtr_test_kit/fixtures/dinner_adaptive/questionnaire_dinner_order_adaptive.json))
+      2. Fetch the first set of questions and render and pre-populate them appropriately, including:
+         - pre-populate data as directed by the questionnaire
+         - display questions only when they are enabled
+      3. Answer the initial questions and request additional questions
+      4. Complete the questionnaire and provide the completed QuestionnaireResponse
+         with appropriate indicators for pre-populated and manually-entered data.
+    )
+
+    group do
+      id :dtr_full_ehr_adaptive_questionnaire_retrieval
+      title 'Retrieving the Adaptive Questionnaire'
+      description %(
+        After DTR launch, Inferno will wait for the client system to request a questionnaire using the
+        $questionnaire-package operation and follow up with an initial $next-question request to retrieve
+        the first set of questions.
+
+        The initial set of questions will be returned for the tester to complete and attest to pre-population
+        and questionnaire rendering.
+
+        Inferno will also validate the conformance of the requests.
+      )
+      run_as_group
+
+      group from: :dtr_full_ehr_adaptive_questionnaire_initial_retrieval
+      group do
+        id :dtr_full_ehr_initial_questionnaire_rendering
+        title 'Filling Out the Questionnaire'
+        description %(
+          The tester will interact with the questionnaire within their client system
+          such that pre-population steps are taken, the qustionnaire is rendered, and
+          they are able to fill it out. The tester will attest that questionnaire pre-population
+          and rendering directives were followed.
+        )
+
+        # Test 1: attest to the pre-population of the name fields
+        test from: :dtr_full_ehr_prepopulation_attestation
+        # Test 2: attest to the pre-population and edit of the first name field
+        test from: :dtr_full_ehr_prepopulation_override_attestation
+      end
+    end
+
+    group from: :dtr_adaptive_questionnaire_followup_questions,
+          config: {
+            options: {
+              accepts_multiple_requests: true,
+              next_tag: "followup_#{CLIENT_NEXT_TAG}"
+            }
+          }
+
+    group from: :dtr_adaptive_questionnaire_completion,
+          config: {
+            options: {
+              accepts_multiple_requests: true,
+              next_tag: "completion_#{CLIENT_NEXT_TAG}"
+            }
+          }
+  end
+end

data/lib/davinci_dtr_test_kit/client_groups/dinner_adaptive/dtr_full_ehr_adaptive_questionnaire_initial_retrieval_group.rb

@@ -0,0 +1,27 @@
+require_relative '../../tags'
+require_relative '../full_ehr/dtr_full_ehr_launch_attestation_test'
+require_relative 'dtr_full_ehr_adaptive_questionnaire_request_test'
+require_relative '../shared/dtr_questionnaire_package_request_validation_test'
+require_relative 'dtr_adaptive_questionnaire_next_question_request_validation_test'
+require_relative 'dtr_adaptive_questionnaire_response_validation_test'
+
+module DaVinciDTRTestKit
+  class DTRFullEHRAdaptiveQuestionnaireInitialRetrievalGroup < Inferno::TestGroup
+    id :dtr_full_ehr_adaptive_questionnaire_initial_retrieval
+    title 'Adaptive Questionnaire Package and Initial Questions Retrieval'
+
+    config(options: { next_tag: "initial_#{CLIENT_NEXT_TAG}" })
+    run_as_group
+
+    # Test 0: attest to launch
+    test from: :dtr_full_ehr_launch_attestation
+    # Test 1: wait for the $questionnaire-package request and initial $next-question request
+    test from: :dtr_full_ehr_adaptive_questionnaire_request
+    # Test 2: validate the $questionnaire-package request body
+    test from: :dtr_questionnaire_package_request_validation
+    # Test 3: validate the $next-question request body
+    test from: :dtr_next_question_request_validation
+    # Test 4: validate the QuestionnaireResponse in the input parameter
+    test from: :dtr_adaptive_questionnaire_response_validation
+  end
+end

data/lib/davinci_dtr_test_kit/client_groups/dinner_adaptive/dtr_full_ehr_adaptive_questionnaire_request_test.rb

@@ -0,0 +1,63 @@
+require_relative '../../urls'
+
+module DaVinciDTRTestKit
+  class DTRFullEHRAdaptiveQuestionnaireRequestTest < Inferno::Test
+    include URLs
+
+    id :dtr_full_ehr_adaptive_questionnaire_request
+    title 'Invoke the Questionnaire Package and Initial Next Question Operation'
+    description %(
+      This test waits for two sequential client requests:
+
+      1. **Questionnaire Package Request**: The client should first invoke the `$questionnaire-package` operation
+      to retrieve the adaptive questionnaire package. Inferno will respond to this request with an empty adaptive
+      questionnaire.
+
+      2. **Initial Next Question Request**: After receiving the package, the client should invoke the
+      `$next-question` operation. Inferno will respond by providing the first set of questions.
+    )
+
+    config options: { accepts_multiple_requests: true }
+    input :access_token
+
+    run do
+      wait(
+        identifier: access_token,
+        message: %(
+          ### Adaptive Questionnaire Retrieval
+
+          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 an empty adaptive questionnaire.
+
+          2. **Initial Next Question Request**:
+            - After receiving the questionnaire package, invoke the `$next-question` operation by sending
+            a POST request to the following endpoint to retrieve the first set of questions:
+
+              `#{next_url}`.
+
+            - Inferno will respond with the initial set of questions.
+
+          Inferno will wait for both of these requests to be made.
+
+          ### Request Identification
+
+          In order to identify requests for this session, Inferno will look for
+          an `Authorization` header with value:
+
+          ```
+          Bearer #{access_token}
+          ```
+
+          ### Continuing the Tests
+
+          When both requests have been made, [Click here](#{resume_pass_url}?token=#{access_token}) to continue.
+        )
+      )
+    end
+  end
+end

data/lib/davinci_dtr_test_kit/client_groups/dinner_adaptive/dtr_smart_app_adaptive_questionnaire_initial_retrieval_group.rb

@@ -0,0 +1,24 @@
+require_relative '../../tags'
+require_relative 'dtr_smart_app_adaptive_questionnaire_request_test'
+require_relative '../shared/dtr_questionnaire_package_request_validation_test'
+require_relative 'dtr_adaptive_questionnaire_next_question_request_validation_test'
+require_relative 'dtr_adaptive_questionnaire_response_validation_test'
+
+module DaVinciDTRTestKit
+  class DTRSmartAppAdaptiveQuestionnaireInitialRetrievalGroup < Inferno::TestGroup
+    id :dtr_smart_app_adaptive_questionnaire_initial_retrieval
+    title 'Adaptive Questionnaire Package and Initial Questions Retrieval'
+
+    config(options: { next_tag: "initial_#{CLIENT_NEXT_TAG}" })
+    run_as_group
+
+    # Test 1: wait for the $questionnaire-package request and initial $next-question request
+    test from: :dtr_smart_app_adaptive_questionnaire_request
+    # Test 2: validate the $questionnaire-package request body
+    test from: :dtr_questionnaire_package_request_validation
+    # Test 3: validate the $next-question request body
+    test from: :dtr_next_question_request_validation
+    # Test 4: validate the QuestionnaireResponse in the input parameter
+    test from: :dtr_adaptive_questionnaire_response_validation
+  end
+end

data/lib/davinci_dtr_test_kit/client_groups/dinner_adaptive/dtr_smart_app_adaptive_questionnaire_request_test.rb

@@ -0,0 +1,148 @@
+require_relative '../../urls'
+
+module DaVinciDTRTestKit
+  class DTRSmartAppAdaptiveQuestionnaireRequestTest < Inferno::Test
+    include URLs
+
+    id :dtr_smart_app_adaptive_questionnaire_request
+    title 'Invoke the Questionnaire Package and Initial Next Question Operation'
+    description %(
+      This test waits for two sequential client requests:
+
+      1. **Questionnaire Package Request**: The client should first invoke the `$questionnaire-package` operation
+      to retrieve the adaptive questionnaire package. Inferno will respond to this request with an empty adaptive
+      questionnaire.
+
+      2. **Initial Next Question Request**: After receiving the package, the client should invoke the
+      `$next-question` operation. Inferno will respond by providing the first set of questions.
+    )
+
+    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 (Dinner 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 (Dinner 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 (Dinner Adaptive)',
+          type: 'textarea',
+          description: %(
+            Resources available from the EHR needed to drive the dinner 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>
+          )
+
+    def example_client_jwt_payload_part
+      Base64.strict_encode64({ inferno_client_id: client_id }.to_json).delete('=')
+    end
+
+    run do
+      # 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 Retrieval
+
+          1. **Questionnaire Package Request**:
+            - Inferno will expect the SMART App to invoke the DTR Questionnaire Package operation by sending a POST
+            request to
+
+            `#{questionnaire_package_url}`
+
+            - Inferno will respond with an empty adaptive questionnaire.
+
+          2. **Initial Next Question Request**:
+            - After receiving the questionnaire package, invoke the `$next-question` operation by sending
+            a POST request to the following endpoint to retrieve the first set of questions:
+
+              `#{next_url}`.
+
+            - Inferno will respond with the initial set of questions.
+
+          ### 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