davinci_dtr_test_kit 0.17.0 → 0.18.0

data/lib/davinci_dtr_test_kit/full_ehr/v2.2.0/interaction/adaptive_questionnaires_completed_test.rb

@@ -0,0 +1,108 @@
+require_relative '../../../urls'
+require_relative '../../../cross_suite/v2.2.0/multi_request_message_helper'
+require_relative '../../short_circuit_interaction_verification'
+require_relative '../../../cross_suite/v2.2.0/questionnaire_helper'
+
+module DaVinciDTRTestKit
+  class DTRFullEHRV220AdaptiveQuestionnairesCompletedTest < Inferno::Test
+    include URLs
+    include MultiRequestMessageHelper
+    include ShortCircuitInteractionVerification
+    include QuestionnaireHelper
+
+    id :dtr_full_ehr_v220_adaptive_questionnaires_completed
+    title 'Adaptive Questionnaires Completed'
+    description %(
+      This test validates that all adaptive Questionnaires returned by Inferno during
+      this interaction were completed as shown by a $next-question request where Inferno
+      updated the status of the QuestionnaireResponse to `completed`.
+    )
+
+    def target_qp_tags
+      tags = [QUESTIONNAIRE_PACKAGE_TAG]
+      tags << config.options[:dtr_workflow_tag] if config.options[:dtr_workflow_tag].present?
+
+      tags
+    end
+
+    def target_nq_tags
+      tags = [CLIENT_NEXT_TAG]
+      tags << config.options[:dtr_workflow_tag] if config.options[:dtr_workflow_tag].present?
+
+      tags
+    end
+
+    def qp_requests_to_analyze
+      @qp_requests_to_analyze ||= load_tagged_requests(*target_qp_tags)
+    end
+
+    def nq_requests_to_analyze
+      @nq_requests_to_analyze ||= load_tagged_requests(*target_nq_tags)
+    end
+
+    def adaptive_questionnaire_canonicals
+      @adaptive_questionnaire_canonicals ||=
+        qp_requests_to_analyze.each_with_object([]) do |request, adaptive_questionnaires|
+          request_parameters = FHIR.from_contents(request.response_body)
+          next unless request_parameters.is_a?(FHIR::Parameters)
+
+          adaptive_questionnaires.concat(
+            questionnaires_from_questionnaire_package_output_parameters(request_parameters, include_standard: false)
+              .map { |questionnaire| questionnaire_canonical_url(questionnaire) }
+          )
+        rescue JSON::ParserError
+          next
+        end
+    end
+
+    def completed_questionnaire_canonicals
+      @completed_questionnaire_canonicals ||=
+        nq_requests_to_analyze.each_with_object([]) do |request, completed_questionnaires|
+          contained_questionnaire = completed_contained_questionnaire(request)
+          next unless contained_questionnaire.present?
+
+          completed_questionnaires << questionnaire_canonical_url(contained_questionnaire)
+        rescue JSON::ParserError
+          next
+        end
+    end
+
+    # Returns the contained Questionnaire from a $next-question response's QuestionnaireResponse,
+    # but only when Inferno marked that QuestionnaireResponse `completed` -- an in-progress adaptive
+    # workflow hasn't finished yet.
+    def completed_contained_questionnaire(request)
+      response_body = FHIR.from_contents(request.response_body)
+      response_questionnaire_response = questionnaire_response_from_next_question_response(response_body)
+      return nil unless response_questionnaire_response.present?
+      return nil unless response_questionnaire_response.status == 'completed'
+
+      contained_questionnaire_from_questionnaire_response(response_questionnaire_response)
+    end
+
+    run do
+      check_for_short_circuit(ok_message: config.options[:short_circuit_pass_message])
+      skip_if no_questionnaires_returned?(qp_requests_to_analyze),
+              'No Questionnaire Package requests returned a Questionnaire.'
+
+      clear_adaptive_short_circuit_flag
+      if adaptive_questionnaire_canonicals.blank?
+        if config.options[:adaptive_questionnaires_optional]
+          short_circuit_adaptive_validation_tests
+          pass SHORT_CIRCUIT_ADAPTIVE_MESSAGE
+        else
+          skip 'Adaptive Questionnaires required to be demonstrated during this scenario but none were returned.'
+        end
+      end
+
+      adaptive_questionnaire_canonicals.each do |target_canonical|
+        next if completed_questionnaire_canonicals.include?(target_canonical)
+
+        add_message('error', "Adaptive Questionnaire with canonical url `#{target_canonical}` was never completed.")
+      end
+
+      assert_no_error_messages(
+        'Adaptive Questionnaires retrieved but not completed. See Messages for details.'
+      )
+    end
+  end
+end

data/lib/davinci_dtr_test_kit/full_ehr/v2.2.0/interaction/interaction_wait_test.rb

@@ -0,0 +1,177 @@
+require_relative '../../descriptions'
+require_relative '../../../urls'
+require_relative '../next_question_template_questionnaires'
+require_relative '../../short_circuit_interaction_verification'
+
+module DaVinciDTRTestKit
+  class DTRFullEHRV220InteractionWaitTest < Inferno::Test
+    include URLs
+    include NextQuestionTemplateQuestionnaires
+    include ShortCircuitInteractionVerification
+
+    id :dtr_full_ehr_v220_interaction_wait
+    title 'Retrieve and complete Questionnaire(s)'
+    description %(
+      Inferno will act as a Payer DTR Server while the tester launches DTR and completes the questionnaire.
+    )
+
+    input :client_id,
+          title: 'Client Id',
+          type: 'text',
+          optional: false,
+          locked: true,
+          description: INPUT_CLIENT_ID_LOCKED
+    # input :questionaire_package_response_template,
+    #       title: '$questionnaire-package Response Template',
+    #       type: 'textarea',
+    #       optional: true,
+    #       description: %(
+    #         Template used to generate responses to invocations of the $questionnaire-package
+    #         operation. This will be a single Parameters resource in json form. Inferno will
+    #         select the `parameter` entries within it to return based on selection criteria
+    #         within the template evaluated against the request details.
+    #       ),
+    #       default: '{ "ResourceType": "Parameters" }'
+    # input :next_question_response_template,
+    #       title: '$next-question Response Template',
+    #       type: 'textarea',
+    #       optional: true,
+    #       description: %(
+    #         Template used to generate responses to invocations of the $questionnaire-package
+    #         operation. This will be a list of Questionnaire resources in json form. Inferno
+    #         will select which Questionnaire to use based on the Questionnaire url indicated
+    #         in the request and will select the `item` entries to add based on selection criteria
+    #         within the template evaluated against the request details.
+    #       ),
+    #       default: '[]'
+    # input :value_set_expansions,
+    #       title: 'ValueSet $expand Data',
+    #       type: 'textarea',
+    #       optional: true,
+    #       description: %(
+    #         Template used to generate responses to invocations of the ValueSet/$expand
+    #         operation. This will be a list of ValueSet resources in json form. Inferno
+    #         will select the entry to use by matching the `url` parameter against the
+    #         ValueSet `url` element.
+    #       ),
+    #       default: '[]'
+    output :continuation_url
+
+    run do
+      clear_short_circuit_flag
+      unless run_tests?
+        short_circuit_validation_tests(:pass)
+        short_circuit_pass(message: config.options[:short_circuit_pass_message])
+      end
+
+      validate_response_template_inputs
+
+      continuation_url = "#{resume_pass_url}?token=#{client_id}"
+      output(continuation_url:)
+
+      wait(
+        identifier: client_id,
+        timeout: 1200,
+        message: %(
+          Inferno will wait while the tester uses the system to complete
+          one or more DTR Questionnaires retrieved from Inferno's simulated
+          payer server.
+
+          When all Questionnaire returned by Inferno during this period
+          have been completed and saved to the EHR [Click here](#{continuation_url})
+          to continue.
+
+          ### Endpoints
+
+          Available endpoints on Inferno's simulated payer server include
+
+          - FHIR Base: `#{fhir_base_url}
+          - Questionnaire Package Operation: `#{questionnaire_package_url}`
+          - Next Question Operation: `#{next_url}`
+
+          ### Authenticated and Identification
+
+          Requests must be authenticated by first obtaining an access token
+          for client `#{client_id}` from Inferno's token endpoint: `#{token_url}`.
+          Only requests including an obtained access token as a bearer token
+          in the `Authentication` header of the HTTP request will be recognized
+          as associated with this session and return successful responses.
+        )
+      )
+    end
+
+    # other things that might go into the wait message
+    # - Whether multiple successful $questionnaire-package requests are allowed (options)
+    # - specific instructions for completion (TODO)
+    # - whether the Questionnaires are provided by Inferno or the tester (options)
+
+    private
+
+    def run_tests?
+      input_name = config.options[:short_circuit_pass_input]
+      return true if input_name.blank?
+
+      send(input_name) == 'true'
+    end
+
+    def validate_response_template_inputs
+      validate_qp_response_template_input
+      validate_nq_questionnaire_template_input
+    rescue Inferno::Exceptions::AssertionException => e
+      short_circuit_validation_tests(:skip)
+      raise e
+    end
+
+    def validate_qp_response_template_input
+      input_name = config.options[:qp_response_template_input]
+      return if input_name.blank?
+
+      title = input_title(input_name)
+      value = send(input_name)
+      assert value.present?, "No response template provided by the user in input '#{title}'."
+
+      parsed = parse_qp_template_value(value, title)
+      assert parsed.is_a?(FHIR::Parameters),
+             "Input '#{title}' must contain a Parameters resource for the $questionnaire-package " \
+             'response template.'
+    end
+
+    def parse_qp_template_value(value, title)
+      FHIR.from_contents(value)
+    rescue StandardError
+      assert false, "Input '#{title}' does not contain valid JSON."
+    end
+
+    # Unlike the endpoint's own parsing (which silently discards array entries that aren't
+    # Questionnaires, since the tester may legitimately be mid-workflow when a request comes in),
+    # this pre-wait check fails on the first bad entry: there's no reason to let the tester start
+    # the interaction with a template that's already known to be broken.
+    def validate_nq_questionnaire_template_input
+      input_name = config.options[:nq_questionnaire_template_input]
+      return if input_name.blank?
+
+      title = input_title(input_name)
+      value = send(input_name)
+      assert value.present?, "No response template provided by the user in input '#{title}'."
+
+      parsed_json = JSON.parse(value)
+      is_array = parsed_json.is_a?(Array)
+      questionnaire_jsons = is_array ? parsed_json : [parsed_json]
+
+      questionnaire_jsons.each_with_index do |questionnaire_json, index|
+        next if parse_template_questionnaire(questionnaire_json).present?
+
+        location = is_array ? "at index #{index} of input '#{title}'" : "in input '#{title}'"
+        assert false, "Invalid $next-question response template: expected a Questionnaire #{location}."
+      end
+    rescue JSON::ParserError
+      assert false, "Input '#{title}' does not contain valid JSON."
+    end
+
+    # config.options input references are stored as input names (e.g. 'additional_ms_qp_responses');
+    # testers only ever see the input's title in the UI, so error messages should use that instead.
+    def input_title(input_name)
+      config.input(input_name.to_sym)&.title || input_name
+    end
+  end
+end

data/lib/davinci_dtr_test_kit/full_ehr/v2.2.0/interaction/ui_display_and_interaction_attestation_test.rb

@@ -0,0 +1,132 @@
+require 'securerandom'
+require_relative '../../../urls'
+require_relative '../../short_circuit_interaction_verification'
+require_relative '../../../cross_suite/v2.2.0/questionnaire_helper'
+
+module DaVinciDTRTestKit
+  class DTRFullEHRV220UIDisplayAndInteractionAttestationTest < Inferno::Test
+    include URLs
+    include ShortCircuitInteractionVerification
+    include QuestionnaireHelper
+
+    id :dtr_full_ehr_v220_ui_display_and_interaction
+    title 'Client correctly displays and allows users to interact with the questionnaire(s)'
+    description %(
+      During this test, the tester will confirm that during the previous interaction
+      the client system was able to fully support the completion of the Questionnaires
+      returned by Inferno's simulated DTR payer server. Most details showing that the client
+      conformed to the DTR specification in its support for Questionnaires are not visible
+      to Inferno, so it is the responsibility of the tester to confirm that the Questionnaires
+      were faithfully computed, displayed, and saved per the DTR requirements.
+
+      Notable requirements that testers are expected to demonstrate and attest client conformance to
+      include:
+      - The ability to calculate, render, and allow users to fill out forms specified as Questionnaires as
+        directed by the Questionnaire's elements and extensions: Completing Questionnaires is a visual task
+        and DTR and the underlying Structured Data Capture specification contain many details about directives
+        that control the behavior of Questionnaires while users are completing them. Clients are required to
+        support the behavior of the Questionnaire items and extensions listed as must support, and they are
+        required to support or gracefully ignore non-must support items and extensions present on the differential
+        tabs of DTR Questionnaire profiles ([base](https://hl7.org/fhir/us/davinci-dtr/2.2.0/en/StructureDefinition-dtr-base-questionnaire.html),
+        [standard](https://hl7.org/fhir/us/davinci-dtr/2.2.0/en/StructureDefinition-dtr-std-questionnaire.html),
+        and [adaptive](https://hl7.org/fhir/us/davinci-dtr/2.2.0/en/StructureDefinition-dtr-questionnaire-adapt.html)).
+        By attesting **true** during this test, the tester confirms that each of the must support or differential
+        items observed within the Questionnaires returned during the previous interaction were exercised and
+        appropriately supported by the client and resulted in the correct behavior (or were ignored if allowed).
+      - The ability to complete standard Questionnaires: unlike adaptive Questionnaires, where Inferno
+        acting as the payer sees the QuestionnaireResponse on $next-question requests and determines
+        whether it is complete, Inferno has no access to QuestionnaireResponses for standard Questionnaires.
+        By attesting **true** during this test, the tester confirms that each unique Questionnaire returned
+        by Inferno during the previous interaction, including the standard Questionnaires, was completed at least once.
+      - The ability to store completed forms for use as a QuestionnaireResponse: Completed forms are generally
+        intended to be communicated to downstream systems for particularly uses, but DTR does not specify an
+        access mechanism or required communication API. Thus, Inferno does not have a way to see and confirm
+        that completed forms have been stored appropriately and made avaialble as QuestionnaireResponses. By
+        attesting **true** during this test, tester confirm that all completed Questionnaires were stored
+        in such a way as to allow downstream communication as QuestionnaireResponses.
+
+      To assist testers in making these determinations, the attestation dialog will include
+      - The list of unique Questionnaires returned during the previous interaction so that testers
+        can confirm that each unique Questionnaires was completed at least once and all completed forms were stored.
+      - The list of Questionnaire must support elements and extensions observed within the Questionnaires
+        returned during the previous interaction along with links to descriptions of them so that testers
+        can confirm that they were exercised, appropriately supported, and drove the correct form behavior.
+      - The list of Questionnaire non-must support differential elements and extensions observed within the
+        Questionnaires returned during the previous interaction along with links to descriptions of them so
+        that testers can confirm that they were exercised, appropriately supported, and drove the correct form behavior
+        or were gracefully ignored without hindering completion of the form.
+    )
+
+    output :attest_true_url
+    output :attest_false_url
+
+    def target_tags
+      tags = [QUESTIONNAIRE_PACKAGE_TAG]
+      tags << config.options[:dtr_workflow_tag] if config.options[:dtr_workflow_tag].present?
+
+      tags
+    end
+
+    def requests_to_analyze
+      @requests_to_analyze ||= load_tagged_requests(*target_tags)
+    end
+
+    def returned_questionnaires_for_display
+      requests_to_analyze.each_with_object([]) do |request, questionnaires|
+        request_parameters = FHIR.from_contents(request.response_body)
+        next unless request_parameters.is_a?(FHIR::Parameters)
+
+        questionnaires.concat(
+          questionnaires_from_questionnaire_package_output_parameters(request_parameters)
+            .map { |questionnaire| questionnaire_display(questionnaire) }
+        )
+      rescue JSON::ParserError
+        next
+      end.uniq
+    end
+
+    LIST_ENTRY_PREFIX = "\n          - ".freeze
+
+    run do
+      check_for_short_circuit(ok_message: config.options[:short_circuit_pass_message])
+      skip_if no_questionnaires_returned?(requests_to_analyze),
+              'No Questionnaire Package requests returned a Questionnaire.'
+
+      identifier = SecureRandom.hex(32)
+      attest_true_url = "#{resume_pass_url}?token=#{identifier}"
+      attest_false_url = "#{resume_fail_url}?token=#{identifier}"
+      output(attest_true_url:)
+      output(attest_false_url:)
+
+      wait(
+        identifier: identifier,
+        message: %(
+          I attest that the DTR client application supported the completion
+          of all unique Questionnaires returned by Inferno in response to client requests
+          during the previous interaction, including
+          - Rendering, pre-populating answers, and allowing users to fill out the form as
+            indicated by the items and directives in the Questionnaires (see list of
+            observed items and extensions below).
+          - Storage of each completed Questionnaires for later use as QuestionnaireResponses
+            (see list of returned Questionnaires below).
+
+          [Click here](#{attest_true_url}) if the above statement is **true**.
+
+          [Click here](#{attest_false_url}) if the above statement is **false**.
+
+          -------------
+
+          Questionnaires returned during the previous interaction for which a
+          response must have been completed and stored to attest **true**:
+          - #{returned_questionnaires_for_display.join(LIST_ENTRY_PREFIX)}
+
+          Must Support Questionnaire items and extensions that must have been followed
+          to attest **true**: TODO
+
+          Additional Questionnaire items and extensions that must have been followed or
+          gracefully ignored to attest **true**: TODO
+        )
+      )
+    end
+  end
+end

data/lib/davinci_dtr_test_kit/full_ehr/v2.2.0/must_support/dtr_additional_questionnaires_interaction_group.rb

@@ -0,0 +1,74 @@
+require_relative '../dtr_full_ehr_abstract_adaptive_group'
+
+module DaVinciDTRTestKit
+  class DTRFullEHRV220AdditionalQuestionnairesForMS < DTRFullEHRV220AbstractAdaptive
+    title 'Additional Questionnaires for Must Support Coverage'
+    id :dtr_full_ehr_v220_additional_qustionnaires_for_ms
+    description <<~DESCRIPTION
+      During this group, the DTR client will have the opportunity to
+      complete additional Questionnaires to demonstrate must support
+      element coverage.
+    DESCRIPTION
+    run_as_group
+
+    config(
+      options: {
+        qp_single_use: false,
+        dtr_workflow_tag: 'additional_must_support',
+        qp_response_template_input: 'additional_ms_qp_responses',
+        nq_questionnaire_template_input: 'additional_ms_nq_responses',
+        short_circuit_pass_input: 'complete_additional_questionnaires',
+        short_circuit_pass_message: 'Tester chose not to complete additional Questionnaires.',
+        adaptive_questionnaires_optional: true
+      }
+    )
+
+    input :complete_additional_questionnaires,
+          title: 'Complete additional Questionnaires?',
+          type: 'radio',
+          options: {
+            list_options: [
+              {
+                label: 'Yes, demonstrate more Questionnaires with additional must support elements now.',
+                value: 'true'
+              },
+              {
+                label: 'No, all must support elements were already demonstrated in previous tests.',
+                value: 'false'
+              }
+            ]
+          },
+          optional: false,
+          description: %(
+            Must support evaluation will consider all Questionnaires completed during the most
+            recent execution of each scenario during this session. Select `Yes` to provide
+            additional Questionnaires for Inferno to respond with now so that the remaining must support
+            elements can be demonstrated. Otherwise, select `No` to evaluate must support requirements
+            without completing additional Questionnaires.
+          ),
+          default: 'true'
+    input :additional_ms_qp_responses,
+          title: 'Additional Must Support $questionnaire-package Response Template',
+          type: 'textarea',
+          optional: false,
+          description: %(
+            Template for $questionnaire-package responses for Inferno to send back.
+          ),
+          enable_when: { input_name: 'complete_additional_questionnaires', value: 'true' },
+          default: File.read(File.join(__dir__, '..', '..', 'fixtures', 'empty_templates',
+                                       'parameters_questionnaire_package_empty.json'))
+    input :additional_ms_nq_responses,
+          title: 'Additional Must Support $next-question Response Template',
+          type: 'textarea',
+          optional: false,
+          description: %(
+            Template for $next-question responses for Inferno to send back. May be a single
+            Questionnaire or a JSON array of Questionnaires; when an array is provided, Inferno
+            selects the first Questionnaire whose url (and version, if the request's contained
+            Questionnaire has one) matches the contained Questionnaire in the request.
+          ),
+          enable_when: { input_name: 'complete_additional_questionnaires', value: 'true' },
+          default: File.read(File.join(__dir__, '..', '..', 'fixtures', 'empty_templates',
+                                       'next_question_template_empty.json'))
+  end
+end

data/lib/davinci_dtr_test_kit/full_ehr/v2.2.0/must_support/dtr_questionnaire_adaptive_must_support_test.rb

@@ -0,0 +1,45 @@
+require_relative '../../../tags'
+require_relative '../../../cross_suite/v2.2.0/questionnaire_helper'
+require_relative '../../../cross_suite/generated_profile_metadata'
+
+module DaVinciDTRTestKit
+  class DTRFullEHRV220QuestionnaireAdaptiveMustSupportTest < Inferno::Test
+    include QuestionnaireHelper
+
+    MUST_SUPPORT_METADATA = GeneratedProfileMetadata.for('v2.2.0', 'dtr_questionnaire_adapt')
+
+    id :dtr_full_ehr_v220_questionnaire_adaptive_must_support
+    title 'Client supports adaptive Questionnaire must support elements and extensions'
+    description %(
+      This test confirms that all must support elements added in the
+      [DTR Questionnaire for adaptive form](https://hl7.org/fhir/us/davinci-dtr/2.2.0/en/StructureDefinition-dtr-questionnaire-adapt.html)
+      ave been observed across all completed adaptive Questionnaires during previous tests.
+      This does not include must support elements flagged within the
+      [DTR Base Questionnaire](https://hl7.org/fhir/us/davinci-dtr/2.2.0/en/StructureDefinition-dtr-base-questionnaire.html)
+      profile. Note that adaptive Questionnaires from test scenarios where the Questionnaire
+      was not completed, e.g., due to errors within referenced CQL, are not included in this
+      analysis. During execution of those previous tests, testers attested to the correct
+      display of, interaction with, and population of the Questionnaires as controlled by
+      the elements aand extensions present in those Questionnaires.
+
+      This includes the following elements:
+      - #{MUST_SUPPORT_METADATA.must_support_strings.join("\n      - ")}
+    )
+    simulation_verification
+
+    def target_tags
+      [CLIENT_QUESTIONNAIRE_MUST_SUPPORT, CLIENT_NEXT_TAG]
+    end
+
+    run do
+      requests = load_tagged_requests(*target_tags)
+      skip_if requests.blank?, 'Requests must be made prior to running this test.'
+
+      questionnaires = questionnaires_from_operation_responses(requests, include_standard: false)
+      skip_if questionnaires.blank?, 'No adaptive Questionnaires found to evaluate.'
+
+      assert_must_support_elements_present(questionnaires, MUST_SUPPORT_METADATA.profile_url,
+                                           metadata: MUST_SUPPORT_METADATA)
+    end
+  end
+end

data/lib/davinci_dtr_test_kit/full_ehr/v2.2.0/must_support/dtr_questionnaire_base_must_support_test.rb

@@ -0,0 +1,43 @@
+require_relative '../../../tags'
+require_relative '../../../cross_suite/v2.2.0/questionnaire_helper'
+require_relative '../../../cross_suite/generated_profile_metadata'
+
+module DaVinciDTRTestKit
+  class DTRFullEHRV220QuestionnaireBaseMustSupportTest < Inferno::Test
+    include QuestionnaireHelper
+
+    MUST_SUPPORT_METADATA = GeneratedProfileMetadata.for('v2.2.0', 'dtr_base_questionnaire')
+
+    id :dtr_full_ehr_v220_questionnaire_base_must_support
+    title 'Client supports base Questionnaire must support elements and extensions'
+    description %(
+      This test confirms that all must support elements and extensions defined on the
+      [DTR Base Questionnaire](https://hl7.org/fhir/us/davinci-dtr/2.2.0/en/StructureDefinition-dtr-base-questionnaire.html)
+      profile and its parents have been observed across all completed Questionnaires during
+      previous tests. Note that Questionnaires from test scenarios where the Questionnaire
+      was not completed, e.g., due to errors within referenced CQL, are not included in this
+      analysis. During execution of those previous tests, testers attested to the correct
+      display of, interaction with, and population of the Questionnaires as controlled by
+      the elements aand extensions present in those Questionnaires.
+
+      This includes the following elements:
+      - #{MUST_SUPPORT_METADATA.must_support_strings.join("\n      - ")}
+    )
+    simulation_verification
+
+    def target_tags
+      [CLIENT_QUESTIONNAIRE_MUST_SUPPORT]
+    end
+
+    run do
+      requests = load_tagged_requests(*target_tags)
+      skip_if requests.blank?, 'Requests must be made prior to running this test'
+
+      questionnaires = questionnaires_from_operation_responses(requests)
+      skip_if questionnaires.blank?, 'No Questionnaires found to evaluate in operation responses.'
+
+      assert_must_support_elements_present(questionnaires.compact, MUST_SUPPORT_METADATA.profile_url,
+                                           metadata: MUST_SUPPORT_METADATA)
+    end
+  end
+end

data/lib/davinci_dtr_test_kit/full_ehr/v2.2.0/must_support/dtr_questionnaire_standard_must_support_test.rb

@@ -0,0 +1,45 @@
+require_relative '../../../tags'
+require_relative '../../../cross_suite/v2.2.0/questionnaire_helper'
+require_relative '../../../cross_suite/generated_profile_metadata'
+
+module DaVinciDTRTestKit
+  class DTRFullEHRV220QuestionnaireStandardMustSupportTest < Inferno::Test
+    include QuestionnaireHelper
+
+    MUST_SUPPORT_METADATA = GeneratedProfileMetadata.for('v2.2.0', 'dtr_std_questionnaire')
+
+    id :dtr_full_ehr_v220_questionnaire_standard_must_support
+    title 'Client supports standard Questionnaire must support elements and extensions'
+    description %(
+      This test confirms that all must support elements added in the
+      [DTR Standard Questionnaire](https://hl7.org/fhir/us/davinci-dtr/2.2.0/en/StructureDefinition-dtr-std-questionnaire.html)
+      ave been observed across all completed standard Questionnaires during previous tests.
+      This does not include must support elements flagged within the
+      [DTR Base Questionnaire](https://hl7.org/fhir/us/davinci-dtr/2.2.0/en/StructureDefinition-dtr-base-questionnaire.html)
+      profile. Note that standard Questionnaires from test scenarios where the Questionnaire
+      was not completed, e.g., due to errors within referenced CQL, are not included in this
+      analysis. During execution of those previous tests, testers attested to the correct
+      display of, interaction with, and population of the Questionnaires as controlled by
+      the elements aand extensions present in those Questionnaires.
+
+      This includes the following elements:
+      - #{MUST_SUPPORT_METADATA.must_support_strings.join("\n      - ")}
+    )
+    simulation_verification
+
+    def target_tags
+      [CLIENT_QUESTIONNAIRE_MUST_SUPPORT, QUESTIONNAIRE_PACKAGE_TAG]
+    end
+
+    run do
+      requests = load_tagged_requests(*target_tags)
+      skip_if requests.blank?, 'Requests must be made prior to running this test.'
+
+      questionnaires = questionnaires_from_operation_responses(requests, include_adaptive: false)
+      skip_if questionnaires.blank?, 'No standard Questionnaires found to evaluate.'
+
+      assert_must_support_elements_present(questionnaires, MUST_SUPPORT_METADATA.profile_url,
+                                           metadata: MUST_SUPPORT_METADATA)
+    end
+  end
+end

data/lib/davinci_dtr_test_kit/full_ehr/v2.2.0/next_question_template_questionnaires.rb

@@ -0,0 +1,21 @@
+module DaVinciDTRTestKit
+  # Shared by the $next-question mock endpoint and the interaction wait test so that both agree
+  # on what counts as a usable $next-question response template: a single Questionnaire or a
+  # JSON array of Questionnaires. Entries that do not parse to a FHIR Questionnaire are silently
+  # discarded rather than treated as an error, since a template array may intentionally carry
+  # entries meant for other questionnaires in the workflow.
+  module NextQuestionTemplateQuestionnaires
+    def questionnaires_from_template_value(value)
+      parsed_json = JSON.parse(value)
+      questionnaire_jsons = parsed_json.is_a?(Array) ? parsed_json : [parsed_json]
+      questionnaire_jsons.filter_map { |questionnaire_json| parse_template_questionnaire(questionnaire_json) }
+    end
+
+    def parse_template_questionnaire(questionnaire_json)
+      parsed = FHIR.from_contents(questionnaire_json.to_json)
+      parsed if parsed.is_a?(FHIR::Questionnaire)
+    rescue StandardError
+      nil
+    end
+  end
+end