davinci_dtr_test_kit 0.9.0 → 0.11.0

data/lib/davinci_dtr_test_kit/dtr_light_ehr_suite.rb

@@ -16,6 +16,25 @@ module DaVinciDTRTestKit
 
     version VERSION
 
+    links [
+      {
+        label: 'Report Issue',
+        url: 'https://github.com/inferno-framework/davinci-dtr-test-kit/issues'
+      },
+      {
+        label: 'Open Source',
+        url: 'https://github.com/inferno-framework/davinci-dtr-test-kit'
+      },
+      {
+        label: 'Download',
+        url: 'https://github.com/inferno-framework/davinci-dtr-test-kit/releases'
+      },
+      {
+        label: 'Implementation Guide',
+        url: 'https://hl7.org/fhir/us/davinci-dtr/STU2/'
+      }
+    ]
+
     # These inputs will be available to all tests in this suite
     input :url,
           title: 'FHIR Server Base Url'
@@ -31,9 +50,13 @@ module DaVinciDTRTestKit
       oauth_credentials :credentials
     end
 
-    # All FHIR validation requsets will use this FHIR validator
-    validator do
-      url ENV.fetch('VALIDATOR_URL')
+    # Hl7 Validator Wrapper:
+    fhir_resource_validator do
+      igs 'hl7.fhir.us.davinci-dtr#2.0.1'
+
+      exclude_message do |message|
+        message.message.match?(/\A\S+: \S+: URL value '.*' does not resolve/)
+      end
     end
   end
 end

data/lib/davinci_dtr_test_kit/dtr_payer_server_suite.rb

@@ -5,10 +5,12 @@ require_relative 'payer_server_groups/payer_server_static_group'
 require_relative 'payer_server_groups/payer_server_adaptive_group'
 require_relative 'tags'
 require_relative 'mock_payer'
+require_relative 'mock_auth_server'
 require_relative 'version'
 
 module DaVinciDTRTestKit
   class DTRPayerServerSuite < Inferno::TestSuite
+    extend MockAuthServer
     extend MockPayer
 
     id :dtr_payer_server
@@ -16,6 +18,26 @@ module DaVinciDTRTestKit
     description File.read(File.join(__dir__, 'docs', 'dtr_payer_server_suite_description_v201.md'))
 
     version VERSION
+
+    links [
+      {
+        label: 'Report Issue',
+        url: 'https://github.com/inferno-framework/davinci-dtr-test-kit/issues'
+      },
+      {
+        label: 'Open Source',
+        url: 'https://github.com/inferno-framework/davinci-dtr-test-kit'
+      },
+      {
+        label: 'Download',
+        url: 'https://github.com/inferno-framework/davinci-dtr-test-kit/releases'
+      },
+      {
+        label: 'Implementation Guide',
+        url: 'https://hl7.org/fhir/us/davinci-dtr/STU2/'
+      }
+    ]
+
     # These inputs will be available to all tests in this suite
 
     input :retrieval_method,
@@ -73,23 +95,27 @@ module DaVinciDTRTestKit
       oauth_credentials :credentials
     end
 
-    # All FHIR validation requsets will use this FHIR validator
-    validator do
-      url ENV.fetch('VALIDATOR_URL')
+    # Hl7 Validator Wrapper:
+    fhir_resource_validator do
+      igs 'hl7.fhir.us.davinci-dtr#2.0.1'
+
+      exclude_message do |message|
+        message.message.match?(/\A\S+: \S+: URL value '.*' does not resolve/)
+      end
     end
 
     allow_cors QUESTIONNAIRE_PACKAGE_PATH, NEXT_PATH
 
-    record_response_route :post, TOKEN_PATH, 'dtr_auth', method(:token_response) do |request|
-      DTRPayerServerSuite.extract_client_id(request)
+    record_response_route :post, PAYER_TOKEN_PATH, 'dtr_payer_auth', method(:payer_token_response) do |request|
+      DTRPayerServerSuite.extract_client_id_from_form_params(request)
     end
 
-    record_response_route :post, '/fhir/Questionnaire/$questionnaire-package', QUESTIONNAIRE_TAG,
+    record_response_route :post, QUESTIONNAIRE_PACKAGE_PATH, QUESTIONNAIRE_TAG,
                           method(:payer_questionnaire_response), resumes: method(:test_resumes?) do |request|
       DTRPayerServerSuite.extract_bearer_token(request)
     end
 
-    record_response_route :post, '/fhir/Questionnaire/$next-question', NEXT_TAG,
+    record_response_route :post, NEXT_PATH, NEXT_TAG,
                           method(:questionnaire_next_response), resumes: method(:test_resumes?) do |request|
       DTRPayerServerSuite.extract_bearer_token(request)
     end

data/lib/davinci_dtr_test_kit/dtr_questionnaire_response_validation.rb

@@ -36,6 +36,16 @@ module DaVinciDTRTestKit
       validate_cql_executed(questionnaire_response.item, questionnaire_cql_expression_link_ids,
                             template_prepopulation_expectations, template_override_expectations, validation_errors)
 
+      if template_prepopulation_expectations.size.positive?
+        validation_errors << 'Items expected to be pre-populated not found: ' \
+                             "#{template_prepopulation_expectations.keys.join(', ')}"
+      end
+
+      if template_override_expectations.size.positive?
+        validation_errors << 'Items expected to be pre-poplated and overridden not found: ' \
+                             "#{template_override_expectations.keys.join(', ')}"
+      end
+
       validation_errors.each { |msg| messages << { type: 'error', message: msg } }
       assert validation_errors.blank?, 'QuestionnaireResponse is not conformant. Check messages for issues found.'
     end
@@ -47,10 +57,11 @@ module DaVinciDTRTestKit
         link_id = item_to_validate.linkId
         if questionnaire_cql_expression_link_ids.include?(link_id)
           if template_prepopulation_expectations.key?(link_id)
-            check_item_prepopulation(item_to_validate, template_prepopulation_expectations[link_id], error_messages,
-                                     false)
+            check_item_prepopulation(item_to_validate, template_prepopulation_expectations.delete(link_id),
+                                     error_messages, false)
           elsif template_override_expectations.include?(link_id)
-            check_item_prepopulation(item_to_validate, template_override_expectations[link_id], error_messages, true)
+            check_item_prepopulation(item_to_validate, template_override_expectations.delete(link_id), error_messages,
+                                     true)
           else
             raise "template missing expectation for question `#{link_id}`"
           end
@@ -84,11 +95,10 @@ module DaVinciDTRTestKit
           raise "Template QuestionnaireResponse item `#{target_link_id}` missing the `origin.source` extension"
         end
 
-        # TODO: handle other data types
         if source_extension.value == 'auto'
-          expected_prepopulated[target_link_id] = target_item_answer.value
+          expected_prepopulated[target_link_id] = target_item_answer
         elsif source_extension.value == 'override'
-          expected_overrides[target_link_id] = target_item_answer.value
+          expected_overrides[target_link_id] = target_item_answer
         else
           raise "`origin.source` extension for item `#{target_link_id}` has unexpected value: #{source_extension.value}"
         end
@@ -114,12 +124,12 @@ module DaVinciDTRTestKit
       answer = item.answer.first
       if answer&.value&.present?
         # check answer
-        if override && answer.value == expected_answer
+        if override && answer_value_equal?(expected_answer, answer)
           error_list << "Answer to item `#{item.linkId}` was not overriden from the pre-populated value. " \
                         "Found #{expected_answer}, but should be different"
-        elsif !override && answer.value != expected_answer
-          error_list << "answer to item `#{item.linkId}` contains unexpected value. Expected: #{expected_answer}. " \
-                        "Found #{answer.value}"
+        elsif !override && !answer_value_equal?(expected_answer, answer)
+          error_list << "answer to item `#{item.linkId}` contains unexpected value. Expected: \
+          #{value_for_display(expected_answer)}. Found #{value_for_display(answer)}"
         end
 
         # check origin.source extension
@@ -176,5 +186,11 @@ module DaVinciDTRTestKit
     def coding_equal?(expected, actual)
       expected.system == actual&.system && expected.code == actual&.code
     end
+
+    def value_for_display(answer)
+      return "#{answer.value&.system}|#{answer.value&.code}" if answer.valueCoding.present?
+
+      answer.value
+    end
   end
 end

data/lib/davinci_dtr_test_kit/dtr_smart_app_suite.rb

@@ -11,8 +11,9 @@ require_relative 'version'
 
 module DaVinciDTRTestKit
   class DTRSmartAppSuite < Inferno::TestSuite
-    extend MockPayer
+    extend MockAuthServer
     extend MockEHR
+    extend MockPayer
 
     id :dtr_smart_app
     title 'Da Vinci DTR SMART App Test Suite'
@@ -20,48 +21,92 @@ module DaVinciDTRTestKit
 
     version VERSION
 
-    # All FHIR validation requsets will use this FHIR validator
-    validator do
-      url ENV.fetch('VALIDATOR_URL')
+    links [
+      {
+        label: 'Report Issue',
+        url: 'https://github.com/inferno-framework/davinci-dtr-test-kit/issues'
+      },
+      {
+        label: 'Open Source',
+        url: 'https://github.com/inferno-framework/davinci-dtr-test-kit'
+      },
+      {
+        label: 'Download',
+        url: 'https://github.com/inferno-framework/davinci-dtr-test-kit/releases'
+      },
+      {
+        label: 'Implementation Guide',
+        url: 'https://hl7.org/fhir/us/davinci-dtr/STU2/'
+      }
+    ]
+
+    # Hl7 Validator Wrapper:
+    fhir_resource_validator do
+      igs 'hl7.fhir.us.davinci-dtr#2.0.1'
+
+      exclude_message do |message|
+        message.message.match?(/\A\S+: \S+: URL value '.*' does not resolve/)
+      end
     end
 
-    allow_cors QUESTIONNAIRE_PACKAGE_PATH, QUESTIONNAIRE_RESPONSE_PATH, FHIR_RESOURCE_PATH, FHIR_SEARCH_PATH
+    allow_cors QUESTIONNAIRE_PACKAGE_PATH, QUESTIONNAIRE_RESPONSE_PATH, FHIR_RESOURCE_PATH, FHIR_SEARCH_PATH,
+               EHR_AUTHORIZE_PATH, EHR_TOKEN_PATH
 
     route(:get, '/fhir/metadata', method(:metadata_handler))
 
-    record_response_route :post, TOKEN_PATH, 'dtr_auth', method(:token_response) do |request|
-      DTRSmartAppSuite.extract_client_id(request)
+    route(:get, SMART_CONFIG_PATH, method(:ehr_smart_config))
+
+    record_response_route :get, EHR_AUTHORIZE_PATH, 'dtr_smart_app_ehr_authorize', method(:ehr_authorize),
+                          resumes: ->(_) { false } do |request|
+      DTRSmartAppSuite.extract_client_id_from_query_params(request)
+    end
+
+    record_response_route :post, EHR_AUTHORIZE_PATH, 'dtr_smart_app_authorize', method(:ehr_authorize),
+                          resumes: ->(_) { false } do |request|
+      DTRSmartAppSuite.extract_client_id_from_form_params(request)
+    end
+
+    record_response_route :post, EHR_TOKEN_PATH, 'dtr_smart_app_ehr_token', method(:ehr_token_response),
+                          resumes: ->(_) { false } do |request|
+      DTRSmartAppSuite.extract_client_id_from_token_request(request)
+    end
+
+    record_response_route :post, PAYER_TOKEN_PATH, 'dtr_smart_app_payer_token',
+                          method(:payer_token_response) do |request|
+      DTRSmartAppSuite.extract_client_id_from_client_assertion(request)
     end
 
     record_response_route :post, QUESTIONNAIRE_PACKAGE_PATH, QUESTIONNAIRE_PACKAGE_TAG,
                           method(:questionnaire_package_response), resumes: ->(_) { false } do |request|
-      DTRSmartAppSuite.extract_bearer_token(request)
+      DTRSmartAppSuite.extract_client_id_from_bearer_token(request)
     end
 
     record_response_route :post, QUESTIONNAIRE_RESPONSE_PATH, 'dtr_smart_app_questionnaire_response',
                           method(:questionnaire_response_response) do |request|
-      DTRSmartAppSuite.extract_bearer_token(request)
+      DTRSmartAppSuite.extract_client_id_from_bearer_token(request)
     end
 
     record_response_route :get, FHIR_RESOURCE_PATH, SMART_APP_EHR_REQUEST_TAG, method(:get_fhir_resource),
                           resumes: ->(_) { false } do |request|
-      DTRSmartAppSuite.extract_bearer_token(request)
+      DTRSmartAppSuite.extract_client_id_from_bearer_token(request)
     end
 
     record_response_route :get, FHIR_SEARCH_PATH, SMART_APP_EHR_REQUEST_TAG, method(:get_fhir_resource),
                           resumes: ->(_) { false } do |request|
-      DTRSmartAppSuite.extract_bearer_token(request)
+      DTRSmartAppSuite.extract_client_id_from_bearer_token(request)
     end
 
     resume_test_route :get, RESUME_PASS_PATH do |request|
-      DTRSmartAppSuite.extract_token_from_query_params(request)
+      DTRSmartAppSuite.extract_client_id_from_query_params(request)
     end
 
     resume_test_route :get, RESUME_FAIL_PATH, result: 'fail' do |request|
-      DTRSmartAppSuite.extract_token_from_query_params(request)
+      DTRSmartAppSuite.extract_client_id_from_query_params(request)
     end
 
-    group from: :oauth2_authentication
+    # TODO: Update based on SMART Launch changes. Do we even want to have this group now?
+    # group from: :oauth2_authentication
+
     group do
       id :dtr_smart_app_basic_workflows
       title 'Basic Workflows'

data/lib/davinci_dtr_test_kit/fixtures/dinner_static/questionnaire_dinner_order_static.json

@@ -7,6 +7,7 @@
       "resource": {
         "resourceType": "Questionnaire",
         "id": "DinnerOrderStatic",
+        "url": "urn:inferno:dtr-test-kit:dinner-order-static",
         "meta": {
           "profile": [
             "http://hl7.org/fhir/StructureDefinition/cqf-questionnaire",
@@ -21,7 +22,6 @@
         ],
         "name": "DinnerOrderStatic",
         "title": "Dinner Order (Static)",
-        "url": "urn:inferno:dtr-test-kit:dinner-order-static",
         "status": "draft",
         "subjectType": [
           "Patient"

data/lib/davinci_dtr_test_kit/fixtures/questionnaire_package.json

@@ -5,6 +5,7 @@
       "resource": {
         "resourceType": "Questionnaire",
         "id": "RespiratoryAssistDevices",
+        "url": "urn:inferno:dtr-test-kit:respiratory-assist-devices",
         "meta": {
           "profile": [
             "http://hl7.org/fhir/StructureDefinition/cqf-questionnaire",
@@ -453,7 +454,6 @@
         ],
         "name": "RespiratoryAssistDevices",
         "title": "Respiratory Assist Device Questionnaire",
-        "url": "urn:fake",
         "status": "draft",
         "subjectType": [
           "Patient"

data/lib/davinci_dtr_test_kit/mock_auth_server.rb

@@ -0,0 +1,135 @@
+require_relative 'urls'
+require_relative 'fixtures'
+
+module DaVinciDTRTestKit
+  module MockAuthServer
+    include Fixtures
+
+    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}"
+      response_body =
+        {
+          authorization_endpoint: base_url + EHR_AUTHORIZE_PATH,
+          token_endpoint: base_url + EHR_TOKEN_PATH,
+          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'],
+          response_types_supported: ['code'],
+          code_challenge_methods_supported: ['S256'],
+          capabilities: [
+            'launch-ehr',
+            'permission-patient',
+            'permission-user',
+            'client-public',
+            'client-confidential-symmetric',
+            'client-confidential-asymmetric'
+          ]
+        }.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
+      if params['redirect_uri'].present?
+        redirect_uri = "#{params['redirect_uri']}?" \
+                       "code=#{SecureRandom.hex}&" \
+                       "state=#{params['state']}"
+        request.status = 302
+        request.response_headers = { 'Location' => redirect_uri }
+      else
+        request.status = 400
+        request.response_headers = { 'Content-Type': 'application/json' }
+        request.response_body = FHIR::OperationOutcome.new(
+          issue: FHIR::OperationOutcome::Issue.new(severity: 'fatal', code: 'required',
+                                                   details: FHIR::CodeableConcept.new(
+                                                     text: 'No redirect_uri provided'
+                                                   ))
+        ).to_json
+      end
+    end
+
+    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)
+      smart_app_launch_input = test_input.find { |input| input['name'] == 'smart_app_launch' }
+
+      if smart_app_launch_input.present? && smart_app_launch_input['value'] == 'inferno'
+        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?
+        fhir_context = fhir_context_input_value || [
+          { reference: 'Coverage/cov015' },
+          { reference: 'DeviceRequest/devreqe0470' }
+        ]
+
+        smart_patient_input = test_input.find { |input| input['name'] == 'smart_patient_id' }
+        smart_patient_input_value = smart_patient_input['value'] if smart_patient_input.present?
+        smart_patient = smart_patient_input_value || 'pat015'
+
+        response.merge!({ patient: smart_patient, fhirContext: fhir_context })
+      end
+      request.response_body = response.to_json
+      request.response_headers = { 'Access-Control-Allow-Origin' => '*' }
+      request.status = 200
+    end
+
+    def payer_token_response(request, _test = nil, _test_result = nil)
+      # Placeholder for a more complete mock token endpoint
+      request.response_body = { access_token: SecureRandom.hex, token_type: 'bearer', expires_in: 3600 }.to_json
+      request.status = 200
+    end
+
+    def extract_client_id_from_token_request(request)
+      # Public client || confidential client asymmetric || confidential client symmetric
+      extract_client_id_from_form_params(request) ||
+        extract_client_id_from_client_assertion(request) ||
+        extract_client_id_from_basic_auth(request)
+    end
+
+    def extract_client_id_from_form_params(request)
+      URI.decode_www_form(request.request_body).to_h['client_id']
+    end
+
+    def extract_client_id_from_client_assertion(request)
+      encoded_jwt = URI.decode_www_form(request.request_body).to_h['client_assertion']
+      return unless encoded_jwt.present?
+
+      jwt_payload = JWT.decode(encoded_jwt, nil, false)&.first # skip signature verification
+      jwt_payload['iss'] || jwt_payload['sub'] if jwt_payload.present?
+    end
+
+    def extract_client_id_from_basic_auth(request)
+      encoded_credentials = request.request_header('Authorization')&.value&.split&.last
+      return unless encoded_credentials.present?
+
+      decoded_credentials = Base64.decode64(encoded_credentials)
+      decoded_credentials&.split(':')&.first
+    end
+
+    def extract_client_id_from_query_params(request)
+      request.query_parameters['client_id']
+    end
+
+    def extract_client_id_from_bearer_token(request)
+      token = extract_bearer_token(request)
+      JWT.decode(token, nil, false)&.first&.dig('inferno_client_id')
+    end
+
+    # Header expected to be a bearer token of the form "Bearer: <token>"
+    def extract_bearer_token(request)
+      request.request_header('Authorization')&.value&.split&.last
+    end
+
+    def extract_token_from_query_params(request)
+      request.query_parameters['token']
+    end
+  end
+end

data/lib/davinci_dtr_test_kit/mock_ehr.rb

@@ -1,11 +1,13 @@
 # frozen_string_literal: true
 
+require_relative 'urls'
+
 module DaVinciDTRTestKit
   module MockEHR
     RESOURCE_SERVER_BASE = ENV.fetch('FHIR_REFERENCE_SERVER')
     RESOURCE_SERVER_BEARER_TOKEN = 'SAMPLE_TOKEN'
 
-    RESPONSE_HEADERS = { 'Content-Type': 'application/json', 'Access-Control-Allow-Origin': '*' }.freeze
+    RESPONSE_HEADERS = { 'Content-Type' => 'application/json', 'Access-Control-Allow-Origin' => '*' }.freeze
 
     def resource_server_client
       return @resource_server_client if @resource_server_client
@@ -18,13 +20,13 @@ module DaVinciDTRTestKit
     def metadata_handler(_env)
       cs = resource_server_client.capability_statement
       if cs.present?
-        [200, { 'Content-Type' => 'application/json', 'Access-Control-Allow-Origin' => '*' }, [cs.to_json]]
+        [200, RESPONSE_HEADERS, [cs.to_json]]
       else
         [500, {}, ['Unexpected error occurred while fetching metadata']]
       end
     end
 
-    def get_fhir_resource(request, _test = nil, _test_result = nil)
+    def get_fhir_resource(request, _test = nil, test_result = nil)
       resource_type, id = resource_type_and_id_from_url(request.url)
       request.response_headers = RESPONSE_HEADERS
 
@@ -34,15 +36,7 @@ module DaVinciDTRTestKit
         resource_type = nil
       end
 
-      if resource_type.present?
-        response = if id.present?
-                     resource_server_client.read(fhir_class, id)
-                   else
-                     resource_server_client.search(fhir_class, search: { parameters: request.query_parameters })
-                   end
-        request.status = response.code
-        request.response_body = response.body
-      else
+      if resource_type.blank?
         request.status = 400
         request.response_headers = { 'Content-Type': 'application/json' }
         request.response_body = FHIR::OperationOutcome.new(
@@ -51,7 +45,33 @@ module DaVinciDTRTestKit
                                                      text: 'No recognized resource type in URL'
                                                    ))
         ).to_json
+        return
       end
+
+      # Respond with user-inputted resource if there is one that matches the request
+      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?
+      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
+        if matching_resource.present?
+          request.status = 200
+          request.response_headers = { 'Content-Type': 'application/json' }
+          request.response_body = matching_resource.to_json
+          return
+        end
+      end
+
+      # Proxy resource request to the reference server
+      response = if id.present?
+                   resource_server_client.read(fhir_class, id)
+                 else
+                   resource_server_client.search(fhir_class, search: { parameters: request.query_parameters })
+                 end
+      request.status = response.code
+      request.response_body = response.body
     end
 
     def questionnaire_response_response(request, _test = nil, _test_result = nil)

data/lib/davinci_dtr_test_kit/mock_payer.rb

@@ -6,13 +6,7 @@ module DaVinciDTRTestKit
   module MockPayer
     include Fixtures
 
-    RESPONSE_HEADERS = { 'Content-Type': 'application/json', 'Access-Control-Allow-Origin': '*' }.freeze
-
-    def token_response(request, _test = nil, _test_result = nil)
-      # Placeholder for a more complete mock token endpoint
-      request.response_body = { access_token: SecureRandom.hex, token_type: 'bearer', expires_in: 300 }.to_json
-      request.status = 200
-    end
+    RESPONSE_HEADERS = { 'Content-Type' => 'application/json', 'Access-Control-Allow-Origin' => '*' }.freeze
 
     def questionnaire_package_response(request, _test = nil, test_result = nil)
       request.status = 200
@@ -25,7 +19,7 @@ module DaVinciDTRTestKit
       url_input = JSON.parse(test_result.input_json).find { |input| input['name'] == 'url' }
       client = FHIR::Client.new(url_input['value'])
       client.default_json
-      endpoint = endpoint_input['value'].nil? ? '/Questionnaire/$questionnaire-package' : endpoint_input['value']
+      endpoint = endpoint_input.to_h['value'].nil? ? '/Questionnaire/$questionnaire-package' : endpoint_input['value']
       payer_response = client.send(:post, endpoint, JSON.parse(request.request_body),
                                    { 'Content-Type' => 'application/json' })
 
@@ -47,19 +41,6 @@ module DaVinciDTRTestKit
       request.response_body = payer_response.response[:body]
     end
 
-    def extract_client_id(request)
-      URI.decode_www_form(request.request_body).to_h['client_id']
-    end
-
-    # Header expected to be a bearer token of the form "Bearer: <token>"
-    def extract_bearer_token(request)
-      request.request_header('Authorization')&.value&.split&.last
-    end
-
-    def extract_token_from_query_params(request)
-      request.query_parameters['token']
-    end
-
     def test_resumes?(test)
       !test.config.options[:accepts_multiple_requests]
     end

data/lib/davinci_dtr_test_kit/payer_server_groups/payer_server_static_group.rb

@@ -37,11 +37,13 @@ module DaVinciDTRTestKit
           description: 'Manual Flow',
           type: 'textarea'
 
+    input :access_token, :retrieval_method
+
     input_order :retrieval_method,
-                :url,
+                :access_token,
                 :initial_static_questionnaire_request
 
-    test from: :dtr_v201_payer_static_questionnaire_request_test, receives_request: :statice_questionnaire_request
+    test from: :dtr_v201_payer_static_questionnaire_request_test, receives_request: :static_questionnaire_request
     test from: :dtr_v201_payer_static_form_request_validation_test
     test from: :dtr_v201_payer_static_form_response_test
     test from: :dtr_v201_payer_static_form_libraries_test

data/lib/davinci_dtr_test_kit/payer_server_groups/static_form_libraries_test.rb

@@ -12,8 +12,8 @@ module DaVinciDTRTestKit
 
     run do
       skip_if retrieval_method == 'Adaptive', 'Performing only adaptive flow tests - only one flow is required.'
-      skip_if scratch[:questionnaire_bundle].nil?, 'No questionnaire bundle returned.'
-      check_libraries(scratch[:questionnaire_bundle])
+      skip_if scratch[:output_parameters].nil?, 'No questionnaire bundle returned.'
+      check_libraries(scratch[:output_parameters])
     end
   end
 end

data/lib/davinci_dtr_test_kit/payer_server_groups/static_form_questionnaire_expressions_test.rb

@@ -12,9 +12,9 @@ module DaVinciDTRTestKit
 
     run do
       skip_if retrieval_method == 'Adaptive', 'Performing only adaptive flow tests - only one flow is required.'
-      skip_if scratch[:questionnaire_bundle].nil?, 'No questionnaire bundle returned.'
-      questionnaire_items_test(scratch[:questionnaire_bundle], final_cql_test: true)
-      scratch[:questionnaire_bundle] = nil
+      skip_if scratch[:output_parameters].nil?, 'No questionnaire bundle returned.'
+      questionnaire_items_test(scratch[:output_parameters], final_cql_test: true)
+      scratch[:output_parameters] = nil
     end
   end
 end

data/lib/davinci_dtr_test_kit/payer_server_groups/static_form_questionnaire_extensions_test.rb

@@ -12,8 +12,8 @@ module DaVinciDTRTestKit
 
     run do
       skip_if retrieval_method == 'Adaptive', 'Performing only adaptive flow tests - only one flow is required.'
-      skip_if scratch[:questionnaire_bundle].nil?, 'No questionnaire bundle returned.'
-      questionnaire_extensions_test(scratch[:questionnaire_bundle])
+      skip_if scratch[:output_parameters].nil?, 'No questionnaire bundle returned.'
+      questionnaire_extensions_test(scratch[:output_parameters])
     end
   end
 end

data/lib/davinci_dtr_test_kit/payer_server_groups/static_form_request_test.rb

@@ -9,6 +9,7 @@ module DaVinciDTRTestKit
     )
     id :dtr_v201_payer_static_questionnaire_request_test
     config options: { accepts_multiple_requests: false }
+    input :initial_static_questionnaire_request, :access_token, :retrieval_method, :url
 
     run do
       skip_if retrieval_method == 'Adaptive', 'Performing only adaptive flow tests - only one flow is required.'