au_core_test_kit 0.0.16

data/lib/au_core_test_kit/date_search_validation.rb

@@ -0,0 +1,114 @@
+# frozen_string_literal: true
+
+module AUCoreTestKit
+  module DateSearchValidation
+    def get_fhir_datetime_range(datetime)
+      range = { start: DateTime.xmlschema(datetime), end: nil }
+      range[:end] =
+        case datetime
+        when /^\d{4}$/ # YYYY
+          range[:start].next_year - 1.seconds
+        when /^\d{4}-\d{2}$/ # YYYY-MM
+          range[:start].next_month - 1.seconds
+        when /^\d{4}-\d{2}-\d{2}$/ # YYYY-MM-DD
+          range[:start].next_day - 1.seconds
+        else # YYYY-MM-DDThh:mm:ss+zz:zz
+          range[:start]
+        end
+      range
+    end
+
+    def get_fhir_period_range(period)
+      range = { start: nil, end: nil }
+      range[:start] = DateTime.xmlschema(period.start) unless period.start.nil?
+      return range if period.end.nil?
+
+      period_end_beginning = DateTime.xmlschema(period.end)
+      range[:end] =
+        case period.end
+        when /^\d{4}$/ # YYYY
+          period_end_beginning.next_year - 1.seconds
+        when /^\d{4}-\d{2}$/ # YYYY-MM
+          period_end_beginning.next_month - 1.seconds
+        when /^\d{4}-\d{2}-\d{2}$/ # YYYY-MM-DD
+          period_end_beginning.next_day - 1.seconds
+        else # YYYY-MM-DDThh:mm:ss+zz:zz
+          period_end_beginning
+        end
+      range
+    end
+
+    def fhir_date_comparer(search_range, target_range, comparator, extend_start = false, extend_end = false)
+      # Implicitly, a missing lower boundary is "less than" any actual date. A missing upper boundary is "greater than" any actual date.
+      case comparator
+      when 'eq' # the range of the search value fully contains the range of the target value
+        !target_range[:start].nil? && !target_range[:end].nil? && search_range[:start] <= target_range[:start] && search_range[:end] >= target_range[:end]
+      when 'ne' # the range of the search value does not fully contain the range of the target value
+        target_range[:start].nil? || target_range[:end].nil? || search_range[:start] > target_range[:start] || search_range[:end] < target_range[:end]
+      when 'gt' #  the range above the search value intersects (i.e. overlaps) with the range of the target value
+        target_range[:end].nil? || search_range[:end] < target_range[:end] || (search_range[:end] < (target_range[:end] + 1) && extend_end)
+      when 'lt' # the range below the search value intersects (i.e. overlaps) with the range of the target value
+        target_range[:start].nil? || search_range[:start] > target_range[:start] || (search_range[:start] > (target_range[:start] - 1) && extend_start)
+      when 'ge'
+        fhir_date_comparer(search_range, target_range, 'gt', extend_start,
+                           extend_end) || fhir_date_comparer(search_range, target_range, 'eq')
+      when 'le'
+        fhir_date_comparer(search_range, target_range, 'lt', extend_start,
+                           extend_end) || fhir_date_comparer(search_range, target_range, 'eq')
+      when 'sa' # the range above the search value contains the range of the target value
+        !target_range[:start].nil? && search_range[:end] < target_range[:start]
+      when 'eb' # the range below the search value contains the range of the target value
+        !target_range[:end].nil? && search_range[:start] > target_range[:end]
+      when 'ap' # the range of the search value overlaps with the range of the target value
+        if target_range[:start].nil? || target_range[:end].nil?
+          (target_range[:start].nil? && search_range[:start] < target_range[:end]) ||
+            (target_range[:end].nil? && search_range[:end] > target_range[:start])
+        else
+          (search_range[:start] >= target_range[:start] && search_range[:start] <= target_range[:end]) ||
+            (search_range[:end] >= target_range[:start] && search_range[:end] <= target_range[:end])
+        end
+      end
+    end
+
+    def validate_date_search(search_value, target_value)
+      if target_value.instance_of? FHIR::Period
+        validate_period_search(search_value, target_value)
+      else
+        validate_datetime_search(search_value, target_value)
+      end
+    end
+
+    def validate_datetime_search(search_value, target_value)
+      comparator = search_value[0..1]
+      if %w[eq ge gt le lt ne sa eb ap].include? comparator
+        search_value = search_value[2..]
+      else
+        comparator = 'eq'
+      end
+      search_is_date = is_date?(search_value)
+      target_is_date = is_date?(target_value)
+      search_range = get_fhir_datetime_range(search_value)
+      target_range = get_fhir_datetime_range(target_value)
+      fhir_date_comparer(search_range, target_range, comparator, !search_is_date && target_is_date,
+                         !search_is_date && target_is_date)
+    end
+
+    def validate_period_search(search_value, target_value)
+      comparator = search_value[0..1]
+      if %w[eq ge gt le lt ne sa eb ap].include? comparator
+        search_value = search_value[2..]
+      else
+        comparator = 'eq'
+      end
+      search_is_date = is_date?(search_value)
+      search_range = get_fhir_datetime_range(search_value)
+      target_range = get_fhir_period_range(target_value)
+      fhir_date_comparer(search_range, target_range, comparator, !search_is_date && is_date?(target_value.start),
+                         !search_is_date && is_date?(target_value.end))
+    end
+
+    def is_date?(value)
+      /^\d{4}(-\d{2})?(-\d{2})?$/.match?(value) # YYYY or YYYY-MM or YYYY-MM-DD
+    end
+  end
+end

data/lib/au_core_test_kit/fhir_resource_navigation.rb

@@ -0,0 +1,177 @@
+# frozen_string_literal: true
+
+module AUCoreTestKit
+  module FHIRResourceNavigation
+    DAR_EXTENSION_URL = 'http://hl7.org/fhir/StructureDefinition/data-absent-reason'
+
+    def resolve_path(elements, path)
+      elements = Array.wrap(elements)
+      return elements if path.blank?
+
+      paths = path.split(/(?<!hl7)\./)
+      segment = paths.first
+      remaining_path = paths.drop(1).join('.')
+
+      elements.flat_map do |element|
+        child = get_next_value(element, segment)
+        resolve_path(child, remaining_path)
+      end.compact
+    end
+
+    def is_extension?(str)
+      !!str.match(%r{extension\('https?://[^\s]+?\)\.value})
+    end
+
+    def get_extension_url(str)
+      match = str.match(/extension\('([^']+)'\)\.value/)
+      match ? match[1] : nil
+    end
+
+    def get_value_from_extension(element, extension_url)
+      extension_elements = element.extension.filter { |ext| ext.url == extension_url }
+      return nil unless extension_elements.length.positive?
+
+      extension_element = extension_elements.first
+      case extension_url
+      when 'http://hl7.org.au/fhir/StructureDefinition/indigenous-status'
+        extension_element.valueCoding
+      when 'http://hl7.org/fhir/StructureDefinition/individual-genderIdentity'
+        extension_element.extension.first.valueCodeableConcept
+      else
+        extension_element.valueCoding
+      end
+    end
+
+    def find_a_value_at(element, path, include_dar: false, &block)
+      return nil if element.nil?
+
+      return get_value_from_extension(element, get_extension_url(path)) if is_extension?(path)
+
+      elements = Array.wrap(element)
+      if path.empty?
+        unless include_dar
+          elements = elements.reject do |el|
+            el.respond_to?(:extension) && el.extension.any? { |ext| ext.url == DAR_EXTENSION_URL }
+          end
+        end
+
+        return elements.find(&block) if block_given?
+
+        return elements.first
+      end
+
+      path_segments = path.split(/(?<!hl7)\./)
+
+      segment = path_segments.shift.delete_suffix('[x]').gsub(/^class$/, 'local_class').gsub(/\[x\]:/, ':').to_sym
+      no_elements_present =
+        elements.none? do |element|
+          child = get_next_value(element, segment)
+          child.present? || child == false
+        end
+      return nil if no_elements_present
+
+      remaining_path = path_segments.join('.')
+      elements.each do |element|
+        child = get_next_value(element, segment)
+        element_found =
+          if block_given?
+            find_a_value_at(child, remaining_path, include_dar:, &block)
+          else
+            find_a_value_at(child, remaining_path, include_dar:)
+          end
+        return element_found if element_found.present? || element_found == false
+      end
+
+      nil
+    end
+
+    def get_next_value(element, property)
+      extension_url = property[/(?<=where\(url=').*(?='\))/]
+      if extension_url.present?
+        element.url == extension_url ? element : nil
+      elsif property.to_s.include?(':') && !property.to_s.include?('url')
+        find_slice_via_discriminator(element, property)
+
+      else
+        element.send(property)
+      end
+    rescue NoMethodError
+      nil
+    end
+
+    def find_slice_via_discriminator(element, property)
+      element_name = property.to_s.split(':')[0].gsub(/^class$/, 'local_class')
+      slice_name = property.to_s.split(':')[1].gsub(/^class$/, 'local_class')
+      if metadata.present?
+        slice_by_name = metadata.must_supports[:slices].find { |slice| slice[:slice_name] == slice_name }
+        discriminator = slice_by_name[:discriminator]
+        slices = Array.wrap(element.send(element_name))
+        slices.find do |slice|
+          case discriminator[:type]
+          when 'patternCodeableConcept'
+            slice_value = discriminator[:path].present? ? slice.send((discriminator[:path]).to_s).coding : slice.coding
+            slice_value.any? { |coding| coding.code == discriminator[:code] && coding.system == discriminator[:system] }
+          when 'patternCoding'
+            slice_value = discriminator[:path].present? ? slice.send(discriminator[:path]) : slice
+            slice_value.code == discriminator[:code] && slice_value.system == discriminator[:system]
+          when 'patternIdentifier'
+            slice.identifier.system == discriminator[:system]
+          when 'value'
+            values = discriminator[:values].map { |value| value.merge(path: value[:path].split('.')) }
+            verify_slice_by_values(slice, values)
+          when 'type'
+            case discriminator[:code]
+            when 'Date'
+              begin
+                Date.parse(slice)
+              rescue ArgumentError
+                false
+              end
+            when 'DateTime'
+              begin
+                DateTime.parse(slice)
+              rescue ArgumentError
+                false
+              end
+            when 'String'
+              slice.is_a? String
+            else
+              slice.is_a? FHIR.const_get(discriminator[:code])
+            end
+          when 'requiredBinding'
+            discriminator[:path].present? ? slice.send((discriminator[:path]).to_s).coding : slice.coding
+            slice_value { |coding| discriminator[:values].include?(coding.code) }
+          end
+        end
+      else
+        # TODO: Error handling for if this file doesn't have access to metadata for some reason (begin/rescue with StandardError?)
+      end
+    end
+
+    def verify_slice_by_values(element, value_definitions)
+      path_prefixes = value_definitions.map { |value_definition| value_definition[:path].first }.uniq
+      path_prefixes.all? do |path_prefix|
+        value_definitions_for_path =
+          value_definitions
+          .select { |value_definition| value_definition[:path].first == path_prefix }
+          .each { |value_definition| value_definition[:path].shift }
+        find_a_value_at(element, path_prefix) do |el_found|
+          child_element_value_definitions, current_element_value_definitions =
+            value_definitions_for_path.partition { |value_definition| value_definition[:path].present? }
+
+          current_element_values_match =
+            current_element_value_definitions
+            .all? { |value_definition| value_definition[:value] == el_found }
+
+          child_element_values_match =
+            if child_element_value_definitions.present?
+              verify_slice_by_values(el_found, child_element_value_definitions)
+            else
+              true
+            end
+          current_element_values_match && child_element_values_match
+        end
+      end
+    end
+  end
+end

data/lib/au_core_test_kit/generated/v1.0.0-preview/allergy_intolerance/allergy_intolerance_clinical_status_search_test.rb

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+require_relative '../../../search_test'
+require_relative '../../../generator/group_metadata'
+require_relative '../../../helpers'
+
+module AUCoreTestKit
+  module AUCoreV100_PREVIEW
+    class AllergyIntoleranceClinicalStatusSearchTest < Inferno::Test
+      include AUCoreTestKit::SearchTest
+
+      title '(MAY) Server returns valid results for AllergyIntolerance search by clinical-status'
+      description %(
+A server MAY support searching by
+clinical-status on the AllergyIntolerance resource. This test
+will pass if resources are returned and match the search criteria. If
+none are returned, the test is skipped.
+
+[AU Core Server CapabilityStatement](http://hl7.org.au/fhir/core//CapabilityStatement-au-core-server.html)
+
+      )
+
+      id :au_core_v100_preview_allergy_intolerance_clinical_status_search_test
+      optional
+
+      def self.properties
+        @properties ||= SearchTestProperties.new(
+          resource_type: 'AllergyIntolerance',
+          search_param_names: ['clinical-status'],
+          token_search_params: ['clinical-status']
+        )
+      end
+
+      def self.metadata
+        @metadata ||= Generator::GroupMetadata.new(YAML.load_file(File.join(__dir__, 'metadata.yml'), aliases: true))
+      end
+
+      def scratch_resources
+        scratch[:allergy_intolerance_resources] ||= {}
+      end
+
+      run do
+        run_search_test
+      end
+    end
+  end
+end

data/lib/au_core_test_kit/generated/v1.0.0-preview/allergy_intolerance/allergy_intolerance_must_support_test.rb

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+require_relative '../../../must_support_test'
+
+module AUCoreTestKit
+  module AUCoreV100_PREVIEW
+    class AllergyIntoleranceMustSupportTest < Inferno::Test
+      include AUCoreTestKit::MustSupportTest
+
+      title 'All must support elements are provided in the AllergyIntolerance resources returned'
+      description %(
+        AU Core Responders SHALL be capable of populating all data elements as
+        part of the query results as specified by the AU Core Server Capability
+        Statement. This test will look through the AllergyIntolerance resources
+        found previously for the following must support elements:
+
+        * AllergyIntolerance.clinicalStatus
+        * AllergyIntolerance.code
+        * AllergyIntolerance.onset[x]
+        * AllergyIntolerance.patient
+        * AllergyIntolerance.reaction
+        * AllergyIntolerance.reaction.manifestation
+        * AllergyIntolerance.reaction.severity
+        * AllergyIntolerance.verificationStatus
+      )
+
+      id :au_core_v100_preview_allergy_intolerance_must_support_test
+
+      def resource_type
+        'AllergyIntolerance'
+      end
+
+      def self.metadata
+        @metadata ||= Generator::GroupMetadata.new(YAML.load_file(File.join(__dir__, 'metadata.yml'), aliases: true))
+      end
+
+      def scratch_resources
+        scratch[:allergy_intolerance_resources] ||= {}
+      end
+
+      run do
+        perform_must_support_test(all_scratch_resources)
+      end
+    end
+  end
+end

data/lib/au_core_test_kit/generated/v1.0.0-preview/allergy_intolerance/allergy_intolerance_patient_chain_search_test.rb

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+
+require_relative '../../../chained_search_test'
+require_relative '../../../generator/group_metadata'
+require_relative '../../../helpers'
+
+module AUCoreTestKit
+  module AUCoreV100_PREVIEW
+    class AllergyIntolerancePatientChainSearchTest < Inferno::Test
+      include AUCoreTestKit::ChainedSearchTest
+
+      title '(SHOULD) Server returns valid results for AllergyIntolerance search by patient (chained parameters)'
+      description %(A server SHOULD support searching by
+patient:Patient.identifier on the AllergyIntolerance resource. This test
+will pass if the server returns a success response to the request.
+
+[AU Core Server CapabilityStatement](http://hl7.org.au/fhir/core//CapabilityStatement-au-core-server.html)
+)
+
+      id :au_core_v100_preview_allergy_intolerance_patient_chain_search_test
+
+      optional
+
+      input :patient_ids,
+            title: 'Patient IDs',
+            description: 'Comma separated list of patient IDs that in sum contain all MUST SUPPORT elements',
+            default: 'baratz-toni, irvine-ronny-lawrence, italia-sofia, howe-deangelo, hayes-arianne, baby-banks-john, banks-mia-leanne'
+
+      def self.properties
+        @properties ||= SearchTestProperties.new(
+          resource_type: 'AllergyIntolerance',
+          search_param_names: ['patient:Patient.identifier'],
+          attr_paths: ['patient']
+        )
+      end
+
+      def self.metadata
+        @metadata ||= Generator::GroupMetadata.new(YAML.load_file(File.join(__dir__, 'metadata.yml'), aliases: true))
+      end
+
+      def scratch_resources
+        scratch[:allergy_intolerance_resources] ||= {}
+      end
+
+      run do
+        run_chain_search_test
+      end
+    end
+  end
+end

data/lib/au_core_test_kit/generated/v1.0.0-preview/allergy_intolerance/allergy_intolerance_patient_clinical_status_search_test.rb

@@ -0,0 +1,52 @@
+# frozen_string_literal: true
+
+require_relative '../../../search_test'
+require_relative '../../../generator/group_metadata'
+require_relative '../../../helpers'
+
+module AUCoreTestKit
+  module AUCoreV100_PREVIEW
+    class AllergyIntolerancePatientClinicalStatusSearchTest < Inferno::Test
+      include AUCoreTestKit::SearchTest
+
+      title '(SHOULD) Server returns valid results for AllergyIntolerance search by patient + clinical-status'
+      description %(
+A server SHOULD support searching by
+patient + clinical-status on the AllergyIntolerance resource. This test
+will pass if resources are returned and match the search criteria. If
+none are returned, the test is skipped.
+
+[AU Core Server CapabilityStatement](http://hl7.org.au/fhir/core//CapabilityStatement-au-core-server.html)
+
+      )
+
+      id :au_core_v100_preview_allergy_intolerance_patient_clinical_status_search_test
+      optional
+
+      input :patient_ids,
+            title: 'Patient IDs',
+            description: 'Comma separated list of patient IDs that in sum contain all MUST SUPPORT elements',
+            default: 'baratz-toni, irvine-ronny-lawrence, italia-sofia, howe-deangelo, hayes-arianne, baby-banks-john, banks-mia-leanne'
+
+      def self.properties
+        @properties ||= SearchTestProperties.new(
+          resource_type: 'AllergyIntolerance',
+          search_param_names: %w[patient clinical-status],
+          token_search_params: ['clinical-status']
+        )
+      end
+
+      def self.metadata
+        @metadata ||= Generator::GroupMetadata.new(YAML.load_file(File.join(__dir__, 'metadata.yml'), aliases: true))
+      end
+
+      def scratch_resources
+        scratch[:allergy_intolerance_resources] ||= {}
+      end
+
+      run do
+        run_search_test
+      end
+    end
+  end
+end

data/lib/au_core_test_kit/generated/v1.0.0-preview/allergy_intolerance/allergy_intolerance_patient_dva_chain_search_test.rb

@@ -0,0 +1,51 @@
+# frozen_string_literal: true
+
+require_relative '../../../chained_search_test'
+require_relative '../../../generator/group_metadata'
+require_relative '../../../helpers'
+
+module AUCoreTestKit
+  module AUCoreV100_PREVIEW
+    class AllergyIntolerancePatient_DVA_ChainSearchTest < Inferno::Test
+      include AUCoreTestKit::ChainedSearchTest
+
+      title '(SHOULD) Server returns valid results for AllergyIntolerance search by patient (DVA) (chained parameters)'
+      description %(A server SHOULD support searching by
+patient:Patient.identifier (DVA) on the AllergyIntolerance resource. This test
+will pass if the server returns a success response to the request.
+
+[AU Core Server CapabilityStatement](http://hl7.org.au/fhir/core//CapabilityStatement-au-core-server.html)
+)
+
+      id :au_core_v100_preview_allergy_intolerance_patient_dva_chain_search_test
+
+      optional
+
+      input :patient_ids,
+            title: 'Patient IDs',
+            description: 'Comma separated list of patient IDs that in sum contain all MUST SUPPORT elements',
+            default: 'baratz-toni, irvine-ronny-lawrence, italia-sofia, howe-deangelo, hayes-arianne, baby-banks-john, banks-mia-leanne'
+
+      def self.properties
+        @properties ||= SearchTestProperties.new(
+          resource_type: 'AllergyIntolerance',
+          search_param_names: ['patient:Patient.identifier'],
+          attr_paths: ['patient'],
+          target_identifier: { display: 'DVA', url: 'http://ns.electronichealth.net.au/id/dva' }
+        )
+      end
+
+      def self.metadata
+        @metadata ||= Generator::GroupMetadata.new(YAML.load_file(File.join(__dir__, 'metadata.yml'), aliases: true))
+      end
+
+      def scratch_resources
+        scratch[:allergy_intolerance_resources] ||= {}
+      end
+
+      run do
+        run_chain_search_test
+      end
+    end
+  end
+end

data/lib/au_core_test_kit/generated/v1.0.0-preview/allergy_intolerance/allergy_intolerance_patient_ihi_chain_search_test.rb

@@ -0,0 +1,51 @@
+# frozen_string_literal: true
+
+require_relative '../../../chained_search_test'
+require_relative '../../../generator/group_metadata'
+require_relative '../../../helpers'
+
+module AUCoreTestKit
+  module AUCoreV100_PREVIEW
+    class AllergyIntolerancePatient_IHI_ChainSearchTest < Inferno::Test
+      include AUCoreTestKit::ChainedSearchTest
+
+      title '(SHOULD) Server returns valid results for AllergyIntolerance search by patient (IHI) (chained parameters)'
+      description %(A server SHOULD support searching by
+patient:Patient.identifier (IHI) on the AllergyIntolerance resource. This test
+will pass if the server returns a success response to the request.
+
+[AU Core Server CapabilityStatement](http://hl7.org.au/fhir/core//CapabilityStatement-au-core-server.html)
+)
+
+      id :au_core_v100_preview_allergy_intolerance_patient_ihi_chain_search_test
+
+      optional
+
+      input :patient_ids,
+            title: 'Patient IDs',
+            description: 'Comma separated list of patient IDs that in sum contain all MUST SUPPORT elements',
+            default: 'baratz-toni, irvine-ronny-lawrence, italia-sofia, howe-deangelo, hayes-arianne, baby-banks-john, banks-mia-leanne'
+
+      def self.properties
+        @properties ||= SearchTestProperties.new(
+          resource_type: 'AllergyIntolerance',
+          search_param_names: ['patient:Patient.identifier'],
+          attr_paths: ['patient'],
+          target_identifier: { display: 'IHI', url: 'http://ns.electronichealth.net.au/id/hi/ihi/1.0' }
+        )
+      end
+
+      def self.metadata
+        @metadata ||= Generator::GroupMetadata.new(YAML.load_file(File.join(__dir__, 'metadata.yml'), aliases: true))
+      end
+
+      def scratch_resources
+        scratch[:allergy_intolerance_resources] ||= {}
+      end
+
+      run do
+        run_chain_search_test
+      end
+    end
+  end
+end

data/lib/au_core_test_kit/generated/v1.0.0-preview/allergy_intolerance/allergy_intolerance_patient_medicare_chain_search_test.rb

@@ -0,0 +1,51 @@
+# frozen_string_literal: true
+
+require_relative '../../../chained_search_test'
+require_relative '../../../generator/group_metadata'
+require_relative '../../../helpers'
+
+module AUCoreTestKit
+  module AUCoreV100_PREVIEW
+    class AllergyIntolerancePatient_Medicare_ChainSearchTest < Inferno::Test
+      include AUCoreTestKit::ChainedSearchTest
+
+      title '(SHOULD) Server returns valid results for AllergyIntolerance search by patient (Medicare) (chained parameters)'
+      description %(A server SHOULD support searching by
+patient:Patient.identifier (Medicare) on the AllergyIntolerance resource. This test
+will pass if the server returns a success response to the request.
+
+[AU Core Server CapabilityStatement](http://hl7.org.au/fhir/core//CapabilityStatement-au-core-server.html)
+)
+
+      id :au_core_v100_preview_allergy_intolerance_patient_medicare_chain_search_test
+
+      optional
+
+      input :patient_ids,
+            title: 'Patient IDs',
+            description: 'Comma separated list of patient IDs that in sum contain all MUST SUPPORT elements',
+            default: 'baratz-toni, irvine-ronny-lawrence, italia-sofia, howe-deangelo, hayes-arianne, baby-banks-john, banks-mia-leanne'
+
+      def self.properties
+        @properties ||= SearchTestProperties.new(
+          resource_type: 'AllergyIntolerance',
+          search_param_names: ['patient:Patient.identifier'],
+          attr_paths: ['patient'],
+          target_identifier: { display: 'Medicare', url: 'http://ns.electronichealth.net.au/id/medicare-number' }
+        )
+      end
+
+      def self.metadata
+        @metadata ||= Generator::GroupMetadata.new(YAML.load_file(File.join(__dir__, 'metadata.yml'), aliases: true))
+      end
+
+      def scratch_resources
+        scratch[:allergy_intolerance_resources] ||= {}
+      end
+
+      run do
+        run_chain_search_test
+      end
+    end
+  end
+end