davinci_dtr_test_kit 0.11.1 → 0.13.0

data/lib/davinci_dtr_test_kit/mock_auth_server.rb

@@ -1,16 +1,37 @@
+# frozen_string_literal: true
+
 require_relative 'urls'
-require_relative 'fixtures'
 
 module DaVinciDTRTestKit
   module MockAuthServer
-    include Fixtures
+    AUTHORIZED_PRACTITIONER_ID = 'pra1234' # Must exist on the FHIR_REFERENCE_SERVER (env var)
+
+    RSA_PRIVATE_KEY = OpenSSL::PKey::RSA.generate(2048)
+    RSA_PUBLIC_KEY = RSA_PRIVATE_KEY.public_key
+    SUPPORTED_SCOPES = ['launch', 'patient/*.rs', 'user/*.rs', 'offline_access', 'openid', 'fhirUser'].freeze
+
+    def requests_repo
+      @requests_repo ||= Inferno::Repositories::Requests.new
+    end
+
+    def auth_server_jwks(_env)
+      response_body = {
+        keys: [
+          {
+            kty: 'RSA',
+            alg: 'RS256',
+            n: Base64.urlsafe_encode64(RSA_PUBLIC_KEY.n.to_s(2), padding: false),
+            e: Base64.urlsafe_encode64(RSA_PUBLIC_KEY.e.to_s(2), padding: false),
+            use: 'sig'
+          }
+        ]
+      }.to_json
+
+      [200, { 'Content-Type' => 'application/json', 'Access-Control-Allow-Origin' => '*' }, [response_body]]
+    end
 
     def ehr_smart_config(env)
-      protocol = env['rack.url_scheme']
-      host = env['HTTP_HOST']
-      path = env['REQUEST_PATH'] || env['PATH_INFO']
-      path.gsub!(%r{#{SMART_CONFIG_PATH}(/)?}, '')
-      base_url = "#{protocol}://#{host + path}"
+      base_url = env_base_url(env, SMART_CONFIG_PATH)
       response_body =
         {
           authorization_endpoint: base_url + EHR_AUTHORIZE_PATH,
@@ -18,7 +39,7 @@ module DaVinciDTRTestKit
           token_endpoint_auth_methods_supported: ['private_key_jwt'],
           token_endpoint_auth_signing_alg_values_supported: ['RS256'],
           grant_types_supported: ['authorization_code'],
-          scopes_supported: ['launch', 'patient/*.rs', 'user/*.rs', 'offline_access'],
+          scopes_supported: SUPPORTED_SCOPES,
           response_types_supported: ['code'],
           code_challenge_methods_supported: ['S256'],
           capabilities: [
@@ -34,9 +55,23 @@ module DaVinciDTRTestKit
       [200, { 'Content-Type' => 'application/json', 'Access-Control-Allow-Origin' => '*' }, [response_body]]
     end
 
+    def ehr_openid_config(env)
+      base_url = env_base_url(env, OPENID_CONFIG_PATH)
+      response_body = {
+        issuer: base_url + FHIR_BASE_PATH,
+        authorization_endpoint: base_url + EHR_AUTHORIZE_PATH,
+        token_endpoint: base_url + EHR_TOKEN_PATH,
+        jwks_uri: base_url + JKWS_PATH,
+        response_types_supported: ['id_token'],
+        subject_types_supported: ['public'],
+        id_token_signing_alg_values_supported: ['RS256']
+      }.to_json
+      [200, { 'Content-Type' => 'application/json', 'Access-Control-Allow-Origin' => '*' }, [response_body]]
+    end
+
     def ehr_authorize(request, _test = nil, _test_result = nil)
       # Authorization requests can bet GET or POST
-      params = request.verb == 'get' ? request.query_parameters : URI.decode_www_form(request.request_body)&.to_h
+      params = params_hash(request)
       if params['redirect_uri'].present?
         redirect_uri = "#{params['redirect_uri']}?" \
                        "code=#{SecureRandom.hex}&" \
@@ -57,25 +92,34 @@ module DaVinciDTRTestKit
 
     def ehr_token_response(request, _test = nil, test_result = nil)
       client_id = extract_client_id_from_token_request(request)
-      token = JWT.encode({ inferno_client_id: client_id }, nil, 'none')
-      response = { access_token: token, token_type: 'bearer', expires_in: 3600 }
-      test_input = JSON.parse(test_result.input_json)
+      access_token = JWT.encode({ inferno_client_id: client_id }, nil, 'none')
+      granted_scopes = SUPPORTED_SCOPES & requested_scopes(test_result.test_session_id)
 
-      fhir_context_input = test_input.find { |input| input['name'] == 'smart_fhir_context' }
-      fhir_context_input_value = fhir_context_input['value'] if fhir_context_input.present?
+      response = { access_token:, scope: granted_scopes.join(' '), token_type: 'bearer', expires_in: 3600 }
+
+      if granted_scopes.include?('openid')
+        response.merge!(id_token: create_id_token(request, client_id, fhir_user: granted_scopes.include?('fhirUser')))
+      end
+
+      fhir_context_input = find_test_input(test_result, 'smart_fhir_context')
+      fhir_context_input_value = fhir_context_input['value'] if fhir_context_input
       begin
         fhir_context = JSON.parse(fhir_context_input_value)
       rescue StandardError
         fhir_context = nil
       end
-      response.merge!({ fhirContext: fhir_context }) if fhir_context
+      response.merge!(fhirContext: fhir_context) if fhir_context
 
-      smart_patient_input = test_input.find { |input| input['name'] == 'smart_patient_id' }
+      smart_patient_input = find_test_input(test_result, 'smart_patient_id')
       smart_patient_input_value = smart_patient_input['value'] if smart_patient_input.present?
-      response.merge!({ patient: smart_patient_input_value }) if smart_patient_input_value
+      response.merge!(patient: smart_patient_input_value) if smart_patient_input_value
 
       request.response_body = response.to_json
-      request.response_headers = { 'Access-Control-Allow-Origin' => '*' }
+      request.response_headers = {
+        'Cache-Control' => 'no-store',
+        'Pragma' => 'no-cache',
+        'Access-Control-Allow-Origin' => '*'
+      }
       request.status = 200
     end
 
@@ -141,5 +185,44 @@ module DaVinciDTRTestKit
     def extract_token_from_query_params(request)
       request.query_parameters['token']
     end
+
+    def create_id_token(request, client_id, fhir_user: false)
+      # No point in mocking an identity provider, just always use known Practitioner as the authorized user
+      suite_base_url = request.url.split(EHR_TOKEN_PATH).first
+      id_token_hash = {
+        iss: suite_base_url + FHIR_BASE_PATH,
+        sub: AUTHORIZED_PRACTITIONER_ID,
+        aud: client_id,
+        exp: Time.now.to_i + (24 * 60 * 60), # 24 hrs
+        iat: Time.now.to_i
+      }
+      id_token_hash.merge!(fhirUser: "#{suite_base_url}/fhir/Practitioner/#{AUTHORIZED_PRACTITIONER_ID}") if fhir_user
+
+      JWT.encode(id_token_hash, RSA_PRIVATE_KEY, 'RS256')
+    end
+
+    def requested_scopes(test_session_id)
+      auth_request = requests_repo.tagged_requests(test_session_id, [EHR_AUTHORIZE_TAG]).last
+      return [] unless auth_request
+
+      scope_str = params_hash(auth_request)&.dig('scope')
+      scope_str ? URI.decode_www_form_component(scope_str).split : []
+    end
+
+    def find_test_input(test_result, input_name)
+      JSON.parse(test_result.input_json)&.find { |input| input['name'] == input_name }
+    end
+
+    def params_hash(request)
+      request.verb == 'get' ? request.query_parameters : URI.decode_www_form(request.request_body)&.to_h
+    end
+
+    def env_base_url(env, endpoint_path)
+      protocol = env['rack.url_scheme']
+      host = env['HTTP_HOST']
+      path = env['REQUEST_PATH'] || env['PATH_INFO']
+      path.gsub!(%r{#{endpoint_path}(/)?}, '')
+      "#{protocol}://#{host + path}"
+    end
   end
 end

data/lib/davinci_dtr_test_kit/mock_ehr.rb

@@ -27,16 +27,10 @@ module DaVinciDTRTestKit
     end
 
     def get_fhir_resource(request, _test = nil, test_result = nil)
-      resource_type, id = resource_type_and_id_from_url(request.url)
+      fhir_class, id = fhir_class_and_id_from_url(request.url)
       request.response_headers = RESPONSE_HEADERS
 
-      begin
-        fhir_class = FHIR.const_get(resource_type)
-      rescue NameError
-        resource_type = nil
-      end
-
-      if resource_type.blank?
+      if fhir_class.nil?
         request.status = 400
         request.response_headers = { 'Content-Type': 'application/json' }
         request.response_body = FHIR::OperationOutcome.new(
@@ -49,18 +43,9 @@ module DaVinciDTRTestKit
       end
 
       # Respond with user-inputted resource if there is one that matches the request
-      begin
-        ehr_bundle_input = JSON.parse(test_result.input_json).find { |input| input['name'] == 'ehr_bundle' }
-        ehr_bundle_input_value = ehr_bundle_input_value = ehr_bundle_input['value'] if ehr_bundle_input.present?
-        ehr_bundle = FHIR.from_contents(ehr_bundle_input_value) if ehr_bundle_input_value.present?
-      rescue StandardError
-        ehr_bundle = nil
-      end
-
-      if id.present? && ehr_bundle.present? && ehr_bundle.is_a?(FHIR::Bundle)
-        matching_resource = ehr_bundle.entry&.find do |entry|
-          entry.resource.is_a?(fhir_class) && entry.resource&.id == id
-        end&.resource
+      ehr_bundle = ehr_input_bundle(test_result)
+      if id.present? && ehr_bundle.present?
+        matching_resource = find_resource_in_bundle(ehr_bundle, fhir_class, id)
         if matching_resource.present?
           request.status = 200
           request.response_headers = { 'Content-Type': 'application/json' }
@@ -85,13 +70,36 @@ module DaVinciDTRTestKit
       request.response_body = request.request_body
     end
 
-    # Pull resource type and ID from url
-    # e.g. http://example.org/fhir/Patient/123 -> ['Patient', '123']
+    def ehr_input_bundle(test_result)
+      ehr_bundle_input = JSON.parse(test_result.input_json).find { |input| input['name'] == 'ehr_bundle' }
+      ehr_bundle_input_value = ehr_bundle_input_value = ehr_bundle_input['value'] if ehr_bundle_input.present?
+      ehr_bundle = FHIR.from_contents(ehr_bundle_input_value) if ehr_bundle_input_value.present?
+      ehr_bundle if ehr_bundle.is_a?(FHIR::Bundle)
+    rescue StandardError
+      nil
+    end
+
+    def find_resource_in_bundle(bundle, fhir_class, id)
+      bundle.entry&.find do |entry|
+        entry.resource.is_a?(fhir_class) && entry.resource&.id == id
+      end&.resource
+    end
+
+    # Pull resource type class and ID from url
+    # e.g. http://example.org/fhir/Patient/123 -> [FHIR::Patient, '123']
     # @private
-    def resource_type_and_id_from_url(url)
+    def fhir_class_and_id_from_url(url)
       path = url.split('?').first.split('/fhir/').second
       path.sub!(%r{/$}, '')
-      path.split('/')
+      resource_type, id = path.split('/')
+
+      begin
+        fhir_class = FHIR.const_get(resource_type)
+      rescue NameError
+        fhir_class = nil
+      end
+
+      [fhir_class, id]
     end
   end
 end

data/lib/davinci_dtr_test_kit/mock_payer.rb

@@ -4,14 +4,12 @@ require_relative 'fixtures'
 
 module DaVinciDTRTestKit
   module MockPayer
-    include Fixtures
-
     RESPONSE_HEADERS = { 'Content-Type' => 'application/json', 'Access-Control-Allow-Origin' => '*' }.freeze
 
     def questionnaire_package_response(request, _test = nil, test_result = nil)
       request.status = 200
       request.response_headers = RESPONSE_HEADERS
-      request.response_body = build_package_questionnaire_response(request, test_result.test_id).to_json
+      request.response_body = build_questionnaire_package_response(request, test_result.test_id).to_json
     end
 
     def payer_questionnaire_response(request, _test = nil, test_result = nil)
@@ -45,79 +43,58 @@ module DaVinciDTRTestKit
       !test.config.options[:accepts_multiple_requests]
     end
 
-    def build_package_questionnaire_response(request, test_id)
-      test_questionnaire_canonical = find_questionnaire_canonical_for_test_id(test_id)
-      test_questionnaire_loaded = false
-
-      bundles = []
-      issues = []
-
-      # first try the parameters - load the questionnaire specified by the questionnaire parameter
-      input_parameters = FHIR.from_contents(request.request_body)
-      input_parameters.parameter.each do |one_parameter|
-        next unless one_parameter.name == 'questionnaire'
-        next unless one_parameter.valueCanonical
+    private
 
-        # don't load test questionnaire if it is also specified explicitly
-        test_questionnaire_loaded = true if one_parameter.valueCanonical == test_questionnaire_canonical
+    def build_questionnaire_package_response(request, test_id)
+      begin
+        input_parameters = FHIR.from_contents(request.request_body)
+      rescue StandardError
+        return operation_outcome('error', 'invalid', 'No valid input parameters')
+      end
 
-        add_questionnaire_canonical_to_response(one_parameter.valueCanonical, bundles, issues)
+      questionnaire_package = Fixtures.questionnaire_package_for_test(test_id)
+      unless questionnaire_package
+        return operation_outcome('error', 'business-rule', "No Questionnaire found for Inferno test #{test_id}")
       end
 
-      unless test_questionnaire_loaded
-        if test_questionnaire_canonical
-          add_questionnaire_canonical_to_response(test_questionnaire_canonical, bundles, issues)
-
-        elsif bundles.empty?
-          # no questionnaire for this test ...
-          operation_outcome_issue = FHIR::OperationOutcome::Issue.new
-          operation_outcome_issue.severity = 'error'
-          operation_outcome_issue.code = 'business-rule'
-          details = FHIR::CodeableConcept.new
-          details.text = "no questionnaire found for test #{test_id}"
-          operation_outcome_issue.details = details
-          issues << operation_outcome_issue
-        end
+      questionnaire_canonical = find_questionnaire_canonical(questionnaire_package)
+
+      other_questionnaire_params = input_parameters.parameter.filter do |param|
+        param.name == 'questionnaire' && param.valueCanonical != questionnaire_canonical
       end
 
-      build_package_questionnaire_response_from_lists(bundles, issues)
+      return questionnaire_package unless other_questionnaire_params.any?
+
+      FHIR::Parameters.new(
+        parameter: [
+          FHIR::Parameters::Parameter.new(
+            name: 'PackageBundle',
+            resource: questionnaire_package
+          ),
+          FHIR::Parameters::Parameter.new(
+            name: 'Outcome',
+            resource: FHIR::OperationOutcome.new(
+              issue: other_questionnaire_params.map do |param|
+                outcome_issue('warning', 'not-found', "Questionnaire #{param.valueCanonical} does not exist")
+              end
+            )
+          )
+        ]
+      )
     end
 
-    def add_questionnaire_canonical_to_response(questionnaire_canonical, bundles, issues)
-      questionnaire_bundle = get_questionnaire_packcage_for_canonical(questionnaire_canonical)
-
-      if questionnaire_bundle
-        bundles << questionnaire_bundle
-      else
-        operation_outcome_issue = FHIR::OperationOutcome::Issue.new
-        operation_outcome_issue.severity = 'warning'
-        operation_outcome_issue.code = 'value'
-        details = FHIR::CodeableConcept.new
-        details.text = "Questionnaire Canonical #{questionnaire_canonical} does not exist"
-        operation_outcome_issue.details = details
-        issues << operation_outcome_issue
-      end
+    def find_questionnaire_canonical(questionnaire_package)
+      questionnaire_package&.entry&.find { |e| e.resource.is_a?(FHIR::Questionnaire) }&.resource&.url
     end
 
-    def build_package_questionnaire_response_from_lists(bundles, issues)
-      response = FHIR::Parameters.new
-      bundles.each do |one_bundle|
-        return_param = FHIR::Parameters::Parameter.new
-        return_param.name = 'return'
-        return_param.resource = one_bundle
-        response.parameter << return_param
-      end
+    def operation_outcome(severity, code, text = nil)
+      FHIR::OperationOutcome.new(issue: outcome_issue(severity, code, text))
+    end
 
-      unless issues.empty?
-        outcome = FHIR::OperationOutcome.new
-        outcome.issue = issues
-        outcome_param = FHIR::Parameters::Parameter.new
-        outcome_param.name = 'outcome'
-        outcome_param.resource = outcome
-        response.parameter << outcome_param
+    def outcome_issue(severity, code, text = nil)
+      FHIR::OperationOutcome::Issue.new(severity:, code:).tap do |issue|
+        issue.details = FHIR::CodeableConcept.new(text:) if text.present?
       end
-
-      response
     end
   end
 end

data/lib/davinci_dtr_test_kit/payer_server_groups/adaptive_next_questionnaire_expressions_test.rb

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

data/lib/davinci_dtr_test_kit/payer_server_groups/payer_server_adaptive_request_validation_test.rb

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

data/lib/davinci_dtr_test_kit/payer_server_groups/payer_server_adaptive_response_bundles_validation_test.rb

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

data/lib/davinci_dtr_test_kit/payer_server_groups/payer_server_adaptive_response_search_validation_test.rb

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

data/lib/davinci_dtr_test_kit/payer_server_groups/payer_server_adaptive_response_validation_test.rb

@@ -15,35 +15,34 @@ module DaVinciDTRTestKit
       to the bound ValueSet. Quantity, Coding, and code element bindings will fail if their code/system are not found in
       the valueset.
 
-      This test may process multiple resources, labeling messages with the corresponding tested resources
       This test may process multiple resources, labeling messages with the corresponding tested resources
       in the order that they were received.
     )
 
     run do
       skip_if retrieval_method == 'Static', 'Performing only static flow tests - only one flow is required.'
+      profile_with_version = 'http://hl7.org/fhir/us/davinci-dtr/StructureDefinition/dtr-qpackage-output-parameters|2.0.1'
       endpoint = custom_endpoint.blank? ? '/Questionnaire/$questionnaire-package' : custom_endpoint
       if initial_adaptive_questionnaire_request.nil?
-        resources = load_tagged_requests(QUESTIONNAIRE_TAG)
+        # making the assumption that only one response was received - if there were multiple, we are only validating the
+        # first
+        response = load_tagged_requests(QUESTIONNAIRE_TAG)[0]
+        scratch[:adaptive_responses] = [response]
+        resource = FHIR.from_contents(response.response[:body])
       else
-        resources = []
-        if initial_adaptive_questionnaire_request.is_a?(Array)
-          initial_adaptive_questionnaire_request.each do |_resource|
-            resources.push(fhir_operation("#{url}#{endpoint}", body: JSON.parse(initial_adaptive_questionnaire_request),
-                                                               headers: { 'Content-Type': 'application/json' }))
-          end
-        else
-          resources.push(fhir_operation("#{url}#{endpoint}", body: JSON.parse(initial_adaptive_questionnaire_request),
-                                                             headers: { 'Content-Type': 'application/json' }))
-        end
+        response = fhir_operation("#{url}#{endpoint}", body: JSON.parse(initial_adaptive_questionnaire_request),
+                                                       headers: { 'Content-Type': 'application/json' })
+        resource = FHIR.from_contents(response.response[:body])
+        scratch[:adaptive_responses] = [response]
       end
-      scratch[:adaptive_responses] = resources
+
       assert !scratch[:adaptive_responses].nil?, 'No resources to validate.'
-      perform_response_validation_test(
-        resources,
-        :parameters,
-        'http://hl7.org/fhir/us/davinci-dtr/StructureDefinition/dtr-qpackage-output-parameters'
-      )
+      assert_response_status([200, 201], response: response.response)
+      assert_resource_type(:parameters, resource:)
+      assert_valid_resource(resource:, profile_url: profile_with_version)
+      questionnaire_bundle = resource.parameter.find { |param| param.resource.resourceType == 'Bundle' }&.resource
+      assert questionnaire_bundle, 'No questionnaire bundle found in the response'
+      assert_valid_resource(resource: questionnaire_bundle, profile_url: 'http://hl7.org/fhir/us/davinci-dtr/StructureDefinition/DTR-QPackageBundle|2.0.1')
     end
   end
 end

data/lib/davinci_dtr_test_kit/payer_server_groups/payer_server_next_request_validation_test.rb

@@ -3,7 +3,7 @@ module DaVinciDTRTestKit
   class PayerAdaptiveFormNextRequestTest < Inferno::Test
     include URLs
     include DaVinciDTRTestKit::ValidationTest
-    title '[USER INPUT VALIDATION] Next Question request is valid'
+    title 'User Input Validation:  Next Question request is valid'
     description %(
       This test validates the conformance of the client's request to the
       [SDC Parameters Next Question In](http://hl7.org/fhir/uv/sdc/StructureDefinition/parameters-questionnaire-next-question-in)
@@ -49,13 +49,12 @@ module DaVinciDTRTestKit
           using_manual_entry
         )
       else
-        raise new Inferno::Exceptions::AssertionException.new "Resource does not conform to the either
-         accepted profiles: http://hl7.org/fhir/uv/sdc/StructureDefinition/sdc-questionnaireresponse-adapt
-         or http://hl7.org/fhir/uv/sdc/StructureDefinition/parameters-questionnaire-next-question-in"
+        messages << { type: 'error',
+                      message: format_markdown("No resources were of type 'Parameters' or 'QuestionnaireResponse'") }
       end
-    rescue Inferno::Exceptions::AssertionException => e
-      msg = e.message.to_s.strip
-      skip msg
+      errors_found = messages.any? { |message| message[:type] == 'error' }
+      skip_if errors_found, "No resources conform to the profiles http://hl7.org/fhir/uv/sdc/StructureDefinition/sdc-questionnaireresponse-adapt
+        or http://hl7.org/fhir/uv/sdc/StructureDefinition/parameters-questionnaire-next-question-in"
     end
   end
 end

data/lib/davinci_dtr_test_kit/payer_server_groups/payer_server_next_response_validation_test.rb

@@ -14,7 +14,6 @@ module DaVinciDTRTestKit
       to the bound ValueSet. Quantity, Coding, and code element bindings will fail if their code/system are not found in
       the valueset.
 
-      This test may process multiple resources, labeling messages with the corresponding tested resources
       This test may process multiple resources, labeling messages with the corresponding tested resources
       in the order that they were received.
     )
@@ -38,6 +37,9 @@ module DaVinciDTRTestKit
         :questionnaireResponse,
         'http://hl7.org/fhir/uv/sdc/StructureDefinition/sdc-questionnaireresponse'
       )
+      errors_found = messages.any? { |message| message[:type] == 'error' }
+      skip_if errors_found, "No resources conform to the profiles http://hl7.org/fhir/uv/sdc/StructureDefinition/sdc-questionnaireresponse-adapt
+        or http://hl7.org/fhir/uv/sdc/StructureDefinition/parameters-questionnaire-next-question-in"
     end
   end
 end