davinci_dtr_test_kit 0.11.1 → 0.13.0

data/lib/davinci_dtr_test_kit/dtr_light_ehr_suite.rb

@@ -1,18 +1,14 @@
+require 'tls_test_kit'
 require_relative 'version'
+require_relative 'dtr_options'
+require 'smart_app_launch/smart_stu1_suite'
+require 'smart_app_launch/smart_stu2_suite'
 
 module DaVinciDTRTestKit
   class DTRLightEHRSuite < Inferno::TestSuite
     id :dtr_light_ehr
     title 'Da Vinci DTR Light EHR Test Suite'
-    description %(
-        # Da Vinci DTR Light EHR Test Suite
-
-        This suite validates that an EMR or other application
-        can act as a data source for a DTR SMART App. Inferno
-        will act as a DTR SMART App making requests for data
-        against the system under test and storing completed
-        questionnaire responses.
-      )
+    description File.read(File.join(__dir__, 'docs', 'dtr_light_ehr_suite_description_v201.md'))
 
     version VERSION
 
@@ -35,28 +31,45 @@ module DaVinciDTRTestKit
       }
     ]
 
-    # These inputs will be available to all tests in this suite
     input :url,
-          title: 'FHIR Server Base Url'
+          title: 'FHIR Endpoint',
+          description: 'URL of the DTR FHIR server'
 
-    input :credentials,
-          title: 'OAuth Credentials',
-          type: :oauth_credentials,
-          optional: true
+    group do
+      title 'Authorization'
 
-    # All FHIR requests in this suite will use this FHIR client
-    fhir_client do
-      url :url
-      oauth_credentials :credentials
-    end
+      group from: :smart_discovery_stu2 do
+        required_suite_options DTROptions::SMART_2_REQUIREMENT
+        run_as_group
+
+        test from: :tls_version_test do
+          title 'DTR FHIR Server is secured by transport layer security'
+          description <<~DESCRIPTION
+            Under [Privacy, Security, and Safety](https://hl7.org/fhir/us/davinci-crd/STU2/security.html),
+            the DTR Implementation Guide imposes the following rule about TLS:
+            As per the [DTR Hook specification](https://cds-hooks.hl7.org/2.0/#security-and-safety),
+            communications between DTR Clients and DTR Servers SHALL
+            use TLS. Mutual TLS is not required by this specification but is permitted. DTR Servers and
+            DTR Clients SHOULD enforce a minimum version and other TLS configuration requirements based
+            on HRex rules for PHI exchange.
+            This test verifies that the FHIR server is using TLS 1.2 or higher.
+          DESCRIPTION
 
-    # Hl7 Validator Wrapper:
-    fhir_resource_validator do
-      igs 'hl7.fhir.us.davinci-dtr#2.0.1'
+          id :dtr_server_tls_version_stu2
 
-      exclude_message do |message|
-        message.message.match?(/\A\S+: \S+: URL value '.*' does not resolve/)
+          config(
+            options: { minimum_allowed_version: OpenSSL::SSL::TLS1_2_VERSION }
+          )
+        end
       end
+
+      group from: :smart_ehr_launch_stu2,
+            required_suite_options: DTROptions::SMART_2_REQUIREMENT,
+            run_as_group: true
+
+      group from: :smart_standalone_launch_stu2,
+            required_suite_options: DTROptions::SMART_2_REQUIREMENT,
+            run_as_group: true
     end
   end
 end

data/lib/davinci_dtr_test_kit/dtr_options.rb

@@ -0,0 +1,7 @@
+module DaVinciDTRTestKit
+  module DTROptions
+    SMART_2 = 'smart_app_launch_2'.freeze
+
+    SMART_2_REQUIREMENT = { smart_app_launch_version: SMART_2 }.freeze
+  end
+end

data/lib/davinci_dtr_test_kit/dtr_questionnaire_response_validation.rb

@@ -1,30 +1,78 @@
-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)
+      check_is_questionnaire_response(questionnaire_response_json)
+      assert_valid_resource(resource: FHIR.from_contents(questionnaire_response_json),
+                            profile_url: 'http://hl7.org/fhir/us/davinci-dtr/StructureDefinition/dtr-questionnaireresponse|2.0.1')
+    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
+
+    # This checks presence of all answers if link_ids is nil
+    def check_answer_presence(items, link_ids: nil)
+      items.each do |item|
+        check_answer_presence(item.item, link_ids:)
+
+        if !item.answer&.first&.value.present? && (link_ids.nil? || link_ids.include?(item.linkId))
+          add_message('error', "No answer for item #{item.linkId}")
+        end
+      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 +80,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 +132,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')
-        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')
-        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 +196,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

@@ -50,18 +50,21 @@ module DaVinciDTRTestKit
     end
 
     allow_cors QUESTIONNAIRE_PACKAGE_PATH, QUESTIONNAIRE_RESPONSE_PATH, FHIR_RESOURCE_PATH, FHIR_SEARCH_PATH,
-               EHR_AUTHORIZE_PATH, EHR_TOKEN_PATH
+               EHR_AUTHORIZE_PATH, EHR_TOKEN_PATH, JKWS_PATH, OPENID_CONFIG_PATH
 
     route(:get, '/fhir/metadata', method(:metadata_handler))
 
     route(:get, SMART_CONFIG_PATH, method(:ehr_smart_config))
+    route(:get, OPENID_CONFIG_PATH, method(:ehr_openid_config))
 
-    record_response_route :get, EHR_AUTHORIZE_PATH, 'dtr_smart_app_ehr_authorize', method(:ehr_authorize),
+    route(:get, JKWS_PATH, method(:auth_server_jwks))
+
+    record_response_route :get, EHR_AUTHORIZE_PATH, EHR_AUTHORIZE_TAG, 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),
+    record_response_route :post, EHR_AUTHORIZE_PATH, EHR_AUTHORIZE_TAG, method(:ehr_authorize),
                           resumes: ->(_) { false } do |request|
       DTRSmartAppSuite.extract_client_id_from_form_params(request)
     end

data/lib/davinci_dtr_test_kit/fixture_loader.rb

@@ -6,94 +6,16 @@ module DaVinciDTRTestKit
     include Singleton
 
     def initialize
-      # list of lists
-      # - first entry is the path to a file containing a Questionnaire Bundle (not Parameters)
-      # - second entry is the path to a file containing a Populated QuestionnaireResponse
-      #   for use in validation.
-      # - third entry is a list of group id within which this questionnaire should be used and
-      #   will be returned for any $questionnaire-package calls. This association of a questionnaire
-      #   with a specific test is Inferno's simulated version of payer business logic.
-      questionnaires_to_load =
-        [
-          [
-            'fixtures/questionnaire_package.json',
-            'fixtures/pre_populated_questionnaire_response.json',
-            ['dtr_smart_app_questionnaire_workflow', 'dtr_full_ehr_questionnaire_workflow']
-          ],
-          [
-            'fixtures/dinner_static/questionnaire_dinner_order_static.json',
-            'fixtures/dinner_static/questionnaire_response_dinner_order_static.json',
-            ['dtr_smart_app_static_dinner_questionnaire_workflow']
-          ],
-          [
-            'fixtures/dinner_adaptive/questionnaire_dinner_order_adaptive.json',
-            '',
-            ['dtr_smart_app_adaptive_dinner_questionnaire_workflow']
-          ]
-        ]
-
-      questionnaires_to_load.each do |questionnaire_details|
-        init_questionnaire_package_and_response(questionnaire_details[0], questionnaire_details[1],
-                                                questionnaire_details[2])
-      end
-    end
-
-    def canonical_to_questionnaire_package_map
-      @canonical_to_questionnaire_package_map ||= {}
+      @cache = {}
     end
 
-    def questionnaire_package_for_canonical(url)
-      @canonical_to_questionnaire_package_map[url]
-    end
-
-    def group_id_to_questionnaire_canonical_map
-      @group_id_to_questionnaire_canonical_map ||= {}
-    end
-
-    def questionnaire_canonical_for_group_id(group_id)
-      group_id_to_questionnaire_canonical_map[group_id]
-    end
-
-    def questionnaire_package_for_group_id(group_id)
-      canonical = questionnaire_canonical_for_group_id(group_id)
-      return unless canonical
-
-      @canonical_to_questionnaire_package_map[canonical]
-    end
+    def [](path)
+      return unless path.present?
 
-    def group_id_to_questionnaire_response_map
-      @group_id_to_questionnaire_response_map ||= {}
-    end
-
-    def questionnaire_response_for_group_id(group_id)
-      group_id_to_questionnaire_response_map[group_id]
-    end
-
-    def init_questionnaire_package_and_response(package_file, response_file = nil, covered_groups = nil)
-      package_json = File.read(File.join(__dir__, package_file))
-      package = FHIR.from_contents(package_json)
-      url = get_url_for_questionnaire(package)
-
-      canonical_to_questionnaire_package_map[url] = package if url
-      covered_groups&.each do |group|
-        group_id_to_questionnaire_canonical_map[group] = url
-      end
-
-      if response_file.present?
-        response_json = File.read(File.join(__dir__, response_file))
-        response = FHIR.from_contents(response_json)
-
-        covered_groups&.each do |group|
-          group_id_to_questionnaire_response_map[group] = response
-        end
-
-      end
-
-      package
-    end
+      return @cache[path] if @cache.key?(path)
 
-    def get_url_for_questionnaire(questionnaire_bundle)
-      questionnaire_bundle.entry[0].resource.url
+      fhir_instance = FHIR.from_contents(File.read(File.join(__dir__, 'fixtures', path)))
+      @cache[path] = fhir_instance
     end
   end
 end

data/lib/davinci_dtr_test_kit/fixtures.rb

@@ -2,64 +2,59 @@ require_relative 'fixture_loader'
 
 module DaVinciDTRTestKit
   module Fixtures
-    DATA_REQUIREMENT_ANSWERS = { 'RAD Prepopulation' => '3.1' }.freeze
-
-    def get_questionnaire_package_for_group_id(group_id)
-      FixtureLoader.instance.questionnaire_package_for_group_id(group_id)
+    # Ideally the groups and/or tests would define which fixtures they use and this module would simply be a provider
+    # of whatever fixture is requested. But the MockPayer needs to determine which questionnaire package belongs to
+    # each group, so this is a straighforward way to facilitate that.
+    FIXTURE_CONFIG = [
+      {
+        group_ids: [
+          'dtr_smart_app_questionnaire_workflow',
+          'dtr_full_ehr_questionnaire_workflow'
+        ],
+        questionnaire_package: File.join('respiratory_assist_device', 'questionnaire_package.json'),
+        questionnaire_response: File.join('respiratory_assist_device', 'pre_populated_questionnaire_response.json')
+      },
+      {
+        group_ids: [
+          'dtr_smart_app_static_dinner_questionnaire_workflow',
+          'dtr_full_ehr_static_dinner_questionnaire_workflow'
+        ],
+        questionnaire_package: File.join('dinner_static', 'questionnaire_dinner_order_static.json'),
+        questionnaire_response: File.join('dinner_static', 'questionnaire_response_dinner_order_static.json')
+      }
+    ].freeze
+
+    extend self
+
+    # full_test_id needs to be the long inferno-generated ID that includes hyphenated ancestor IDs
+    def questionnaire_package_for_test(full_test_id)
+      get_fixture(full_test_id, :questionnaire_package)
     end
 
-    def find_questionnaire_instance_for_test_id(test_id)
-      canonical_url = find_questionnaire_canonical_for_test_id(test_id)
-      return unless canonical_url.present?
-
-      package = get_questionnaire_packcage_for_canonical(canonical_url)
-      return unless package.present?
-
-      questionnaire = nil
-      package.entry.find do |entry|
-        questionnaire = entry.resource if entry.resource.is_a?(FHIR::Questionnaire)
-      end
-      questionnaire
+    # full_test_id needs to be the long inferno-generated ID that includes hyphenated ancestor IDs
+    def questionnaire_response_for_test(full_test_id)
+      get_fixture(full_test_id, :questionnaire_response)
     end
 
-    def find_questionnaire_canonical_for_test_id(test_id)
-      canonical_url = nil
-
-      # test_id is of the form [suite id]-[group id 1]-...-[group id n]-[test id]
-      groups = test_id.split('-')[1..-2] # first is suite, last is test, we want groups
-      groups.each do |one_group_id|
-        next if canonical_url.present?
-
-        canonical_url = get_questionnaire_canonical_for_group_id(one_group_id)
-      end
-
-      canonical_url
+    # full_test_id needs to be the long inferno-generated ID that includes hyphenated ancestor IDs
+    def questionnaire_for_test(full_test_id)
+      questionnaire_package_for_test(full_test_id)&.entry&.find { |e| e.resource.is_a?(FHIR::Questionnaire) }&.resource
     end
 
-    def get_questionnaire_canonical_for_group_id(group_id)
-      FixtureLoader.instance.questionnaire_canonical_for_group_id(group_id)
-    end
-
-    def get_questionnaire_packcage_for_canonical(url)
-      FixtureLoader.instance.questionnaire_package_for_canonical(url)
-    end
-
-    def find_questionnaire_response_for_test_id(test_id)
-      questionnaire_response = nil
-
-      # test_id is of the form [suite id]-[group id 1]-...-[group id n]-[test id]
-      groups = test_id.split('-')[1..-2] # first is suite, last is test, we want groups
-      groups.each do |one_group_id|
-        next if questionnaire_response.present?
+    private
 
-        questionnaire_response = get_questionnaire_response_for_group_id(one_group_id)
-      end
+    def get_fixture(full_test_id, fixture_type)
+      fixture_path = extract_group_ids(full_test_id).filter_map do |group_id|
+        FIXTURE_CONFIG.find { |fc| fc[:group_ids].include?(group_id) }&.dig(fixture_type)
+      end&.first
 
-      questionnaire_response
+      FixtureLoader.instance[fixture_path]
     end
 
-    def get_questionnaire_response_for_group_id(group_id)
-      FixtureLoader.instance.questionnaire_response_for_group_id(group_id)
+    # full_test_id is of the form [suite id]-[group id 1]-...-[group id n]-[test id]
+    def extract_group_ids(full_test_id)
+      # First is suite, last is test, we want groups
+      full_test_id.split('-')[1...-1]&.reverse
     end
   end
 end