davinci_dtr_test_kit 0.17.0 → 0.18.0

data/lib/davinci_dtr_test_kit/server/v2.2.0/dtr_payer_server_suite_description_v220.md

@@ -0,0 +1,37 @@
+The Da Vinci DTR Test Kit Payer Server Suite validates the conformance of payer
+server systems to the STU 2.2.0 version of the HL7® FHIR® [Da Vinci
+Documentation Templates and Rules (DTR) Implementation
+Guide](https://hl7.org/fhir/us/davinci-dtr/2.2.0/).
+
+These tests are a **DRAFT** intended to allow payer implementers to perform
+preliminary checks of their systems against DTR IG requirements and [provide
+feedback](https://github.com/inferno-framework/davinci-dtr-test-kit/issues)
+on the tests. Future versions of these tests may validate other
+requirements and may change the test validation logic.
+
+The best place to get started is the [Server Testing
+Instructions](https://github.com/inferno-framework/davinci-dtr-test-kit/wiki/Server-Instructions-v2.2.0),
+which provides a step-by-step guide for running the tests. Visit the [Server
+Testing
+Details](https://github.com/inferno-framework/davinci-dtr-test-kit/wiki/Server-Details)
+documentation for information about technical implementation and known
+limitations of these tests.
+
+Inferno will simulate a DTR client and make a series of requests to the system
+under test. Because the business logic that determines Questionnaire design and
+which Questionnaires will be returned is outside of the scope of the DTR
+specification and will vary between implementers, testers are required to
+provide the requests that Inferno will make to the server. These requests must
+cause the server to return Questionnaires which demonstrate support for DTR
+requirements, including
+- Advertising support for DTR operations in the CapabilityStatement
+- Support for SMART backend services authorization
+- Responding to the `$questionnaire-package`, `$next-question` (optional),
+  `ValueSet/$expand`, and `$log-questionnaire-errors` operations
+- Populating all Must Support elements in the responses
+- Correctly handling errors
+
+All requests and responses will be checked for conformance to the DTR IG
+requirements individually and used in aggregate to determine whether required
+features and functionality are present. HL7® FHIR® resources are validated with
+the Java validator using tx.fhir.org as the terminology server.

data/lib/davinci_dtr_test_kit/server/v2.2.0/interaction_test.rb

@@ -0,0 +1,97 @@
+require_relative 'client_simulation'
+
+module DaVinciDTRTestKit
+  module DTRPayerServerV220
+    class InteractionTest < Inferno::Test
+      include ClientSimulation
+
+      id :dtr_v220_payer_interaction
+      title 'Request Questionnaires'
+      description %(
+        During this test, Inferno will simulate a DTR Client and make requests against
+        the payer endpoint to retrieve and complete questionnaires, including
+        - the `Questionnaire/$questionnaire-package` operation
+        - the `Questionnaire/$next-question` operation
+        - the `ValueSet/$expand` operation
+
+        The tester will provide the details of the requests for Inferno to use, including
+        - A list of `$questionnaire-package` request parameters: Inferno will invoke the
+          `$questionnaire-package` once per provided request body. Inferno will look
+          for the following entries withing package bundles for follow-up requests:
+          - Unexpanded ValueSets: Inferno will issue a `ValueSet/$expand` request for each.
+          - Adaptive Questionnaires: Inferno will attempt to complete the form using the
+            `Questionnaire/$next-question` operation using answers from tester-provided
+            QuestionnaireResponse templates.
+        - A list of QuestionnaireResponse templates: When an adaptive form is returned in
+          a `$questionnaire-package` response, Inferno will find a matching template from
+          this list based on the Questionnaire and use the answers to construct a sequence
+          of `$next-question` calls.
+
+        Requests made during this test are tagged for analysis in subsequent tests.
+      )
+
+      input :url,
+            title: 'Payer FHIR Server Base Url',
+            description: 'Base FHIR URL implementing the DTR server operations.'
+      input :questionnaire_package_request_parameters,
+            title: '$questionnaire-package Request Parameters',
+            description: %(
+              Tester-provided list of one or more $questionnaire-package requests each
+              as a Parameters resource in json format. Inferno will call the
+              `Questionnaire/$questionnaire-package` operation once for each
+              with the request as the body of the invocation.
+            ),
+            type: 'textarea'
+      input :questionnaire_response_templates,
+            title: 'QuestionnaireResponse Templates for $next-question requests',
+            description: %(
+              Tester-provided list of one or more QuestionnaireResponse resources in json format
+              that Inferno will use to populate answers for adaptive forms for the purpose
+              of building `Questionnaire/$next-question` requests to complete these forms.
+              If not provided, no `$next-question` requests will be performed.
+            ),
+            type: 'textarea',
+            optional: true
+      input :backend_services_smart_auth_info
+
+      run do
+        parameters = extract_fhir_parameters(questionnaire_package_request_parameters)
+        templates = extract_fhir_questionnaire_response_templates(questionnaire_response_templates)
+        parameters.each { |parameter| questionnaire_interaction(url, parameter, templates) }
+      end
+
+      def extract_fhir_parameters(questionnaire_package_request_parameters)
+        parameters_list = Array.wrap(parsed_json_if_valid(questionnaire_package_request_parameters,
+                                                          'Provided well-formed $questionnaire-package bodies.',
+                                                          continue: false))
+        parameters_list.map.with_index do |entry, index|
+          if entry['resourceType'] == 'Parameters'
+            FHIR::Parameters.new(entry)
+          else
+            add_message('warning', "skipping **$questionnaire-package Parameters** input entry #{index + 1}: " \
+                                   'not a FHIR Parameters resource')
+            nil
+          end
+        end.compact
+      end
+
+      def extract_fhir_questionnaire_response_templates(questionnaire_response_templates)
+        return nil unless questionnaire_response_templates.present?
+
+        questionnaire_response_list =
+          Array.wrap(parsed_json_if_valid(questionnaire_response_templates,
+                                          'Provided well-formed QuestionnaireResponse templates.',
+                                          continue: false))
+        questionnaire_response_list.map.with_index do |entry, index|
+          if entry['resourceType'] == 'QuestionnaireResponse'
+            FHIR::QuestionnaireResponse.new(entry)
+          else
+            add_message('warning', 'skipping **QuestionnaireResponse Templates for $next-question requests** ' \
+                                   "input entry #{index + 1}: not a FHIR QuestionnaireResponse resource")
+            nil
+          end
+        end.compact
+      end
+    end
+  end
+end

data/lib/davinci_dtr_test_kit/server/v2.2.0/log_questionnaire_errors_support_test.rb

@@ -0,0 +1,57 @@
+module DaVinciDTRTestKit
+  module DTRPayerServerV220
+    class LogQuestionnaireErrorsSupportTest < Inferno::Test
+      id :dtr_v220_payer_log_questionnaire_errors_support
+      title 'Verify $log-questionnaire-errors operation support'
+      description %(
+        This test verifies that the payer supports the
+        [`Questionnaire/$log-questionnaire-errors` operation](https://hl7.org/fhir/us/davinci-dtr/2.2.0/en/OperationDefinition-log-questionnaire-errors.html).
+
+        Inferno submits a representative, non-PHI error report containing a
+        Questionnaire canonical and an OperationOutcome. The payer must respond
+        with a successful HTTP response.
+      )
+      verifies_requirements 'hl7.fhir.us.davinci-dtr_2.2.0@oper-1'
+
+      input :url
+      input :questionnaire_canonical,
+            title: 'Questionnaire Canonical URL',
+            description: 'Canonical URL of a Questionnaire supported by the payer.'
+
+      def log_questionnaire_errors_parameters
+        FHIR::Parameters.new(
+          parameter: [
+            FHIR::Parameters::Parameter.new(
+              name: 'questionnaire',
+              valueCanonical: questionnaire_canonical
+            ),
+            FHIR::Parameters::Parameter.new(
+              name: 'operationOutcome',
+              resource: FHIR::OperationOutcome.new(
+                issue: [
+                  FHIR::OperationOutcome::Issue.new(
+                    severity: 'error',
+                    code: 'processing',
+                    diagnostics: 'Unable to evaluate a Questionnaire expression.'
+                  )
+                ]
+              )
+            )
+          ]
+        )
+      end
+
+      run do
+        fhir_operation(
+          "#{url.chomp('/')}/Questionnaire/$log-questionnaire-errors",
+          body: log_questionnaire_errors_parameters,
+          headers: { 'Content-Type': 'application/fhir+json' }
+        )
+
+        status = request.status.to_s
+        assert status.start_with?('2'),
+               "Expected a successful 2xx response to $log-questionnaire-errors, but received HTTP #{status}."
+      end
+    end
+  end
+end

data/lib/davinci_dtr_test_kit/server/v2.2.0/must_support/questionnaire_adaptive_must_support_test.rb

@@ -0,0 +1,47 @@
+require_relative '../../../cross_suite/generated_profile_metadata'
+require_relative '../../../cross_suite/v2.2.0/questionnaire_helper'
+require_relative '../../../tags'
+
+module DaVinciDTRTestKit
+  module DTRPayerServerV220
+    class QuestionnaireAdaptiveMustSupportTest < Inferno::Test
+      include QuestionnaireHelper
+
+      MUST_SUPPORT_METADATA = GeneratedProfileMetadata.for('v2.2.0', 'dtr_questionnaire_adapt')
+
+      id :dtr_v220_payer_questionnaire_adaptive_must_support
+      title 'Server provides 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)
+        profile have been observed cumulatively across adaptive Questionnaires returned
+        during previous `$next-question` tests. Common inherited Questionnaire elements
+        are evaluated separately.
+
+        This includes the following elements:
+        - #{MUST_SUPPORT_METADATA.must_support_strings.join("\n        - ")}
+      )
+      verifies_requirements 'hl7.fhir.us.davinci-dtr_2.2.0@conf-2'
+
+      run do
+        load_tagged_requests(NEXT_TAG)
+        questionnaires = questionnaires_from_operation_responses(requests)
+
+        if questionnaires.blank?
+          load_tagged_requests(QUESTIONNAIRE_TAG)
+          questionnaire_package_questionnaires = questionnaires_from_operation_responses(requests)
+          adaptive_search_questionnaires = questionnaire_package_questionnaires.select do |questionnaire|
+            adaptive_questionnaire?(questionnaire)
+          end
+          omit_if questionnaire_package_questionnaires.present? && adaptive_search_questionnaires.blank?,
+                  'The server did not return any adaptive-search Questionnaires.'
+
+          skip 'No adaptive Questionnaires were found in $next-question responses.'
+        end
+
+        assert_must_support_elements_present(questionnaires, MUST_SUPPORT_METADATA.profile_url,
+                                             metadata: MUST_SUPPORT_METADATA)
+      end
+    end
+  end
+end

data/lib/davinci_dtr_test_kit/server/v2.2.0/must_support/questionnaire_adaptive_search_must_support_test.rb

@@ -0,0 +1,40 @@
+require_relative '../../../cross_suite/generated_profile_metadata'
+require_relative '../../../cross_suite/v2.2.0/questionnaire_helper'
+require_relative '../../../tags'
+
+module DaVinciDTRTestKit
+  module DTRPayerServerV220
+    class QuestionnaireAdaptiveSearchMustSupportTest < Inferno::Test
+      include QuestionnaireHelper
+
+      MUST_SUPPORT_METADATA = GeneratedProfileMetadata.for('v2.2.0', 'dtr_questionnaire_adapt_search')
+
+      id :dtr_v220_payer_questionnaire_adaptive_search_must_support
+      title 'Server provides adaptive-search Questionnaire must support elements and extensions'
+      description %(
+        This test confirms that all must support elements and extensions defined in the
+        [DTR Adaptive Questionnaire Search](https://hl7.org/fhir/us/davinci-dtr/2.2.0/en/StructureDefinition-dtr-questionnaire-adapt-search.html)
+        profile have been observed cumulatively across adaptive-search Questionnaires
+        returned during previous `$questionnaire-package` tests.
+
+        This includes the following elements:
+        - #{MUST_SUPPORT_METADATA.must_support_strings.join("\n        - ")}
+      )
+      verifies_requirements 'hl7.fhir.us.davinci-dtr_2.2.0@conf-2'
+
+      run do
+        load_tagged_requests(QUESTIONNAIRE_TAG)
+        questionnaires = questionnaires_from_operation_responses(requests)
+        skip_if questionnaires.blank?, 'No Questionnaires were found in $questionnaire-package responses.'
+
+        adaptive_search_questionnaires = questionnaires.select do |questionnaire|
+          adaptive_questionnaire?(questionnaire)
+        end
+        omit_if adaptive_search_questionnaires.blank?, 'The server did not return any adaptive-search Questionnaires.'
+
+        assert_must_support_elements_present(adaptive_search_questionnaires, MUST_SUPPORT_METADATA.profile_url,
+                                             metadata: MUST_SUPPORT_METADATA)
+      end
+    end
+  end
+end

data/lib/davinci_dtr_test_kit/server/v2.2.0/must_support/questionnaire_base_must_support_test.rb

@@ -0,0 +1,40 @@
+require_relative '../../../cross_suite/generated_profile_metadata'
+require_relative '../../../cross_suite/v2.2.0/questionnaire_helper'
+
+module DaVinciDTRTestKit
+  module DTRPayerServerV220
+    class QuestionnaireBaseMustSupportTest < Inferno::Test
+      include QuestionnaireHelper
+
+      MUST_SUPPORT_METADATA = GeneratedProfileMetadata.for('v2.2.0', 'dtr_base_questionnaire')
+
+      id :dtr_v220_payer_questionnaire_base_must_support
+      title 'Server provides common DTR Questionnaire must support elements and extensions'
+      description %(
+        This test confirms that all must support elements and extensions defined in 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 cumulatively across standard
+        and adaptive Questionnaires returned during previous tests.
+
+        This includes the following elements:
+        - #{MUST_SUPPORT_METADATA.must_support_strings.join("\n        - ")}
+      )
+      verifies_requirements 'hl7.fhir.us.davinci-dtr_2.2.0@conf-2'
+
+      run do
+        questionnaire_package_requests = load_tagged_requests(QUESTIONNAIRE_TAG)
+        next_question_requests = load_tagged_requests(NEXT_TAG)
+        skip_if requests.blank?, 'Requests must be made prior to running this test.'
+
+        questionnaires = questionnaires_from_operation_responses(
+          questionnaire_package_requests,
+          include_adaptive: false
+        ) + questionnaires_from_operation_responses(next_question_requests)
+        skip_if questionnaires.blank?, 'No standard or adaptive Questionnaires were found to evaluate.'
+
+        assert_must_support_elements_present(questionnaires, MUST_SUPPORT_METADATA.profile_url,
+                                             metadata: MUST_SUPPORT_METADATA)
+      end
+    end
+  end
+end

data/lib/davinci_dtr_test_kit/server/v2.2.0/must_support/questionnaire_package_bundle_must_support_test.rb

@@ -0,0 +1,38 @@
+require_relative '../../../cross_suite/generated_profile_metadata'
+require_relative '../../../cross_suite/v2.2.0/questionnaire_helper'
+require_relative '../../../tags'
+
+module DaVinciDTRTestKit
+  module DTRPayerServerV220
+    class QuestionnairePackageBundleMustSupportTest < Inferno::Test
+      include QuestionnaireHelper
+
+      MUST_SUPPORT_METADATA = GeneratedProfileMetadata.for('v2.2.0', 'dtr_q_package_bundle')
+
+      id :dtr_v220_payer_questionnaire_package_bundle_must_support
+      title 'Server provides Questionnaire Package Bundle must support elements'
+      description %(
+        This test confirms that all must support entries defined in the
+        [DTR Questionnaire Package Bundle](https://hl7.org/fhir/us/davinci-dtr/2.2.0/en/StructureDefinition-DTR-QPackageBundle.html)
+        profile have been observed cumulatively across package Bundles returned during
+        previous `$questionnaire-package` tests.
+
+        This includes the following elements:
+        - #{MUST_SUPPORT_METADATA.must_support_strings.join("\n        - ")}
+      )
+      verifies_requirements 'hl7.fhir.us.davinci-dtr_2.2.0@conf-2'
+
+      run do
+        load_tagged_requests(QUESTIONNAIRE_TAG)
+        skip_if requests.blank?, 'Requests must be made prior to running this test.'
+
+        bundles = questionnaire_package_output_parameters_from_operation_responses(requests)
+          .flat_map { |parameters| questionnaire_package_bundles(parameters) }
+        skip_if bundles.blank?, 'No Questionnaire Package Bundle resources were found to evaluate.'
+
+        assert_must_support_elements_present(bundles, MUST_SUPPORT_METADATA.profile_url,
+                                             metadata: MUST_SUPPORT_METADATA)
+      end
+    end
+  end
+end

data/lib/davinci_dtr_test_kit/server/v2.2.0/must_support/questionnaire_package_output_parameters_must_support_test.rb

@@ -0,0 +1,37 @@
+require_relative '../../../cross_suite/generated_profile_metadata'
+require_relative '../../../cross_suite/v2.2.0/questionnaire_helper'
+require_relative '../../../tags'
+
+module DaVinciDTRTestKit
+  module DTRPayerServerV220
+    class QuestionnairePackageOutputParametersMustSupportTest < Inferno::Test
+      include QuestionnaireHelper
+
+      MUST_SUPPORT_METADATA = GeneratedProfileMetadata.for('v2.2.0', 'dtr_qpackage_output_parameters')
+
+      id :dtr_v220_payer_questionnaire_package_output_parameters_must_support
+      title 'Server provides Questionnaire Package Output Parameters must support elements'
+      description %(
+        This test confirms that all must support elements defined in the
+        [DTR Questionnaire Package Output Parameters](https://hl7.org/fhir/us/davinci-dtr/2.2.0/en/StructureDefinition-dtr-qpackage-output-parameters.html)
+        profile have been observed cumulatively across `$questionnaire-package` responses
+        returned during previous tests.
+
+        This includes the following elements:
+        - #{MUST_SUPPORT_METADATA.must_support_strings.join("\n        - ")}
+      )
+      verifies_requirements 'hl7.fhir.us.davinci-dtr_2.2.0@conf-2'
+
+      run do
+        load_tagged_requests(QUESTIONNAIRE_TAG)
+        skip_if requests.blank?, 'Requests must be made prior to running this test.'
+
+        parameters = questionnaire_package_output_parameters_from_operation_responses(requests)
+        skip_if parameters.blank?, 'No Questionnaire Package Output Parameters resources were found to evaluate.'
+
+        assert_must_support_elements_present(parameters, MUST_SUPPORT_METADATA.profile_url,
+                                             metadata: MUST_SUPPORT_METADATA)
+      end
+    end
+  end
+end

data/lib/davinci_dtr_test_kit/server/v2.2.0/must_support/questionnaire_standard_must_support_test.rb

@@ -0,0 +1,39 @@
+require_relative '../../../cross_suite/generated_profile_metadata'
+require_relative '../../../cross_suite/v2.2.0/questionnaire_helper'
+require_relative '../../../tags'
+
+module DaVinciDTRTestKit
+  module DTRPayerServerV220
+    class QuestionnaireStandardMustSupportTest < Inferno::Test
+      include QuestionnaireHelper
+
+      MUST_SUPPORT_METADATA = GeneratedProfileMetadata.for('v2.2.0', 'dtr_std_questionnaire')
+
+      id :dtr_v220_payer_questionnaire_standard_must_support
+      title 'Server provides 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)
+        profile have been observed cumulatively across standard Questionnaires returned
+        during previous `$questionnaire-package` tests. Common inherited Questionnaire
+        elements are evaluated separately.
+
+        This includes the following elements:
+        - #{MUST_SUPPORT_METADATA.must_support_strings.join("\n        - ")}
+      )
+      verifies_requirements 'hl7.fhir.us.davinci-dtr_2.2.0@conf-2'
+
+      run do
+        load_tagged_requests(QUESTIONNAIRE_TAG)
+        questionnaires = questionnaires_from_operation_responses(requests)
+        skip_if questionnaires.blank?, 'No Questionnaires were found in $questionnaire-package responses.'
+
+        standard_questionnaires = questionnaires.reject { |questionnaire| adaptive_questionnaire?(questionnaire) }
+        omit_if standard_questionnaires.blank?, 'The server did not return any standard Questionnaires.'
+
+        assert_must_support_elements_present(standard_questionnaires, MUST_SUPPORT_METADATA.profile_url,
+                                             metadata: MUST_SUPPORT_METADATA)
+      end
+    end
+  end
+end

data/lib/davinci_dtr_test_kit/server/v2.2.0/next_question_request_validation_test.rb

@@ -0,0 +1,45 @@
+require_relative '../validation_test'
+require_relative '../../tags'
+
+module DaVinciDTRTestKit
+  module DTRPayerServerV220
+    class NextQuestionRequestValidationTest < Inferno::Test
+      include DaVinciDTRTestKit::ValidationTest
+
+      id :dtr_v220_payer_next_question_request_validation
+      title '$next-question QuestionnaireResponse request is valid'
+      description %(
+        This test validates that each outgoing QuestionnaireResponse request to the
+        `$next-question` operation
+        conforms to the [DTR Questionnaire Response for adaptive form profile](https://hl7.org/fhir/us/davinci-dtr/2.2.0/en/StructureDefinition-dtr-questionnaireresponse-adapt.html).
+        Inferno generates these request bodies from the provided test input.
+      )
+      simulation_verification
+
+      run do
+        load_tagged_requests(NEXT_TAG)
+
+        omit_if requests.empty?, 'No $next-question requests were made.'
+
+        requests.each_with_index do |request, index|
+          fhir_obj = begin
+            FHIR.from_contents(request.request_body)
+          rescue StandardError
+            nil
+          end
+
+          validate_resource(
+            fhir_obj,
+            :questionnaire_response,
+            'http://hl7.org/fhir/us/davinci-dtr/StructureDefinition/dtr-questionnaireresponse-adapt|2.2.0',
+            index
+          )
+        end
+
+        assert_no_error_messages(
+          'Non-conformant $next-question QuestionnaireResponse request. See Messages for details.'
+        )
+      end
+    end
+  end
+end

data/lib/davinci_dtr_test_kit/server/v2.2.0/next_question_support/adaptive_questionnaire_endpoint_test.rb

@@ -0,0 +1,98 @@
+# frozen_string_literal: true
+
+require_relative '../../../tags'
+require_relative '../questionnaire_operation_validation'
+
+module DaVinciDTRTestKit
+  module DTRPayerServerV220
+    class AdaptiveQuestionnaireEndpointTest < Inferno::Test
+      include QuestionnaireOperationValidation
+
+      ADAPTIVE_QUESTIONNAIRE_EXTENSION_URL =
+        'http://hl7.org/fhir/uv/sdc/StructureDefinition/sdc-questionnaire-questionnaireAdaptive'
+
+      id :dtr_v220_payer_adaptive_questionnaire_endpoint
+      title 'Adaptive Questionnaire endpoints are payer sub-URLs accessible with the configured credentials'
+      description %(
+        This test verifies that every URL provided by a `questionnaireAdaptive`
+        extension is a sub-URL of the payer FHIR base. It also verifies that the
+        DTR client's `$next-question` request to that endpoint succeeds. The
+        request is made by the same configured FHIR client used for the
+        `$questionnaire-package` operation.
+      )
+
+      verifies_requirements 'hl7.fhir.us.davinci-dtr_2.2.0@spec-24'
+
+      input :url
+
+      run do
+        questionnaire_requests = load_tagged_requests(QUESTIONNAIRE_TAG)
+        successful_questionnaire_requests = questionnaire_requests.select do |request|
+          request.status.to_s.start_with?('2')
+        end
+        skip_if successful_questionnaire_requests.blank?, 'No successful $questionnaire-package requests were made.'
+
+        adaptive_urls = successful_questionnaire_requests.flat_map do |request|
+          adaptive_questionnaire_urls(request)
+        end.uniq
+        omit_if adaptive_urls.blank?, 'No adaptive Questionnaire URLs were returned.'
+
+        next_question_requests = load_tagged_requests(NEXT_TAG)
+        adaptive_urls.each do |adaptive_url|
+          payer_base_url = url.chomp('/')
+          unless adaptive_url.chomp('/') == payer_base_url || adaptive_url.start_with?("#{payer_base_url}/")
+            add_message(
+              'error',
+              "`questionnaireAdaptive` extension URL `#{adaptive_url}` is not a sub-URL of payer base `#{url}`."
+            )
+            next
+          end
+
+          expected_next_question_url = "#{adaptive_url.chomp('/')}/Questionnaire/$next-question"
+          matching_request = next_question_requests.find { |request| request.url == expected_next_question_url }
+
+          if matching_request.nil?
+            add_message(
+              'error',
+              "No $next-question request was made to `questionnaireAdaptive` extension URL `#{adaptive_url}`."
+            )
+          elsif !matching_request.status.to_s.start_with?('2')
+            add_message(
+              'error',
+              "$next-question request to `questionnaireAdaptive` extension URL `#{adaptive_url}` did not succeed " \
+              "(received HTTP #{matching_request.status})."
+            )
+          end
+        end
+
+        assert_no_error_messages(
+          '`questionnaireAdaptive` extension URLs must be payer sub-URLs and accessible with ' \
+          'the configured credentials.'
+        )
+      end
+
+      private
+
+      def adaptive_questionnaire_urls(request)
+        resource = FHIR.from_contents(request.response_body)
+        extract_questionnaire_bundles(resource).flat_map do |bundle|
+          adaptive_questionnaire_urls_from_bundle(bundle)
+        end
+      rescue JSON::ParserError, NoMethodError
+        []
+      end
+
+      def adaptive_questionnaire_urls_from_bundle(bundle)
+        extract_questionnaires_from_bundles([bundle]).filter_map do |questionnaire|
+          adaptive_questionnaire_url(questionnaire)
+        end
+      end
+
+      def adaptive_questionnaire_url(questionnaire)
+        questionnaire.extension&.find do |extension|
+          extension.url == ADAPTIVE_QUESTIONNAIRE_EXTENSION_URL && extension.valueUrl.present?
+        end&.valueUrl
+      end
+    end
+  end
+end

data/lib/davinci_dtr_test_kit/server/v2.2.0/next_question_support/invalid_questionnaire_response_test.rb

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+module DaVinciDTRTestKit
+  module DTRPayerServerV220
+    class InvalidQuestionnaireResponseTest < Inferno::Test
+      id :dtr_v220_payer_invalid_questionnaire_response
+      title 'Invalid QuestionnaireResponses return 400 with an OperationOutcome'
+      description %(
+        Inferno invokes `Questionnaire/$next-question` using a tester-provided
+        QuestionnaireResponse that the DTR server considers invalid based on the
+        rules in its contained Questionnaire. Inferno verifies that the server
+        returns HTTP 400 with an OperationOutcome describing the error.
+      )
+      verifies_requirements 'hl7.fhir.us.davinci-dtr_2.2.0@spec-147'
+
+      input :invalid_questionnaire_response,
+            title: 'Invalid QuestionnaireResponse',
+            description: %(
+              Provide a `QuestionnaireResponse` resource in JSON format that the DTR
+              server will determine is invalid based on the rules in its contained
+              Questionnaire.
+            ),
+            type: 'textarea'
+
+      run do
+        assert_valid_json invalid_questionnaire_response, 'The provided QuestionnaireResponse is not valid JSON.'
+        questionnaire_response = FHIR.from_contents(invalid_questionnaire_response)
+        assert_resource_type(:questionnaire_response, resource: questionnaire_response)
+
+        fhir_operation(
+          '/Questionnaire/$next-question',
+          body: questionnaire_response,
+          headers: { 'Content-Type': 'application/fhir+json' }
+        )
+
+        assert_response_status(400)
+        assert_resource_type(:operation_outcome)
+        assert resource.issue.present?,
+               'The OperationOutcome did not include an issue describing why the QuestionnaireResponse was invalid.'
+      end
+    end
+  end
+end