au_core_test_kit 0.0.16

data/lib/au_core_test_kit/generator/suite_generator.rb

@@ -0,0 +1,104 @@
+# frozen_string_literal: true
+
+require_relative 'naming'
+require_relative 'special_cases'
+
+module AUCoreTestKit
+  class Generator
+    class SuiteGenerator
+      class << self
+        def generate(ig_metadata, base_output_dir)
+          new(ig_metadata, base_output_dir).generate
+        end
+      end
+
+      attr_accessor :ig_metadata, :base_output_dir
+
+      def initialize(ig_metadata, base_output_dir)
+        self.ig_metadata = ig_metadata
+        self.base_output_dir = base_output_dir
+      end
+
+      def version_specific_message_filters
+        []
+      end
+
+      def template
+        @template ||= File.read(File.join(__dir__, 'templates', 'suite.rb.erb'))
+      end
+
+      def output
+        @output ||= ERB.new(template).result(binding)
+      end
+
+      def base_output_file_name
+        'au_core_test_suite.rb'
+      end
+
+      def class_name
+        'AUCoreTestSuite'
+      end
+
+      def module_name
+        "AUCore#{ig_metadata.reformatted_version.upcase}"
+      end
+
+      def output_file_name
+        File.join(base_output_dir, base_output_file_name)
+      end
+
+      def suite_id
+        "au_core_#{ig_metadata.reformatted_version}"
+      end
+
+      def fhir_api_group_id
+        "au_core_#{ig_metadata.reformatted_version}_fhir_api"
+      end
+
+      def title
+        "AU Core #{ig_metadata.ig_version}"
+      end
+
+      def ig_identifier
+        version = ig_metadata.ig_version[1..] # Remove leading 'v'
+        "hl7.fhir.au.core##{version}"
+      end
+
+      def ig_link
+        case ig_metadata.ig_version
+        when 'v0.3.0-ballot'
+          'http://hl7.org.au/fhir/core/0.3.0-ballot'
+        end
+      end
+
+      def generate
+        File.open(output_file_name, 'w') { |f| f.write(output) }
+      end
+
+      def groups
+        ig_metadata.ordered_groups.compact
+                   .reject { |group| SpecialCases.exclude_group? group }
+      end
+
+      def group_id_list
+        @group_id_list ||=
+          groups.map(&:id)
+      end
+
+      def group_file_list
+        @group_file_list ||=
+          groups.map { |group| group.file_name.delete_suffix('.rb') }
+      end
+
+      def capability_statement_file_name
+        # "../../custom_groups/#{ig_metadata.ig_version}/capability_statement_group"
+        '../../custom_groups/v0.3.0-ballot/capability_statement_group'
+      end
+
+      def capability_statement_group_id
+        # "au_core_#{ig_metadata.reformatted_version}_capability_statement"
+        'au_core_v030_ballot_capability_statement'
+      end
+    end
+  end
+end

data/lib/au_core_test_kit/generator/summary_generator.rb

@@ -0,0 +1,172 @@
+# frozen_string_literal: true
+
+require 'erb'
+require 'yaml'
+
+def symbolize_keys(hash)
+  hash.transform_keys(&:to_sym).transform_values do |value|
+    if value.is_a?(Hash)
+      symbolize_keys(value)
+    elsif value.is_a?(Array)
+      value.map { |item| item.is_a?(Hash) ? symbolize_keys(item) : item }
+    else
+      value
+    end
+  end
+end
+
+def make_search_string(resource_name, search_names)
+  search = search_names.map.with_index do |search_name, index|
+    prefix = index.zero? ? '?' : '&'
+    "#{prefix}#{search_name}={#{search_name}}"
+  end
+  "/#{resource_name}#{search.join('')}"
+end
+
+def search_string(file_path)
+  search_names = extract_test_attribute(file_path, 'search_param_names')
+  return unless search_names
+
+  resource_type = extract_test_attribute(file_path, 'resource_type')
+  make_search_string(resource_type, search_names)
+end
+
+def update_test_groups_titles(ig_index, test_groups)
+  test_groups.each_with_index do |test_group, index|
+    test_group_index = index + 2
+    test_group[:title] = "#{ig_index}.#{test_group_index} #{test_group[:title]}"
+    test_group[:tests].each_with_index do |test, t_index|
+      test_index = t_index + 1
+      test[:title] = "#{ig_index}.#{test_group_index}.#{test_index} #{test[:title]}"
+    end
+  end
+end
+
+def generate_summary_md(folder_hashes)
+  summary_template = File.read(File.join(__dir__, 'templates', 'summary.md.erb'))
+  folder_hashes.each do |folder_hash|
+    folder_name = folder_hash[:folder_name]
+    folder_path = folder_hash[:folder_path]
+    test_groups = folder_hash[:test_groups]
+
+    summary_content = ERB.new(summary_template).result(binding)
+
+    File.open("#{folder_path}/summary.md", 'w') { |summary_file| summary_file.puts summary_content }
+  end
+end
+
+def find_value_in_file(file_path, search_str)
+  value = nil
+  File.foreach(file_path) do |test_line|
+    if test_line.include?(search_str)
+      value = test_line.split(search_str)[1].strip.gsub("'", '')
+      break
+    end
+  end
+  value
+end
+
+def extract_test_attribute(test_file_path_with_id, attribute)
+  attribute_value = nil
+  case attribute
+  when 'resource_type'
+    attribute_value = find_value_in_file(test_file_path_with_id, 'resource_type').delete(':,').strip
+  when 'search_param_names'
+    dirty_value = find_value_in_file(test_file_path_with_id, 'search_param_names')
+    attribute_value = dirty_value.scan(/\[(.*?)\]/).flatten.first.split(', ') if dirty_value
+  when 'title', 'short_description'
+    attribute_value = find_value_in_file(test_file_path_with_id, attribute)
+  when 'description'
+    content = File.read(test_file_path_with_id)
+    matches = content.scan(/%\((.*?)\)/m)
+    attribute_value = find_value_in_file(test_file_path_with_id, 'description') if matches.empty?
+    matches.each { |match| attribute_value = match[0].strip }
+    # TODO: Fix it
+    attribute_value = attribute_value.gsub(
+      '[AU Core Server CapabilityStatement](http://hl7.org.au/fhir/core/0.3.0-ballot/CapabilityStatement-au-core-server.html',
+      '[AU Core Server CapabilityStatement](http://hl7.org.au/fhir/core/0.3.0-ballot/CapabilityStatement-au-core-server.html)'
+    )
+  else
+    puts "Unknown attribute: #{attribute}"
+  end
+  attribute_value
+end
+
+directory_path = 'lib/au_core_test_kit/generated'
+folder_hashes = []
+
+if Dir.exist?(directory_path)
+  folder_names = Dir.entries(directory_path).select do |entry|
+    File.directory?(File.join(directory_path, entry)) && entry != '.' && entry != '..'
+  end
+
+  folder_names.each_with_index do |folder_name, index|
+    folder_path = File.join(directory_path, folder_name)
+    file_path = File.join(folder_path, 'au_core_test_suite.rb')
+    test_groups = []
+    ig_index = index + 1
+
+    next unless File.exist?(file_path)
+
+    File.foreach(file_path) do |line|
+      if line.include?('group from: :')
+        value = line[/:\s*([^\s]+)/, 1]
+        id = value if value
+        file_path_with_id = Dir.glob("#{folder_path}/*").find { |f| File.file?(f) && File.read(f).include?("id #{id}") }
+        tests = []
+        next unless id && file_path_with_id
+
+        File.foreach(file_path_with_id) do |test_line|
+          if test_line.include?('test from: :')
+            test_value = test_line[/:\s*([^\s]+)/, 1]
+            test_id = test_value if test_value
+            Dir.glob("#{folder_path}/**/*").select { |f| File.file?(f) }.each do |test_file_path_with_id|
+              next unless File.read(test_file_path_with_id).include?("id #{test_id}")
+
+              tests << {
+                id: test_id,
+                test_file_path: test_file_path_with_id,
+                title: extract_test_attribute(test_file_path_with_id, 'title'),
+                description: extract_test_attribute(test_file_path_with_id, 'description'),
+                search_string: search_string(test_file_path_with_id)
+              }
+              break
+            end
+          end
+        end
+        if id && file_path_with_id
+          test_groups << {
+            id:,
+            file_path: file_path_with_id,
+            title: extract_test_attribute(file_path_with_id, 'title'),
+            short_description: extract_test_attribute(file_path_with_id, 'short_description'),
+            description: extract_test_attribute(file_path_with_id, 'description'),
+            tests:
+          }
+        end
+      end
+    end
+
+    update_test_groups_titles(ig_index, test_groups)
+    test_groups.unshift(
+      symbolize_keys(
+        YAML.safe_load(
+          File.read(
+            File.join(
+              __dir__, 'assets', 'capability_statement_group.yaml'
+            )
+          )
+        )
+      )
+    )
+
+    folder_hashes << {
+      folder_name: "#{ig_index} AU Core #{folder_name}",
+      folder_path:,
+      test_groups:
+    }
+  end
+  generate_summary_md(folder_hashes)
+else
+  puts "Directory not found: #{directory_path}"
+end

data/lib/au_core_test_kit/generator/terminology_binding_metadata_extractor.rb

@@ -0,0 +1,118 @@
+# frozen_string_literal: true
+
+module AUCoreTestKit
+  class Generator
+    class TerminologyBindingMetadataExtractor
+      attr_accessor :profile_elements, :ig_resources, :resource
+
+      def initialize(profile_elements, ig_resources, resource)
+        self.profile_elements = profile_elements
+        self.ig_resources = ig_resources
+        self.resource = resource
+      end
+
+      def terminology_bindings
+        (element_terminology_bindings + extension_terminology_bindings).compact
+        # add_terminology_bindings_from_extensions
+        # profile_elements.select { |element| element.type&.first&.code == 'Extension' }
+        #   .each { |extension| add_terminology_bindings_from_extension(extension) }
+      end
+
+      def element_has_fixed_value?(element)
+        case element.type.first.code
+        when 'Quantity'
+          code = profile_elements.find { |e| e.path == "#{element.path}.code" }
+          system = profile_elements.find { |e| e.path == "#{element.path}.system" }
+          code&.fixedCode || system&.fixedUri
+        when 'code'
+          element.fixedCode.present?
+        end
+      end
+
+      def element_has_optional_binding_slice?(element)
+        element.sliceName.present? && element.min.zero?
+      end
+
+      def profile_elements_with_bindings
+        profile_elements
+          .select { |element| element.binding.present? && element.binding.strength == 'required' }
+          .reject { |element| element_has_fixed_value?(element) || element_has_optional_binding_slice?(element) }
+      end
+
+      def element_terminology_bindings
+        profile_elements_with_bindings.map do |element|
+          binding = {
+            type: element.type.first.code,
+            strength: element.binding.strength,
+            # Goal.target.detail has an unbound binding
+            system: element.binding.valueSet&.split('|')&.first,
+            path: element.path.gsub('[x]', '').gsub("#{resource}.", '')
+          }
+
+          binding[:required_binding_slice] = true if element.sliceName.present? && element.min.positive?
+
+          binding
+        end
+      end
+
+      def extension_profile_elements
+        profile_elements
+          .select { |element| element.type&.first&.code == 'Extension' }
+          .select { |element| extension_profile_url(element).present? }
+      end
+
+      def extension_profile_url(extension)
+        extension.type.first.profile&.first
+      end
+
+      def extension_terminology_bindings
+        extension_profile_elements
+          .flat_map do |extension_profile_element|
+            url = extension_profile_url(extension_profile_element)
+            extension = ig_resources.profile_by_url(url)
+
+            # TODO: Temporaray fix for extension defined out of AU Core. FI-1623
+            next if extension.nil?
+
+            elements = extension.snapshot.element
+            elements_with_bindings = elements.select do |element|
+              element.binding.present? && !element.id.include?('Extension.extension')
+            end
+
+            elements_with_bindings.map do |element|
+              {
+                type: element.type.first.code,
+                strength: element.binding.strength,
+                system: element.binding.valueSet&.split('|')&.first,
+                path: element.path.gsub('[x]', '').gsub('Extension.', ''),
+                extensions: [url]
+              }
+            end + nested_extension_terminology_bindings(elements, url)
+          end
+      end
+
+      def nested_extension_terminology_bindings(elements, extension_url)
+        nested_extensions = elements.select { |element| element.path == 'Extension.extension' }
+        nested_extensions.flat_map do |nested_extension|
+          nested_extension_element = elements.find { |element| element.id == "#{nested_extension.id}.url" }
+          next unless nested_extension_element.present?
+
+          nested_extension_url = nested_extension_element.fixedUri
+          nested_elements_with_bindings = elements.select do |element|
+            element.id.include?(nested_extension.id) && element.binding.present?
+          end
+
+          nested_elements_with_bindings.map do |element|
+            {
+              type: element.type.first.code,
+              strength: element.binding.strength,
+              system: element.binding.valueSet&.split('|')&.first,
+              path: element.path.gsub('[x]', '').gsub('Extension.extension.', ''),
+              extensions: [extension_url, nested_extension_url]
+            }
+          end
+        end
+      end
+    end
+  end
+end

data/lib/au_core_test_kit/generator/validation_test_generator.rb

@@ -0,0 +1,142 @@
+# frozen_string_literal: true
+
+require_relative 'naming'
+require_relative 'special_cases'
+
+module AUCoreTestKit
+  class Generator
+    class ValidationTestGenerator
+      class << self
+        def generate(ig_metadata, base_output_dir)
+          ig_metadata.groups
+                     .reject { |group| SpecialCases.exclude_group? group }
+                     .each do |group|
+            new(group, base_output_dir:).generate
+            next unless group.resource == 'MedicationRequest'
+
+            # The Medication validation test lives in the MedicationRequest
+            # group, so we need to pass in that group's metadata
+            medication_group_metadata = ig_metadata.groups.find { |group| group.resource == 'Medication' }
+            new(medication_group_metadata, group, base_output_dir:).generate
+          end
+        end
+      end
+
+      attr_accessor :group_metadata, :medication_request_metadata, :base_output_dir
+
+      def initialize(group_metadata, medication_request_metadata = nil, base_output_dir:)
+        self.group_metadata = group_metadata
+        self.medication_request_metadata = medication_request_metadata
+        self.base_output_dir = base_output_dir
+      end
+
+      def template
+        @template ||= File.read(File.join(__dir__, 'templates', 'validation.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, directory_name)
+      end
+
+      def output_file_name
+        File.join(output_file_directory, base_output_file_name)
+      end
+
+      def directory_name
+        Naming.snake_case_for_profile(medication_request_metadata || group_metadata)
+      end
+
+      def profile_identifier
+        Naming.snake_case_for_profile(group_metadata)
+      end
+
+      def profile_url
+        group_metadata.profile_url
+      end
+
+      def profile_name
+        group_metadata.profile_name
+      end
+
+      def profile_version
+        group_metadata.profile_version
+      end
+
+      def test_id
+        "au_core_#{group_metadata.reformatted_version}_#{profile_identifier}_validation_test"
+      end
+
+      def class_name
+        "#{Naming.upper_camel_case_for_profile(group_metadata)}ValidationTest"
+      end
+
+      def module_name
+        "AUCore#{group_metadata.reformatted_version.upcase}"
+      end
+
+      def resource_type
+        group_metadata.resource
+      end
+
+      def conformance_expectation
+        read_interaction[:expectation]
+      end
+
+      def skip_if_empty
+        # Return true if a system must demonstrate at least one example of the resource type.
+        # This drives omit vs. skip result statuses in this test.
+        resource_type != 'Medication'
+      end
+
+      def generate
+        FileUtils.mkdir_p(output_file_directory)
+        File.open(output_file_name, 'w') { |f| f.write(output) }
+
+        test_metadata = {
+          id: test_id,
+          file_name: base_output_file_name
+        }
+
+        if resource_type == 'Medication'
+          medication_request_metadata.add_test(**test_metadata)
+        else
+          group_metadata.add_test(**test_metadata)
+        end
+      end
+
+      def description
+        <<~DESCRIPTION
+          #{description_intro}
+          It verifies the presence of mandatory elements and that elements with
+          required bindings contain appropriate values. CodeableConcept element
+          bindings will fail if none of their codings have a code/system belonging
+          to the bound ValueSet. Quantity, Coding, and code element bindings will
+          fail if their code/system are not found in the valueset.
+        DESCRIPTION
+      end
+
+      def description_intro
+        if resource_type == 'Medication'
+          <<~MEDICATION_INTRO
+            This test verifies resources returned from previous tests conform to
+            the [#{profile_name}](#{profile_url}).
+          MEDICATION_INTRO
+        else
+          <<~GENERIC_INTRO
+            This test verifies resources returned from the first search conform to
+            the [#{profile_name}](#{profile_url}).
+            If at least one resource from the first search is invalid, the test will fail.
+          GENERIC_INTRO
+        end
+      end
+    end
+  end
+end

data/lib/au_core_test_kit/generator/value_extractor.rb

@@ -0,0 +1,107 @@
+# frozen_string_literal: true
+
+module AUCoreTestKit
+  class Generator
+    class ValueExactor
+      attr_accessor :ig_resources, :resource, :profile_elements
+
+      def initialize(ig_resources, resource, profile_elements)
+        self.ig_resources = ig_resources
+        self.resource = resource
+        self.profile_elements = profile_elements
+      end
+
+      def values_from_required_binding(profile_element)
+        return [] unless profile_element&.max == '*'
+
+        profile_elements
+          .select do |element|
+            element.path == profile_element.path && element.binding&.strength == 'required'
+          end
+          .map { |element| values_from_value_set_binding(element) }
+          .flatten.compact
+      end
+
+      def values_from_fixed_codes(profile_element, type)
+        return [] unless type == 'CodeableConcept'
+
+        profile_elements
+          .select do |element|
+            element.path == "#{profile_element.path}.coding.code" && element.fixedCode.present?
+          end
+          .map(&:fixedCode)
+      end
+
+      def values_from_pattern_coding(profile_element, type)
+        return [] unless type == 'CodeableConcept'
+
+        profile_elements
+          .select do |element|
+            element.path == "#{profile_element.path}.coding" && element.patternCoding.present?
+          end
+          .map { |element| element.patternCoding.code }
+      end
+
+      def values_from_pattern_codeable_concept(profile_element, type)
+        return [] unless type == 'CodeableConcept'
+
+        profile_elements
+          .select do |element|
+            element.path == profile_element.path && element.patternCodeableConcept.present? && element.min.positive?
+          end
+          .map { |element| element.patternCodeableConcept.coding.first.code }
+      end
+
+      def value_set_binding(the_element)
+        the_element&.binding
+      end
+
+      def value_set(the_element)
+        ig_resources.value_set_by_url(value_set_binding(the_element)&.valueSet)
+      end
+
+      def bound_systems(the_element)
+        bound_systems_from_valueset(value_set(the_element))
+      end
+
+      def bound_systems_from_valueset(value_set)
+        value_set&.compose&.include&.map do |include|
+          if include.concept.present?
+            include
+          elsif include.system.present? && include.filter&.empty? # Cannot process intensional value set with filters
+            ig_resources.code_system_by_url(include.system)
+          elsif include.valueSet.present?
+            include.valueSet.map do |vs|
+              a_value_set = ig_resources.value_set_by_url(vs)
+              bound_systems_from_valueset(a_value_set)
+            end
+          end
+        end&.flatten&.compact
+      end
+
+      def values_from_value_set_binding(the_element)
+        bound_systems = bound_systems(the_element)
+
+        return [] if bound_systems.blank?
+
+        bound_systems.flat_map { |system| system.concept.map(&:code) }.uniq
+      end
+
+      def fhir_metadata(current_path)
+        FHIR.const_get(resource)::METADATA[current_path]
+      end
+
+      def values_from_resource_metadata(paths)
+        values = []
+
+        paths.each do |current_path|
+          current_metadata = fhir_metadata(current_path)
+
+          values += current_metadata['valid_codes'].values.flatten if current_metadata&.dig('valid_codes').present?
+        end
+
+        values
+      end
+    end
+  end
+end