au_core_test_kit 0.0.16

data/lib/au_core_test_kit/generator/multiple_or_search_test_generator.rb

@@ -0,0 +1,219 @@
+# frozen_string_literal: true
+
+require_relative 'naming'
+require_relative 'special_cases'
+require_relative '../helpers'
+
+module AUCoreTestKit
+  class Generator
+    class MultipleOrSearchTestGenerator
+      class << self
+        def generate(ig_metadata, base_output_dir)
+          ig_metadata.groups
+                     .select { |group| group.searches.present? }
+                     .each do |group|
+            group.search_definitions.each_key do |search_key|
+              new(search_key.to_s, group, group.search_definitions[search_key], base_output_dir).generate if group.search_definitions[search_key].key?(:multiple_or) && search_key.to_s != 'patient'
+            end
+          end
+        end
+      end
+
+      attr_accessor :search_name, :group_metadata, :search_metadata, :base_output_dir
+
+      def initialize(search_name, group_metadata, search_metadata, base_output_dir)
+        self.search_name = search_name
+        self.group_metadata = group_metadata
+        self.search_metadata = search_metadata
+        self.base_output_dir = base_output_dir
+      end
+
+      def template
+        @template ||= File.read(File.join(__dir__, 'templates', 'multiple_or_search.rb.erb'))
+      end
+
+      def output
+        @output ||= ERB.new(template).result(binding)
+      end
+
+      def base_output_file_name
+        "#{class_name.underscore}.rb"
+      end
+
+      def output_file_directory
+        File.join(base_output_dir, profile_identifier)
+      end
+
+      def output_file_name
+        File.join(output_file_directory, base_output_file_name)
+      end
+
+      def profile_identifier
+        Naming.snake_case_for_profile(group_metadata)
+      end
+
+      def test_id
+        "au_core_#{group_metadata.reformatted_version}_#{profile_identifier}_#{search_identifier}_multiple_or_search_test"
+      end
+
+      def search_identifier
+        search_name.to_s.tr('-', '_')
+      end
+
+      def search_title
+        search_identifier
+      end
+
+      def class_name
+        "#{Naming.upper_camel_case_for_profile(group_metadata)}#{search_title.capitalize}MultipleOrSearchTest"
+      end
+
+      def module_name
+        "AUCore#{group_metadata.reformatted_version.upcase}"
+      end
+
+      def resource_type
+        group_metadata.resource
+      end
+
+      def conformance_expectation
+        # NOTE: https://github.com/hl7au/au-fhir-core-inferno/issues/61
+        return 'SHOULD' if search_name == 'status' && (resource_type == 'Procedure' || resource_type == 'Observation')
+
+        search_metadata[:multiple_or]
+      end
+
+      def first_search?
+        group_metadata.searches.first == search_metadata
+      end
+
+      def fixed_value_search?
+        first_search? && search_metadata[:names] != ['patient'] &&
+          !group_metadata.delayed? && resource_type != 'Patient'
+      end
+
+      def fixed_value_search_param_name
+        (search_metadata[:names] - [:patient]).first
+      end
+
+      def search_param_name_string
+        search_name
+      end
+
+      def needs_patient_id?
+        true
+      end
+
+      def search_param_names
+        [search_name]
+      end
+
+      def search_param_names_array
+        array_of_strings(search_param_names)
+      end
+
+      def path_for_value(path)
+        path == 'class' ? 'local_class' : path
+      end
+
+      def optional?
+        conformance_expectation == 'SHOULD' || conformance_expectation == 'MAY'
+      end
+
+      def search_definition(name)
+        group_metadata.search_definitions[name.to_sym]
+      end
+
+      def saves_delayed_references?
+        first_search? && group_metadata.delayed_references.present?
+      end
+
+      def required_multiple_or_search_params
+        @required_multiple_or_search_params ||=
+          search_definition(search_name)[:multiple_or] == 'SHALL'
+      end
+
+      def optional_multiple_or_search_params
+        @optional_multiple_or_search_params ||=
+          search_definition(search_name)[:multiple_or] == 'SHOULD'
+      end
+
+      def required_multiple_or_search_params_string
+        required_multiple_or_search_params
+      end
+
+      def optional_multiple_or_search_params_string
+        optional_multiple_or_search_params
+      end
+
+      def required_comparators_string
+        array_of_strings(required_comparators.keys)
+      end
+
+      def array_of_strings(array)
+        quoted_strings = array.map { |element| "'#{element}'" }
+        "[#{quoted_strings.join(', ')}]"
+      end
+
+      def test_reference_variants?
+        first_search? && search_param_names.include?('patient')
+      end
+
+      def test_medication_inclusion?
+        %w[MedicationRequest MedicationDispense].include?(resource_type)
+      end
+
+      def test_post_search?
+        first_search?
+      end
+
+      def search_properties
+        {}.tap do |properties|
+          properties[:first_search] = 'true' if first_search?
+          properties[:fixed_value_search] = 'true' if fixed_value_search?
+          properties[:resource_type] = "'#{resource_type}'"
+          properties[:search_param_names] = search_param_names
+          properties[:saves_delayed_references] = 'true' if saves_delayed_references?
+          properties[:test_medication_inclusion] = 'true' if test_medication_inclusion?
+          properties[:test_reference_variants] = 'true' if test_reference_variants?
+          if required_multiple_or_search_params.present?
+            properties[:multiple_or_search_params] =
+              required_multiple_or_search_params_string
+          end
+          properties[:optional_multiple_or_search_params] = optional_multiple_or_search_params_string if optional_multiple_or_search_params.present?
+          properties[:search_by_target_resource_data] = 'true' if Helpers.test_on_target_resource_data?(
+            SpecialCases.multiple_or_and_search_by_target_resource,
+            resource_type, search_param_names
+          )
+        end
+      end
+
+      def url_version
+        case group_metadata.version
+        when 'v0.3.0-ballot'
+          '0.3.0-ballot'
+        end
+      end
+
+      def search_test_properties_string
+        search_properties
+          .map { |key, value| "#{' ' * 8}#{key}: #{value}" }
+          .join(",\n")
+      end
+
+      def generate
+        FileUtils.mkdir_p(output_file_directory)
+        File.open(output_file_name, 'w') { |f| f.write(output) }
+
+        group_metadata.add_test(
+          id: test_id,
+          file_name: base_output_file_name
+        )
+      end
+
+      def description
+        Helpers.multiple_test_description('OR', conformance_expectation, search_param_name_string, resource_type, url_version)
+      end
+    end
+  end
+end

data/lib/au_core_test_kit/generator/must_support_metadata_extractor.rb

@@ -0,0 +1,472 @@
+# frozen_string_literal: true
+
+require_relative 'value_extractor'
+require_relative 'must_support_metadata_extractor_au_core_3'
+
+module AUCoreTestKit
+  class Generator
+    class MustSupportMetadataExtractor
+      attr_accessor :profile_elements, :profile, :resource, :ig_resources
+
+      def initialize(profile_elements, profile, resource, ig_resources)
+        self.profile_elements = profile_elements
+        self.profile = profile
+        self.resource = resource
+        self.ig_resources = ig_resources
+      end
+
+      def must_supports
+        @must_supports = {
+          extensions: must_support_extensions,
+          slices: must_support_slices,
+          elements: must_support_elements
+        }
+
+        handle_special_cases
+
+        @must_supports
+      end
+
+      def is_uscdi_requirement_element?(_element)
+        # TODO: Temporary fix
+        false
+      end
+
+      def all_must_support_elements
+        profile_elements.select { |element| element.mustSupport || is_uscdi_requirement_element?(element) }
+      end
+
+      def must_support_extension_elements
+        all_must_support_elements.select { |element| element.path.end_with? 'extension' }
+      end
+
+      def must_support_extensions
+        must_support_extension_elements.map do |element|
+          {
+            id: element.id,
+            url: element.type.first.profile.first
+          }.tap do |metadata|
+            metadata[:uscdi_only] = true if is_uscdi_requirement_element?(element)
+          end
+        end
+      end
+
+      def must_support_slice_elements
+        all_must_support_elements.select do |element|
+          !element.path.end_with?('extension') && element.sliceName.present?
+        end
+      end
+
+      def sliced_element(slice)
+        profile_elements.find do |element|
+          element.id == slice.path || element.id == slice.id.sub(":#{slice.sliceName}", '')
+        end
+      end
+
+      def discriminators(slice)
+        slice.slicing.discriminator
+      end
+
+      def must_support_pattern_slice_elements
+        must_support_slice_elements.select do |element|
+          discriminators(sliced_element(element)).first.type == 'pattern'
+        end
+      end
+
+      def pattern_slices
+        must_support_pattern_slice_elements.map do |current_element|
+          next if current_element.id.include? ':'
+
+          {
+            slice_id: current_element.id,
+            slice_name: current_element.sliceName,
+            path: current_element.path.gsub("#{resource}.", '')
+          }.tap do |metadata|
+            discriminator = discriminators(sliced_element(current_element)).first
+            discriminator_path = discriminator.path
+            discriminator_path = '' if discriminator_path == '$this'
+            pattern_element =
+              if discriminator_path.present?
+                profile_elements.find { |element| element.id == "#{current_element.id}.#{discriminator_path}" }
+              else
+                current_element
+              end
+            metadata[:discriminator] =
+              if pattern_element.patternCodeableConcept.present?
+                {
+                  type: 'patternCodeableConcept',
+                  path: discriminator_path,
+                  code: pattern_element.patternCodeableConcept.coding.first.code,
+                  system: pattern_element.patternCodeableConcept.coding.first.system
+                }
+              elsif pattern_element.patternCoding.present?
+                {
+                  type: 'patternCoding',
+                  path: discriminator_path,
+                  code: pattern_element.patternCoding.code,
+                  system: pattern_element.patternCoding.system
+                }
+              elsif pattern_element.patternIdentifier.present?
+                {
+                  type: 'patternIdentifier',
+                  path: discriminator_path,
+                  system: pattern_element.patternIdentifier.system
+                }
+              elsif pattern_element.binding&.strength == 'required' &&
+                    pattern_element.binding&.valueSet.present?
+
+                value_extractor = ValueExactor.new(ig_resources, resource, profile_elements)
+
+                values = value_extractor.values_from_value_set_binding(pattern_element).presence ||
+                         value_extractor.values_from_resource_metadata([metadata[:path]]).presence || []
+
+                {
+                  type: 'requiredBinding',
+                  path: discriminator_path,
+                  values:
+                }
+              else
+                raise StandardError, 'Unsupported discriminator pattern type'
+              end
+
+            metadata[:uscdi_only] = true if is_uscdi_requirement_element?(current_element)
+          end
+        end.compact
+      end
+
+      def must_support_type_slice_elements
+        must_support_slice_elements.select do |element|
+          discriminators(sliced_element(element)).first.type == 'type'
+        end
+      end
+
+      def type_slices
+        must_support_type_slice_elements.map do |current_element|
+          discriminator = discriminators(sliced_element(current_element)).first
+          type_path = discriminator.path
+          type_path = '' if type_path == '$this'
+          type_element =
+            if type_path.present?
+              elements.find { |element| element.id == "#{current_element.id}.#{type_path}" }
+            else
+              current_element
+            end
+
+          type_code = type_element.type.first.code
+
+          {
+            slice_id: current_element.id,
+            slice_name: current_element.sliceName,
+            path: current_element.path.gsub("#{resource}.", ''),
+            discriminator: {
+              type: 'type',
+              code: type_code.upcase_first
+            }
+          }.tap do |metadata|
+            metadata[:uscdi_only] = true if is_uscdi_requirement_element?(current_element)
+          end
+        end
+      end
+
+      def must_support_value_slice_elements
+        must_support_slice_elements.select do |element|
+          discriminators(sliced_element(element)).first.type == 'value'
+        end
+      end
+
+      def value_slices
+        must_support_value_slice_elements.map do |current_element|
+          {
+            slice_id: current_element.id,
+            slice_name: current_element.sliceName,
+            path: current_element.path.gsub("#{resource}.", ''),
+            discriminator: {
+              type: 'value'
+            }
+          }.tap do |metadata|
+            metadata[:discriminator][:values] = discriminators(sliced_element(current_element)).map do |discriminator|
+              fixed_element = profile_elements.find do |element|
+                element.id.starts_with?(current_element.id) &&
+                  element.path == "#{current_element.path}.#{discriminator.path}"
+              end
+
+              {
+                path: discriminator.path,
+                value: fixed_element.fixedUri || fixed_element.fixedCode
+              }
+            end
+
+            metadata[:uscdi_only] = true if is_uscdi_requirement_element?(current_element)
+          end
+        end
+      end
+
+      def must_support_slices
+        pattern_slices + type_slices + value_slices
+      end
+
+      def plain_must_support_elements
+        all_must_support_elements - must_support_extension_elements - must_support_slice_elements
+      end
+
+      def element_part_of_slice_discrimination?(element)
+        must_support_slice_elements.any? { |ms_slice| element.id.include?(ms_slice.id) }
+      end
+
+      def handle_fixed_values(metadata, element)
+        if element.fixedUri.present?
+          metadata[:fixed_value] = element.fixedUri
+        elsif element.patternCodeableConcept.present? && !element_part_of_slice_discrimination?(element)
+          metadata[:fixed_value] = element.patternCodeableConcept.coding.first.code
+          metadata[:path] += '.coding.code'
+        elsif element.fixedCode.present?
+          metadata[:fixed_value] = element.fixedCode
+        elsif element.patternIdentifier.present? && !element_part_of_slice_discrimination?(element)
+          metadata[:fixed_value] = element.patternIdentifier.system
+          metadata[:path] += '.system'
+        end
+      end
+
+      def type_must_support_extension?(extensions)
+        extensions&.any? do |extension|
+          extension.url == 'http://hl7.org/fhir/StructureDefinition/elementdefinition-type-must-support' &&
+            extension.valueBoolean
+        end
+      end
+
+      def save_type_code?(type)
+        type.code == 'Reference'
+      end
+
+      def get_type_must_support_metadata(current_metadata, current_element)
+        current_element.type.map do |type|
+          next unless type_must_support_extension?(type.extension)
+
+          metadata =
+            {
+              path: "#{current_metadata[:path].delete_suffix('[x]')}#{type.code.upcase_first}",
+              original_path: current_metadata[:path]
+            }
+          metadata[:types] = [type.code] if save_type_code?(type)
+          handle_type_must_support_target_profiles(type, metadata) if type.code == 'Reference'
+
+          metadata
+        end.compact
+      end
+
+      def handle_type_must_support_target_profiles(type, metadata)
+        # AU Core 3.1.1 profiles do not have AU Core target profiles.
+        # Vital Sign proifles from FHIR R4 (version 4.0.1) do not have AU Core target profiles either.
+        return if ['3.1.1', '4.0.1'].include?(profile.version)
+
+        target_profiles = []
+
+        if type.targetProfile&.length == 1
+          target_profiles << type.targetProfile.first
+        else
+          type.source_hash['_targetProfile']&.each_with_index do |hash, index|
+            if hash.present?
+              element = FHIR::Element.new(hash)
+              target_profiles << type.targetProfile[index] if type_must_support_extension?(element.extension)
+            end
+          end
+        end
+
+        # remove target_profile for FHIR Base resource type.
+        target_profiles.delete_if { |reference| reference.start_with?('http://hl7.org/fhir/StructureDefinition') }
+        metadata[:target_profiles] = target_profiles if target_profiles.present?
+      end
+
+      def handle_choice_type_in_sliced_element(current_metadata, must_support_elements_metadata)
+        choice_element_metadata = must_support_elements_metadata.find do |metadata|
+          metadata[:original_path].present? &&
+            current_metadata[:path].include?(metadata[:original_path])
+        end
+
+        return unless choice_element_metadata.present?
+
+        current_metadata[:original_path] = current_metadata[:path]
+        current_metadata[:path] =
+          current_metadata[:path].sub(choice_element_metadata[:original_path], choice_element_metadata[:path])
+      end
+
+      def must_support_elements
+        plain_must_support_elements.each_with_object([]) do |current_element, must_support_elements_metadata|
+          {
+            path: current_element.id.gsub("#{resource}.", '')
+          }.tap do |current_metadata|
+            current_metadata[:uscdi_only] = true if is_uscdi_requirement_element?(current_element)
+
+            type_must_support_metadata = get_type_must_support_metadata(current_metadata, current_element)
+
+            if type_must_support_metadata.any?
+              must_support_elements_metadata.concat(type_must_support_metadata)
+            else
+              handle_choice_type_in_sliced_element(current_metadata, must_support_elements_metadata)
+
+              supported_types = current_element.type.select { |type| save_type_code?(type) }.map(&:code)
+              current_metadata[:types] = supported_types if supported_types.present?
+
+              if current_element.type.first&.code == 'Reference'
+                handle_type_must_support_target_profiles(current_element.type.first,
+                                                         current_metadata)
+              end
+
+              handle_fixed_values(current_metadata, current_element)
+
+              must_support_elements_metadata.delete_if do |metadata|
+                metadata[:path] == current_metadata[:path] && metadata[:fixed_value].blank?
+              end
+
+              must_support_elements_metadata << current_metadata
+            end
+          end
+        end.uniq
+      end
+
+      #### SPECIAL CASE ####
+
+      def handle_special_cases
+        remove_vital_sign_component
+        remove_blood_pressure_value_data_absent_reason
+        remove_observation_data_absent_reason
+        remove_observation_method_attribute
+        remove_observation_value_attribute
+        remove_lipid_result_attributes
+        # remove_specimen_attribute
+
+        case profile.version
+        when '3.1.1'
+          MustSupportMetadataExtractorAUCore3.new(profile, @must_supports).handle_special_cases
+        when '4.0.0'
+          MustSupportMetadataExtractorAUCore4.new(profile, @must_supports).handle_special_cases
+        when '5.0.1'
+          MustSupportMetadataExtractorAUCore5.new(profile, @must_supports).handle_special_cases
+        when '6.1.0'
+          MustSupportMetadataExtractorAUCore6.new(profile, @must_supports).handle_special_cases
+        when '7.0.0-ballot'
+          MustSupportMetadataExtractorAUCore7.new(profile, @must_supports).handle_special_cases
+        end
+      end
+
+      def remove_specimen_attribute
+        # TODO: Temporary solution https://github.com/hl7au/au-fhir-core-inferno/issues/18
+        return unless profile.id == 'au-core-diagnosticresult-path'
+
+        @must_supports[:elements].delete_if do |element|
+          ['specimen'].include? element[:path]
+        end
+      end
+
+      def remove_lipid_result_attributes
+        # TODO: This code block should be discussed.
+        # We need to understand why there are a lot of extra attributes
+        # for the current Observation resource profile.
+        return unless profile.id == 'au-core-lipid-result'
+
+        @must_supports[:elements].delete_if do |element|
+          ['identifier', 'performer', 'note',
+           'specimen', 'referenceRange.type',
+           'referenceRange.text', 'hasMember'].include? element[:path]
+        end
+      end
+
+      def remove_observation_value_attribute
+        return unless is_observation_without_value?
+
+        @must_supports[:elements].delete_if do |element|
+          element[:path] == 'value[x]'
+        end
+      end
+
+      def remove_observation_method_attribute
+        # TODO: Discuss with the team the problem related to the method attribute.
+        if %w[AUCorePathologyResult AUCoreLipidResult AUCoreDiagnosticImagingResult
+              AUCoreDiagnosticResult].include? profile.name
+          @must_supports[:elements].delete_if do |element|
+            element[:path] == 'method'
+          end
+        end
+      end
+
+      def is_vital_sign?
+        [
+          'http://hl7.org/fhir/StructureDefinition/vitalsigns'
+        ].include?(profile.baseDefinition)
+      end
+
+      def is_observation_without_component?
+        %w[
+          au-core-bmi
+          au-core-bodyweight
+          au-core-oxygensat
+          au-core-bodyheight
+          au-core-headcircum
+          au-core-bodytemp
+          au-core-heartrate
+          au-core-resprate
+          au-core-vitalspanel
+          au-core-lipid-result
+        ].include?(profile.id)
+      end
+
+      def is_observation_without_value?
+        [
+          'au-core-vitalspanel'
+        ].include?(profile.id)
+      end
+
+      def is_blood_pressure?
+        ['au-core-bloodpressure'].include?(profile.id)
+      end
+
+      # Exclude Observation.component from vital sign profiles except observation-bp and observation-pulse-ox
+      def remove_vital_sign_component
+        return if is_blood_pressure? || profile.name == 'AUCorePulseOximetryProfile'
+
+        return unless is_vital_sign? || is_observation_without_component?
+
+        @must_supports[:elements].delete_if do |element|
+          element[:path].start_with?('component')
+        end
+      end
+
+      # Exclude Observation.value[x] from observation-bp
+      def remove_blood_pressure_value_data_absent_reason
+        return unless is_blood_pressure?
+
+        pattern = /component(:[^.]+)?\.dataAbsentReason/
+
+        @must_supports[:elements].delete_if do |element|
+          element[:path].start_with?('value[x]') ||
+            element[:original_path]&.start_with?('value[x]') ||
+            element[:path] == ('dataAbsentReason') ||
+            (
+              pattern.match?(element[:path]) && ['3.1.1', '4.0.0'].include?(ig_resources.ig.version)
+            )
+        end
+
+        @must_supports[:slices].delete_if do |slice|
+          slice[:path].start_with?('value[x]')
+        end
+      end
+
+      # ONC and AU Core 4.0.0 both clarified that health IT developers that always provide HL7 FHIR "observation" values
+      # are not required to demonstrate Health IT Module support for "dataAbsentReason" elements.
+      # Remove MS check for dataAbsentReason and component.dataAbsentReason from vital sign profiles and observation lab profile
+      # Smoking status profile does not have MS on dataAbsentReason. It is safe to use profile.type == 'Observation'
+      # Since AU Core 5.0.1, Blood Pressure profile restores component.dataAbsentReason as MustSupport.
+      def remove_observation_data_absent_reason
+        return if is_blood_pressure?
+
+        pattern = /(component(:[^.]+)?\.)?dataAbsentReason/
+
+        return unless profile.type == 'Observation'
+
+        @must_supports[:elements].delete_if do |element|
+          pattern.match?(element[:path])
+        end
+      end
+    end
+  end
+end