au_core_test_kit 1.4.5 → 1.4.7

data/lib/au_core_test_kit/fhir_resource_navigation.rb

@@ -1,177 +0,0 @@
-# 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/generator/chain_search_test_generator.rb

@@ -1,169 +0,0 @@
-# frozen_string_literal: true
-
-require_relative 'naming'
-require_relative 'special_cases'
-
-module AUCoreTestKit
-  class Generator
-    class ChainSearchTestGenerator
-      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|
-              current_search_definition = group.search_definitions[search_key]
-              next unless current_search_definition.key?(:chain) && current_search_definition[:chain].length.positive?
-
-              current_search_definition[:chain].each do |chain_item|
-                new(
-                  search_key.to_s,
-                  group,
-                  group.search_definitions[search_key],
-                  base_output_dir,
-                  chain_item
-                ).generate
-              end
-            end
-          end
-        end
-      end
-
-      attr_accessor :search_name, :group_metadata, :search_metadata, :base_output_dir, :chain_item
-
-      def initialize(search_name, group_metadata, search_metadata, base_output_dir, chain_item)
-        self.search_name = search_name
-        self.group_metadata = group_metadata
-        self.search_metadata = search_metadata
-        self.base_output_dir = base_output_dir
-        self.chain_item = chain_item
-      end
-
-      def template
-        @template ||= File.read(File.join(__dir__, 'templates', 'chain_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}_chain_search_test"
-      end
-
-      def search_identifier
-        search_name.to_s.tr('-', '_')
-      end
-
-      def search_title
-        search_identifier.camelize
-      end
-
-      def class_name
-        "#{Naming.upper_camel_case_for_profile(group_metadata)}#{search_title}ChainSearchTest"
-      end
-
-      def module_name
-        "AUCore#{group_metadata.reformatted_version.upcase}"
-      end
-
-      def resource_type
-        group_metadata.resource
-      end
-
-      def conformance_expectation
-        chain_item[:expectation]
-      end
-
-      def search_param_names
-        ["#{search_name}:#{chain_item[:target]}.#{chain_item[:chain]}"]
-      end
-
-      def search_param_names_array
-        array_of_strings(search_param_names)
-      end
-
-      def search_param_name_string
-        search_name
-      end
-
-      def search_properties
-        {}.tap do |properties|
-          properties[:resource_type] = "'#{resource_type}'"
-          properties[:search_param_names] = search_param_names_array
-          properties[:attr_paths] = attribute_paths
-        end
-      end
-
-      def attribute_paths
-        search_metadata[:paths]
-      end
-
-      def optional?
-        conformance_expectation != 'SHALL'
-      end
-
-      def search_definition(name)
-        group_metadata.search_definitions[name.to_sym]
-      end
-
-      def array_of_strings(array)
-        quoted_strings = array.map { |element| "'#{element}'" }
-        "[#{quoted_strings.join(', ')}]"
-      end
-
-      def search_test_properties_string
-        search_properties
-          .map { |key, value| "#{' ' * 8}#{key}: #{value}" }
-          .join(",\n")
-      end
-
-      def url_version
-        case group_metadata.version
-        when 'v0.3.0-ballot'
-          '0.3.0-ballot'
-        end
-      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 title
-        "Server returns valid results for #{resource_type} search by #{search_param_name_string} (chained parameters)"
-      end
-
-      def description
-        <<~DESCRIPTION.gsub(/\n{3,}/, "\n\n")
-          A server #{conformance_expectation} support searching by
-          #{search_param_names.first} on the #{resource_type} 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/#{url_version}/CapabilityStatement-au-core-server.html)
-        DESCRIPTION
-      end
-    end
-  end
-end

data/lib/au_core_test_kit/generator/group_generator.rb

@@ -1,143 +0,0 @@
-# frozen_string_literal: true
-
-require_relative 'naming'
-require_relative 'special_cases'
-require_relative '../helpers'
-
-module AUCoreTestKit
-  class Generator
-    class GroupGenerator
-      class << self
-        def generate(ig_metadata, base_output_dir)
-          ig_metadata.ordered_groups
-                     .compact
-                     .reject { |group| SpecialCases.exclude_group? group }
-                     .each { |group| new(group, base_output_dir).generate }
-        end
-      end
-
-      attr_accessor :group_metadata, :base_output_dir
-
-      def initialize(group_metadata, base_output_dir)
-        self.group_metadata = group_metadata
-        self.base_output_dir = base_output_dir
-      end
-
-      def template
-        @template ||= File.read(File.join(__dir__, 'templates', 'group.rb.erb'))
-      end
-
-      def output
-        @output ||= ERB.new(template).result(binding)
-      end
-
-      def base_output_file_name
-        "#{class_name.underscore}.rb"
-      end
-
-      def base_metadata_file_name
-        'metadata.yml'
-      end
-
-      def class_name
-        "#{Naming.upper_camel_case_for_profile(group_metadata)}Group"
-      end
-
-      def module_name
-        "AUCore#{group_metadata.reformatted_version.upcase}"
-      end
-
-      def title
-        group_metadata.title
-      end
-
-      def short_description
-        group_metadata.short_description
-      end
-
-      def output_file_name
-        File.join(base_output_dir, base_output_file_name)
-      end
-
-      def metadata_file_name
-        File.join(base_output_dir, profile_identifier, base_metadata_file_name)
-      end
-
-      def profile_identifier
-        Naming.snake_case_for_profile(group_metadata)
-      end
-
-      def group_id
-        "au_core_#{group_metadata.reformatted_version}_#{profile_identifier}"
-      end
-
-      def resource_type
-        group_metadata.resource
-      end
-
-      def search_validation_resource_type
-        "#{resource_type} resources"
-      end
-
-      def profile_name
-        group_metadata.profile_name
-      end
-
-      def profile_url
-        group_metadata.profile_url
-      end
-
-      def optional?
-        resource_type == 'QuestionnaireResponse'
-      end
-
-      def generate
-        add_special_tests
-        File.open(output_file_name, 'w') { |f| f.write(output) }
-        group_metadata.id = group_id
-        group_metadata.file_name = base_output_file_name
-        File.open(metadata_file_name, 'w') { |f| f.write(YAML.dump(group_metadata.to_hash)) }
-      end
-
-      def add_special_tests
-        return if group_metadata.reformatted_version == 'v311'
-
-        case group_metadata.resource
-        when 'DocumentReference'
-          group_metadata.add_test(
-            id: 'au_core_v400_document_reference_custodian_test',
-            file_name: '../../custom_groups/v4.0.0/document_reference_custodian_test.rb'
-          )
-        end
-      end
-
-      def test_id_list
-        @test_id_list ||= group_metadata.tests.map { |test| test[:id] }
-      end
-
-      def test_file_list
-        @test_file_list ||=
-          group_metadata.tests.map do |test|
-            name_without_suffix = test[:file_name].delete_suffix('.rb')
-            name_without_suffix.start_with?('..') ? name_without_suffix : "#{profile_identifier}/#{name_without_suffix}"
-          end
-      end
-
-      def required_searches
-        group_metadata.searches.select { |search| search[:expectation] == 'SHALL' }
-      end
-
-      def search_param_name_string
-        required_searches
-          .map { |search| search[:names].join(' + ') }
-          .map { |names| "* #{names}" }
-          .join("\n")
-      end
-
-      def description
-        Helpers.get_group_description_text(title, resource_type, profile_name, group_metadata.version, profile_url,
-                                           required_searches, search_param_name_string, search_validation_resource_type, resource_type)
-      end
-    end
-  end
-end

data/lib/au_core_test_kit/generator/group_metadata.rb

@@ -1,103 +0,0 @@
-# frozen_string_literal: true
-
-module AUCoreTestKit
-  class Generator
-    class GroupMetadata
-      ATTRIBUTES = %i[
-        name
-        class_name
-        version
-        reformatted_version
-        resource
-        profile_url
-        profile_name
-        profile_version
-        title
-        short_description
-        interactions
-        operations
-        searches
-        search_definitions
-        include_params
-        revincludes
-        required_concepts
-        must_supports
-        mandatory_elements
-        bindings
-        references
-        tests
-        id
-        file_name
-        delayed_references
-      ].freeze
-
-      NON_USCDI_RESOURCES = {
-        'Encounter' => %w[v311 v400],
-        'Location' => %w[v311 v400 v501 v610],
-        'Organization' => %w[v311 v400 v501 v610],
-        'Practitioner' => %w[v311 v400 v501 v610],
-        'PractitionerRole' => %w[v311 v400 v501 v610],
-        'Provenance' => %w[v311 v400 v501 v610],
-        'RelatedPerson' => %w[v501 v610],
-        'Specimen' => ['v610']
-      }.freeze
-
-      ATTRIBUTES.each { |name| attr_accessor name }
-
-      def initialize(metadata)
-        metadata.each do |key, value|
-          raise "Unknown attribute #{key}" unless ATTRIBUTES.include? key
-
-          instance_variable_set(:"@#{key}", value)
-        end
-      end
-
-      def delayed?
-        return false if resource == 'Patient'
-
-        no_patient_searches? || non_uscdi_resource?
-      end
-
-      def no_patient_searches?
-        searches.none? { |search| search[:names].include? 'patient' }
-      end
-
-      def non_uscdi_resource?
-        NON_USCDI_RESOURCES.key?(resource) && NON_USCDI_RESOURCES[resource].include?(reformatted_version)
-      end
-
-      def add_test(id:, file_name:)
-        self.tests ||= []
-
-        test_metadata = {
-          id:,
-          file_name:
-        }
-
-        if delayed? && id.include?('read')
-          tests.unshift(test_metadata)
-        else
-          tests << test_metadata
-        end
-      end
-
-      def to_hash
-        ATTRIBUTES.each_with_object({}) { |key, hash| hash[key] = send(key) unless send(key).nil? }
-      end
-
-      def add_delayed_references(delayed_profiles, ig_resources)
-        self.delayed_references =
-          references
-          .select { |reference| (reference[:profiles] & delayed_profiles).present? }
-          .map do |reference|
-            profile_urls = (reference[:profiles] & delayed_profiles)
-            delayed_resources = profile_urls.map { |url| ig_resources.resource_for_profile(url) }
-            {
-              path: reference[:path].gsub("#{resource}.", ''),
-              resources: delayed_resources
-            }
-          end
-      end
-    end
-  end
-end