davinci_dtr_test_kit 0.12.0 → 0.14.0

data/lib/davinci_dtr_test_kit/dtr_questionnaire_response_validation.rb

@@ -1,30 +1,86 @@
-require_relative 'fixtures'
+# frozen_string_literal: true
 
 module DaVinciDTRTestKit
   module DTRQuestionnaireResponseValidation
-    include Fixtures
-
     CQL_EXPRESSION_EXTENSIONS = [
       'http://hl7.org/fhir/uv/sdc/StructureDefinition/sdc-questionnaire-initialExpression',
       'http://hl7.org/fhir/uv/sdc/StructureDefinition/sdc-questionnaire-calculatedExpression',
       'http://hl7.org/fhir/uv/sdc/StructureDefinition/sdc-questionnaire-candidateExpression'
     ].freeze
 
-    def validate_questionnaire_pre_population(questionnaire_response, test_id)
-      # Requirements:
-      #  - Prior to exposing the draft QuestionnaireResponse to the user for completion and/or review, the DTR client
-      #    SHALL execute all CQL necessary to resolve the initialExpression, candidateExpression and
-      #    calculatedExpression extensions found in the Questionnaire for any enabled elements.
-      #  - All items that are pre-populated (whether by the payer in the initial QuestionnaireResponse provided in the
-      #    questionnaire package, or from data retrieved from the EHR) SHALL have their origin.source set to ‘auto’.
-      #
-      # Note that in the questionnaire fixture, all cql expression elements are enabled, so we don't filter
-      template_questionnaire_response = find_questionnaire_response_for_test_id(test_id)
-      raise "missing QuestionnaireResponse template for test #{test_id}" unless template_questionnaire_response.present?
-
-      questionnaire = find_questionnaire_instance_for_test_id(test_id)
-      raise "missing Questionnaire for test #{test_id}" unless questionnaire.present?
+    def check_is_questionnaire_response(questionnaire_response_json)
+      assert_valid_json(questionnaire_response_json)
+      questionnaire_response = begin
+        FHIR.from_contents(questionnaire_response_json)
+      rescue StandardError
+        nil
+      end
+
+      assert questionnaire_response.present?, 'The QuestionnaireResponse is not a recognized FHIR object'
+      assert_resource_type(:questionnaire_response, resource: questionnaire_response)
+    end
+
+    def verify_basic_conformance(questionnaire_response_json, profile_url = nil)
+      profile_url ||= 'http://hl7.org/fhir/us/davinci-dtr/StructureDefinition/dtr-questionnaireresponse|2.0.1'
+      check_is_questionnaire_response(questionnaire_response_json)
+      assert_valid_resource(resource: FHIR.from_contents(questionnaire_response_json), profile_url:)
+    end
+
+    # This only checks answers in the questionnaire response, meaning it does not catch missing answers
+    def check_origin_sources(questionnaire_items, response_items, expected_overrides: [])
+      response_items&.each do |response_item|
+        check_origin_sources(questionnaire_items, response_item.item, expected_overrides:)
+        next unless response_item.answer&.any?
+
+        link_id = response_item.linkId
+        origin_source = find_origin_source(response_item)
+        questionnaire_item = find_item_by_link_id(questionnaire_items, link_id)
+        is_cql_expression = item_is_cql_expression?(questionnaire_item)
+
+        if origin_source.nil?
+          add_message('error', "Required `origin.source` extension not present on answer to item `#{link_id}`")
+        else
+          check_origin_source(origin_source, link_id, is_cql_expression, override: expected_overrides.include?(link_id))
+        end
+      end
+    end
+
+    def check_origin_source(origin_source, link_id, is_cql_expression, override: false)
+      if override
+        origin_source_error(link_id, ['override'], origin_source) unless origin_source == 'override'
+      elsif is_cql_expression && !['auto', 'override'].include?(origin_source)
+        origin_source_error(link_id, 'auto or override', origin_source)
+      elsif !is_cql_expression && origin_source != 'manual'
+        origin_source_error(link_id, 'manual', origin_source)
+      end
+    end
+
+    # Ensures that all required questions have been answered.
+    # If required_link_ids not provided, all questions are treated as optional.
+    def check_answer_presence(response_items, required_link_ids = [])
+      required_link_ids.each do |link_id|
+        item = find_item_by_link_id(response_items, link_id)
+        unless item&.answer&.any? { |answer| answer.value.present? }
+          add_message('error', "No answer for item #{link_id}")
+        end
+      end
+    end
 
+    def extract_required_link_ids(questionnaire_items)
+      questionnaire_items.each_with_object([]) do |item, required_link_ids|
+        required_link_ids << item.linkId if item.required
+
+        required_link_ids.concat(extract_required_link_ids(item.item)) if item.item.present?
+      end
+    end
+
+    # Requirements:
+    #  - Prior to exposing the draft QuestionnaireResponse to the user for completion and/or review, the DTR client
+    #    SHALL execute all CQL necessary to resolve the initialExpression, candidateExpression and
+    #    calculatedExpression extensions found in the Questionnaire for any enabled elements.
+    #  - All items that are pre-populated (whether by the payer in the initial QuestionnaireResponse provided in the
+    #    questionnaire package, or from data retrieved from the EHR) SHALL have their origin.source set to ‘auto’.
+    def validate_questionnaire_pre_population(questionnaire, template_questionnaire_response, questionnaire_response)
       questionnaire_cql_expression_link_ids = collect_questionnaire_cql_expression_link_ids(questionnaire.item)
       template_prepopulation_expectations = {}
       template_override_expectations = {}
@@ -32,45 +88,42 @@ module DaVinciDTRTestKit
                                              questionnaire_cql_expression_link_ids,
                                              template_prepopulation_expectations,
                                              template_override_expectations)
-      validation_errors = []
+
       validate_cql_executed(questionnaire_response.item, questionnaire_cql_expression_link_ids,
-                            template_prepopulation_expectations, template_override_expectations, validation_errors)
+                            template_prepopulation_expectations, template_override_expectations)
 
       if template_prepopulation_expectations.size.positive?
-        validation_errors << 'Items expected to be pre-populated not found: ' \
-                             "#{template_prepopulation_expectations.keys.join(', ')}"
+        add_message('error', %(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(', ')}"
+        add_message('error', %(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.'
+      assert(messages.none? { |m| m[:type] == 'error' },
+             'QuestionnaireResponse is not conformant. Check messages for issues found.')
     end
 
     def validate_cql_executed(actual_items, questionnaire_cql_expression_link_ids, template_prepopulation_expectations,
-                              template_override_expectations, error_messages)
+                              template_override_expectations)
 
       actual_items&.each do |item_to_validate|
         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.delete(link_id),
-                                     error_messages, false)
+            check_item_prepopulation(item_to_validate, template_prepopulation_expectations.delete(link_id), false)
           elsif template_override_expectations.include?(link_id)
-            check_item_prepopulation(item_to_validate, template_override_expectations.delete(link_id), error_messages,
-                                     true)
+            check_item_prepopulation(item_to_validate, template_override_expectations.delete(link_id), true)
           else
             raise "template missing expectation for question `#{link_id}`"
           end
         end
 
         validate_cql_executed(item_to_validate.item, questionnaire_cql_expression_link_ids,
-                              template_prepopulation_expectations, template_override_expectations, error_messages)
+                              template_prepopulation_expectations, template_override_expectations)
       end
-      error_messages
     end
 
     def extract_expected_answers_from_template(template_questionnaire_response,
@@ -87,70 +140,60 @@ module DaVinciDTRTestKit
           raise "Template QuestionnaireResponse missing an answer for item with link id `#{target_link_id}`"
         end
 
-        origin_extension = find_extension(target_item_answer,
-                                          'http://hl7.org/fhir/us/davinci-dtr/StructureDefinition/information-origin|2.0.1')
-        source_extension = find_extension(origin_extension, 'source')
+        origin_source = find_origin_source(target_item)
 
-        unless source_extension.present?
+        unless origin_source.present?
           raise "Template QuestionnaireResponse item `#{target_link_id}` missing the `origin.source` extension"
         end
 
-        if source_extension.value == 'auto'
+        if origin_source == 'auto'
           expected_prepopulated[target_link_id] = target_item_answer
-        elsif source_extension.value == 'override'
+        elsif origin_source == 'override'
           expected_overrides[target_link_id] = target_item_answer
         else
-          raise "`origin.source` extension for item `#{target_link_id}` has unexpected value: #{source_extension.value}"
+          raise "`origin.source` extension for item `#{target_link_id}` has unexpected value: #{origin_source}"
         end
       end
     end
 
-    def validate_data_requirements_retrieved(expected_questionnaire_response, questionnaire_response)
-      error_messages = []
-
-      DATA_REQUIREMENT_ANSWERS.each do |library_name, link_id|
-        expected = find_item_by_link_id(expected_questionnaire_response.item, link_id).answer.first.value
-        actual = find_item_by_link_id(questionnaire_response.item, link_id)&.answer&.first&.value
-        next if coding_equal?(expected, actual)
+    def check_item_prepopulation(item, expected_answer, override)
+      answer = item.answer.first
+      link_id = item.linkId
 
-        error_messages << "dataRequirement not satisfied for Library '#{library_name}'. Expected answer to " \
-                          "question with linkId `#{link_id}` to have coding with system: '`#{expected.system}`' " \
-                          "and value: '`#{expected.code}`'"
+      unless answer&.value&.present?
+        add_message('error', "No answer for item `#{link_id}`")
+        return
       end
-      error_messages
-    end
 
-    def check_item_prepopulation(item, expected_answer, error_list, override)
-      answer = item.answer.first
-      if answer&.value&.present?
-        # check 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_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_answer(link_id, override, expected_answer, answer)
 
-        # check origin.source extension
-        origin_extension = find_extension(answer,
-                                          'http://hl7.org/fhir/us/davinci-dtr/StructureDefinition/information-origin|2.0.1')
-        source_extension = find_extension(origin_extension, 'source')
+      origin_source = find_origin_source(item)
+      expected_origin_source = override ? 'override' : 'auto'
 
-        if source_extension.present?
-          expected_source_value = override ? 'override' : 'auto'
-          if source_extension.value != expected_source_value
-            error_list << "`origin.source` extension on item `#{item.linkId}` contains unexpected value. Expected: " \
-                          "#{expected_source_value}. Found #{source_extension.value}"
-          end
-        else
-          error_list << "Required `origin.source` extension not present on answer to item `#{item.linkId}`"
+      if origin_source.present?
+        unless origin_source == expected_origin_source
+          origin_source_error(link_id, expected_origin_source, origin_source)
         end
       else
-        error_list << "No answer for item `#{item.linkId}`"
+        add_message('error', "Required `origin.source` extension not present on answer to item `#{item.linkId}`")
+      end
+    end
+
+    def check_answer(link_id, override, expected_answer, answer)
+      if override && answer_value_equal?(expected_answer, answer)
+        add_message('error', %(Answer to item `#{link_id}` was not overriden from the pre-populated value.
+                               Found #{expected_answer}, but should be different))
+      elsif !override && !answer_value_equal?(expected_answer, answer)
+        add_message('error', %(Answer to item `#{link_id}` contains unexpected value. Expected:
+                               #{value_for_display(expected_answer)}. Found #{value_for_display(answer)}))
       end
     end
 
+    def origin_source_error(link_id, expected, actual)
+      add_message('error', %(`origin.source` extension on item `#{link_id}` contains unexpected value.
+                             Expected: #{expected}. Found: #{actual}))
+    end
+
     def find_item_by_link_id(items, link_id)
       items.each do |item|
         return item if item.linkId == link_id
@@ -161,6 +204,14 @@ module DaVinciDTRTestKit
       nil
     end
 
+    def find_origin_source(item)
+      origin_extension = find_extension(
+        item&.answer&.first,
+        'http://hl7.org/fhir/us/davinci-dtr/StructureDefinition/information-origin'
+      )
+      find_extension(origin_extension, 'source')&.value
+    end
+
     def find_extension(element, url)
       element&.extension&.find { |e| e.url == url }
     end

data/lib/davinci_dtr_test_kit/dtr_smart_app_suite.rb

@@ -1,19 +1,21 @@
-require_relative 'ext/inferno_core/runnable'
-require_relative 'ext/inferno_core/record_response_route'
-require_relative 'ext/inferno_core/request'
 require_relative 'auth_groups/oauth2_authentication_group'
 require_relative 'client_groups/resp_assist_device/dtr_smart_app_questionnaire_workflow_group'
 require_relative 'client_groups/dinner_static/dtr_smart_app_questionnaire_workflow_group'
 require_relative 'client_groups/dinner_adaptive/dtr_smart_app_questionnaire_workflow_group'
-require_relative 'mock_payer'
-require_relative 'mock_ehr'
+require_relative 'endpoints/cors'
+require_relative 'endpoints/mock_authorization'
+require_relative 'endpoints/mock_authorization/authorize_endpoint'
+require_relative 'endpoints/mock_authorization/token_endpoint'
+require_relative 'endpoints/mock_payer/questionnaire_package_endpoint'
+require_relative 'endpoints/mock_payer/next_question_endpoint'
+require_relative 'endpoints/mock_ehr'
+require_relative 'endpoints/mock_ehr/questionnaire_response_endpoint'
+require_relative 'endpoints/mock_ehr/fhir_get_endpoint'
 require_relative 'version'
 
 module DaVinciDTRTestKit
   class DTRSmartAppSuite < Inferno::TestSuite
-    extend MockAuthServer
-    extend MockEHR
-    extend MockPayer
+    extend CORS
 
     id :dtr_smart_app
     title 'Da Vinci DTR SMART App Test Suite'
@@ -50,58 +52,32 @@ module DaVinciDTRTestKit
     end
 
     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))
-
-    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_ehr_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_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_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_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_client_id_from_bearer_token(request)
-    end
+               EHR_AUTHORIZE_PATH, EHR_TOKEN_PATH, JKWS_PATH, OPENID_CONFIG_PATH, NEXT_PATH
+
+    # Authorization server
+    route(:get, SMART_CONFIG_PATH, MockAuthorization.method(:ehr_smart_config))
+    route(:get, OPENID_CONFIG_PATH, MockAuthorization.method(:ehr_openid_config))
+    route(:get, JKWS_PATH, MockAuthorization.method(:jwks))
+    suite_endpoint :get, EHR_AUTHORIZE_PATH, MockAuthorization::AuthorizeEndpoint
+    suite_endpoint :post, EHR_AUTHORIZE_PATH, MockAuthorization::AuthorizeEndpoint
+    suite_endpoint :post, EHR_TOKEN_PATH, MockAuthorization::TokenEndpoint
+
+    # Payer
+    suite_endpoint :post, QUESTIONNAIRE_PACKAGE_PATH, MockPayer::QuestionnairePackageEndpoint
+    suite_endpoint :post, NEXT_PATH, MockPayer::NextQuestionEndpoint
+
+    # EHR
+    route(:get, '/fhir/metadata', MockEHR.method(:metadata))
+    suite_endpoint :post, QUESTIONNAIRE_RESPONSE_PATH, MockEHR::QuestionnaireResponseEndpoint
+    suite_endpoint :get, FHIR_RESOURCE_PATH, MockEHR::FHIRGetEndpoint
+    suite_endpoint :get, FHIR_SEARCH_PATH, MockEHR::FHIRGetEndpoint
 
     resume_test_route :get, RESUME_PASS_PATH do |request|
-      DTRSmartAppSuite.extract_client_id_from_query_params(request)
+      request.query_parameters['client_id'] || request.query_parameters['token']
     end
 
     resume_test_route :get, RESUME_FAIL_PATH, result: 'fail' do |request|
-      DTRSmartAppSuite.extract_client_id_from_query_params(request)
+      request.query_parameters['client_id'] || request.query_parameters['token']
     end
 
     # TODO: Update based on SMART Launch changes. Do we even want to have this group now?
@@ -115,7 +91,7 @@ module DaVinciDTRTestKit
       )
 
       group from: :dtr_smart_app_static_dinner_questionnaire_workflow
-      # group from: :dtr_smart_app_adaptive_dinner_questionnaire_workflow - TODO
+      group from: :dtr_smart_app_adaptive_dinner_questionnaire_workflow
     end
     group do
       id :dtr_smart_app_questionnaire_functionality

data/lib/davinci_dtr_test_kit/endpoints/cors.rb

@@ -0,0 +1,20 @@
+module DaVinciDTRTestKit
+  module CORS
+    PRE_FLIGHT_HANDLER = proc do
+      [
+        200,
+        {
+          'Access-Control-Allow-Origin' => '*',
+          'Access-Control-Allow-Headers' => 'Content-Type, Authorization'
+        },
+        ['']
+      ]
+    end
+
+    def allow_cors(*paths)
+      paths.each do |path|
+        route(:options, path, PRE_FLIGHT_HANDLER)
+      end
+    end
+  end
+end

data/lib/davinci_dtr_test_kit/endpoints/mock_authorization/authorize_endpoint.rb

@@ -0,0 +1,32 @@
+module DaVinciDTRTestKit
+  module MockAuthorization
+    class AuthorizeEndpoint < Inferno::DSL::SuiteEndpoint
+      def test_run_identifier
+        request.params[:client_id]
+      end
+
+      def tags
+        [EHR_AUTHORIZE_TAG]
+      end
+
+      def make_response
+        if request.params[:redirect_uri].present?
+          redirect_uri = "#{request.params[:redirect_uri]}?" \
+                         "code=#{SecureRandom.hex}&" \
+                         "state=#{request.params[:state]}"
+          response.status = 302
+          response.headers['Location'] = redirect_uri
+        else
+          response.status = 400
+          response.format = 'application/fhir+json'
+          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
+    end
+  end
+end

data/lib/davinci_dtr_test_kit/endpoints/mock_authorization/simple_token_endpoint.rb

@@ -0,0 +1,19 @@
+module DaVinciDTRTestKit
+  module MockAuthorization
+    class SimpleTokenEndpoint < Inferno::DSL::SuiteEndpoint
+      def test_run_identifier
+        request.params[:client_id]
+      end
+
+      # Placeholder for a more complete mock token endpoint
+      def make_response
+        response.body = { access_token: SecureRandom.hex, token_type: 'bearer', expires_in: 3600 }.to_json
+        response.status = 200
+      end
+
+      def update_result
+        results_repo.update_result(result.id, 'pass')
+      end
+    end
+  end
+end

data/lib/davinci_dtr_test_kit/endpoints/mock_authorization/token_endpoint.rb

@@ -0,0 +1,116 @@
+# frozen_string_literal: true
+
+require_relative '../../urls'
+require_relative '../mock_authorization'
+
+module DaVinciDTRTestKit
+  module MockAuthorization
+    AUTHORIZED_PRACTITIONER_ID = 'pra1234' # Must exist on the FHIR_REFERENCE_SERVER (env var)
+
+    class TokenEndpoint < Inferno::DSL::SuiteEndpoint
+      def test_run_identifier
+        extract_client_id
+      end
+
+      def make_response
+        client_id = extract_client_id
+        access_token = JWT.encode({ inferno_client_id: client_id }, nil, 'none')
+        granted_scopes = SUPPORTED_SCOPES & requested_scopes
+
+        response_hash = { access_token:, scope: granted_scopes.join(' '), token_type: 'bearer', expires_in: 3600 }
+
+        if granted_scopes.include?('openid')
+          response_hash.merge!(id_token: create_id_token(client_id, fhir_user: granted_scopes.include?('fhirUser')))
+        end
+
+        fhir_context_input = find_test_input("#{input_group_prefix}_smart_fhir_context")
+        begin
+          fhir_context = JSON.parse(fhir_context_input)
+        rescue StandardError
+          fhir_context = nil
+        end
+        response_hash.merge!(fhirContext: fhir_context) if fhir_context
+
+        smart_patient_input = find_test_input("#{input_group_prefix}_smart_patient_id")
+        response_hash.merge!(patient: smart_patient_input) if smart_patient_input
+
+        response.body = response_hash.to_json
+        response.headers['Cache-Control'] = 'no-store'
+        response.headers['Pragma'] = 'no-cache'
+        response.headers['Access-Control-Allow-Origin'] = '*'
+        response.status = 200
+      end
+
+      private
+
+      def extract_client_id
+        # Public client            || confidential client asymmetric          || confidential client symmetric
+        request.params[:client_id] || extract_client_id_from_client_assertion || extract_client_id_from_basic_auth
+      end
+
+      def extract_client_id_from_client_assertion
+        encoded_jwt = request.params[:client_assertion]
+        return unless encoded_jwt.present?
+
+        jwt_payload =
+          begin
+            JWT.decode(encoded_jwt, nil, false)&.first # skip signature verification
+          rescue StandardError
+            nil
+          end
+
+        jwt_payload['iss'] || jwt_payload['sub'] if jwt_payload.present?
+      end
+
+      def input_group_prefix
+        if test.id.include?('static')
+          'static'
+        elsif test.id.include?('adaptive')
+          'adaptive'
+        else
+          'resp'
+        end
+      end
+
+      def find_test_input(input_name)
+        JSON.parse(result.input_json)&.find { |input| input['name'] == input_name }&.dig('value')
+      end
+
+      def extract_client_id_from_basic_auth
+        encoded_credentials = request.headers['authorization']&.delete_prefix('Basic ')
+        return unless encoded_credentials.present?
+
+        decoded_credentials = Base64.decode64(encoded_credentials)
+        decoded_credentials&.split(':')&.first
+      end
+
+      def requested_scopes
+        auth_request = requests_repo.tagged_requests(result.test_session_id, [EHR_AUTHORIZE_TAG]).last
+        return [] unless auth_request
+
+        auth_params = if auth_request.verb.downcase == 'get'
+                        auth_request.query_parameters
+                      else
+                        URI.decode_www_form(auth_request.request_body)&.to_h
+                      end
+        scope_str = auth_params&.dig('scope')
+        scope_str ? URI.decode_www_form_component(scope_str).split : []
+      end
+
+      def create_id_token(client_id, fhir_user: false)
+        # No point in mocking an identity provider, just always use known Practitioner as the authorized user
+        suite_fhir_base_url = request.url.split(EHR_TOKEN_PATH).first + FHIR_BASE_PATH
+        id_token_hash = {
+          iss: suite_fhir_base_url,
+          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_fhir_base_url}/Practitioner/#{AUTHORIZED_PRACTITIONER_ID}") if fhir_user
+
+        JWT.encode(id_token_hash, RSA_PRIVATE_KEY, 'RS256')
+      end
+    end
+  end
+end