au_ps_inferno 0.1.0

data/lib/au_ps_inferno/utils/basic_test/ms_sub_elements_populated_module.rb

@@ -0,0 +1,128 @@
+# frozen_string_literal: true
+
+require_relative 'ms_elements_populated_helpers_module'
+
+module AUPSTestKit
+  # Must Support elements populated or missing message.
+  module BasicTestMsSubElementsPopulatedModule
+    include BasicTestMsElementsPopulatedHelpersModule
+
+    def ms_sub_elements_populated_message(container_type)
+      guard_populated_resource(container_type)
+
+      resource = get_resource_by_container_type(container_type)
+
+      author_and_device_resource?(container_type, resource)
+
+      return unless (metadata = get_metadata_by_resource_type(resource.resourceType)).present?
+
+      _, new_grouped_sub_elements, ms_checker, results =
+        sub_elements_filtered_grouped_and_check_context(resource, metadata)
+      omit_if new_grouped_sub_elements.blank?, 'No complex element with Must Support sub-elements is defined'
+
+      show_ms_elements_messages(new_grouped_sub_elements, ms_checker, resource, results)
+      assert assert_result(results, new_grouped_sub_elements),
+             'When any mandatory Must Support sub-element is missing. See the list in messages tab.'
+    end
+
+    private
+
+    def ms_checker(metadata)
+      @ms_checker ||= InfernoSuiteGenerator::MSChecker.new(metadata)
+    end
+
+    def get_metadata_by_resource_type(resource_type)
+      raw_metadata = metadata_manager.group_metadata_by_resource_type(resource_type)
+      return nil unless raw_metadata.present?
+
+      InfernoSuiteGenerator::Generator::GroupMetadata.new(raw_metadata)
+    end
+
+    def sub_elements_filtered_grouped_and_check_context(resource, metadata)
+      checker = ms_checker(metadata)
+      results = checker.elements_present_statuses([resource], all_present: false)
+      filtered_results = results.filter { |result| sub_element?(result[:path]) }
+      grouped = filtered_results.group_by { |result| result[:path].split('.').first }
+
+      [filtered_results, grouped, checker, results]
+    end
+
+    def show_ms_elements_messages(new_grouped_sub_elements, ms_checker, resource, results)
+      new_grouped_sub_elements.each do |parent_path, sub_elements|
+        sub_element_message(ms_checker, sub_elements, resource, parent_path, results)
+      end
+    end
+
+    def assert_result(results, grouped_sub_elements)
+      grouped_sub_elements.all? do |parent_path, sub_elements|
+        !sub_element_assertion_failure?(results, parent_path, sub_elements)
+      end
+    end
+
+    def mandatory_ms_sub_elements(sub_elements)
+      sub_elements.filter { |res| res[:mandatory] == true }
+    end
+
+    def sub_element_assertion_failure?(results, parent_path, sub_elements)
+      mandatory_sub_elements = mandatory_ms_sub_elements(sub_elements)
+      return false if mandatory_sub_elements.empty?
+
+      mandatory_sub_elements_present = mandatory_sub_elements.all? { |res| res[:present] == true }
+
+      parent_element = results.find { |res| res[:path] == parent_path }
+      return false if parent_element.nil?
+
+      parent_present = parent_element[:present] == true
+
+      !mandatory_sub_elements_present && parent_present
+    end
+
+    def sub_element_message(ms_checker, sub_elements, resource, parent_path, results)
+      message_level = build_message_level(ms_checker, sub_elements, results)
+      message = build_sub_element_message_content(ms_checker, sub_elements, resource, parent_path, results)
+      add_message(message_level, message)
+    end
+
+    def build_message_level(ms_checker, sub_elements, results)
+      return 'warning' if parent_element_is_not_populated?(sub_elements, results)
+
+      ms_checker.calculate_elements_status_message_level(sub_elements)
+    end
+
+    def build_sub_element_message_content(ms_checker, sub_elements, resource, parent_path, results)
+      [
+        'Must Support sub-elements correctly populated',
+        "**Referenced subject**: #{resource.resourceType}",
+        "## Complex element **#{parent_path}** — Must Support sub-elements populated or missing",
+        sub_element_statuses_texts(ms_checker, sub_elements, results, parent_path)
+      ].join("\n\n")
+    end
+
+    def sub_element_statuses_texts(ms_checker, sub_elements, results, parent_path)
+      if parent_element_is_not_populated?(sub_elements, results)
+        return parent_element_is_not_populated_text(parent_path,
+                                                    sub_elements)
+      end
+
+      ms_checker.element_statuses_texts(sub_elements).map do |text|
+        text.gsub('|- ', '')
+      end.join("\n\n")
+    end
+
+    def parent_element_is_not_populated?(sub_elements, results)
+      parent_path = sub_elements[0][:path].split('.').first
+      results.any? { |result| result[:path] == parent_path && result[:present] == false }
+    end
+
+    def parent_element_is_not_populated_text(parent_path, sub_elements)
+      "**Complex element #{parent_path}** is not populated. " \
+        "Must Support sub-elements that would be validated: #{sub_elements.map do |element|
+          element[:path]
+        end.join(', ')}."
+    end
+
+    def sub_element?(path)
+      path.include?('.')
+    end
+  end
+end

data/lib/au_ps_inferno/utils/basic_test/paths_module.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+module AUPSTestKit
+  # FHIR path population checks and formatted lists of populated elements.
+  module BasicTestPathsModule
+    private
+
+    def populated_paths_info(resource, elements_array, mandatory_array: [])
+      title = '## List of populated elements'
+      result = elements_array.map do |element|
+        mandatory = mandatory_array.include?(element)
+        element_str = "**#{element}**"
+        element_str += ' (M)' if mandatory
+        "#{boolean_to_existent_string(resolve_path_with_dar(resource, element).first.present?,
+                                      optional: !mandatory)}: #{element_str}"
+      end
+      [title, result.join("\n\n")].join("\n\n")
+    end
+
+    def all_paths_are_populated?(resource, elements_array)
+      elements_array.map do |element|
+        resolve_path_with_dar(resource, element).first.present?
+      end.all?
+    end
+  end
+end

data/lib/au_ps_inferno/utils/basic_test/resolve_path_debug_module.rb

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+module AUPSTestKit
+  # Wraps Inferno's FHIRResourceNavigation#resolve_path to check simple elements for DAR extension presence.
+  # Ex: birthDate DAR extension is _birthDate.extension.where(url='http://hl7.org/fhir/StructureDefinition/data-absent-reason').valueCode
+  module BasicTestResolvePathDebugModule
+    def resolve_path_with_dar(resource, path)
+      result = eval_expression(resource, path)
+      return result if result.length.positive?
+
+      check_for_dar(resource, path)
+    end
+
+    private
+
+    def eval_expression(resource, path)
+      result = resolve_path(resource, path)
+      return_values(result)
+    end
+
+    def return_values(result)
+      result.length.positive? ? result : []
+    end
+
+    def check_for_dar(resource, path)
+      dar_path = modify_path_to_check_for_dar(path)
+      return nil if dar_path.nil?
+
+      eval_expression(resource, dar_path)
+    end
+
+    def modify_path_to_check_for_dar(path)
+      # Last path segment as primitive -> _segment.extension (FHIR JSON shadow path for extensions).
+      # Single segment: birthDate -> _birthDate.extension
+      # Nested: name.family -> name._family.extension
+      segments = path.split('.')
+      return nil if segments.empty?
+
+      last_part = segments.last
+      prefix = segments.length > 1 ? segments[0..-2].join('.') : ''
+      suffix = "#{last_part}.extension"
+      prefix.empty? ? suffix : "#{prefix}.#{suffix}"
+    end
+  end
+end

data/lib/au_ps_inferno/utils/basic_test/resolve_resource_type_module.rb

@@ -0,0 +1,52 @@
+# frozen_string_literal: true
+
+module AUPSTestKit
+  # Resolves the resource type from a resource. This module is used in tests for subject, author, custodian, attester.
+  module BasicTestResolveResourceTypeModule
+    def test_resource_type_is_valid?(container_type)
+      result = raw_resource_type_is_valid(container_type)
+      valid = result[:valid?]
+      result_msg = result[:msg]
+
+      build_message(valid, result_msg)
+      assert valid, result_msg
+    end
+
+    def raw_resource_type_is_valid(container_type)
+      resource = get_resource_by_container_type(container_type)
+      return { valid?: false, msg: not_resolved_message(container_type) } if resource.blank?
+
+      resolved_type = resource_type(resource)
+
+      unless allowed_resource_types(container_type).include?(resolved_type)
+        return { valid?: false, msg: invalid_resource_type_message(container_type, resolved_type) }
+      end
+
+      { valid?: true, msg: valid_resource_type_message(container_type, resolved_type) }
+    end
+
+    private
+
+    def allowed_resource_types(container_type)
+      container_metadata = get_target_metadata_by_container_type(container_type)
+      container_metadata.map { |item| item[:resource_type] }
+    end
+
+    def build_message(valid, result_msg)
+      msg_level = calculate_message_level(failed: !valid, warning: false, info: valid)
+      add_message(msg_level, result_msg)
+    end
+
+    def not_resolved_message(container_type)
+      "#{container_type.capitalize} reference does not resolve"
+    end
+
+    def invalid_resource_type_message(container_type, resource_type)
+      "#{container_type.capitalize} reference resolves to a resource with invalid resource type: #{resource_type}"
+    end
+
+    def valid_resource_type_message(container_type, resource_type)
+      "#{container_type.capitalize} reference resolves to a resource with valid resource type: #{resource_type}"
+    end
+  end
+end

data/lib/au_ps_inferno/utils/basic_test/resource_helpers_module.rb

@@ -0,0 +1,129 @@
+# frozen_string_literal: true
+
+require 'yaml'
+
+module AUPSTestKit
+  # Cross-cutting helpers: metadata, resource typing, profiles, identifiers, coding.
+  module BasicTestResourceHelpersModule
+    private
+
+    def calculate_message_level(failed: false, warning: false, info: false)
+      return 'error' if failed
+      return 'warning' if warning
+      return 'info' if info
+
+      'info'
+    end
+
+    def resource_type(resource)
+      return nil unless resource.present?
+
+      resource.respond_to?(:resourceType) ? resource.resourceType : resource['resourceType']
+    end
+
+    def author_resource_type_and_profiles(resource)
+      return ['', ''] unless resource.present?
+
+      resource_type_str = resource.respond_to?(:resourceType) ? resource.resourceType : resource['resourceType']
+      profiles = resource_profiles(resource)
+      profile_str = profiles.is_a?(Array) ? profiles.join(', ') : profiles.to_s
+      [resource_type_str.to_s, profile_str.to_s]
+    end
+
+    def resource_profiles(resource)
+      return [] unless resource.present?
+
+      if resource.respond_to?(:meta) && resource.meta&.profile.present?
+        resource.meta.profile
+      elsif resource.is_a?(Hash)
+        resource.dig('meta', 'profile') || []
+      else
+        []
+      end
+    end
+
+    def ms_elements_populated_message(resource, list_lines)
+      ref = prepare_resource_type_and_profile_str(resource, 'author')
+      "#{ms_elements_populated_title}#{ref}#{populated_elements_list(list_lines)}"
+    end
+
+    def ms_elements_populated_title
+      'Must Support elements correctly populated'
+    end
+
+    def prepare_resource_type_and_profile_str(resource, human_readable_name)
+      resource_type_str = resource.respond_to?(:resourceType) ? resource.resourceType : resource['resourceType']
+      profiles = resource_profiles(resource)
+      profile_str = profiles.is_a?(Array) && profiles.length.positive? ? profiles.join(', ') : nil
+
+      result = [resource_type_str, profile_str].compact.join(' — ')
+
+      "\n\n**Referenced #{human_readable_name}**: #{result}"
+    end
+
+    def populated_elements_list(list_lines)
+      return '' if list_lines.blank?
+
+      "\n\n## List of Must Support elements (complex) populated or missing\n\n#{list_lines.join("\n\n")}"
+    end
+
+    def identifiers_from_resource(resource)
+      return nil unless resource.present?
+
+      if resource.respond_to?(:identifier)
+        resource.identifier
+      elsif resource.is_a?(Hash)
+        resource['identifier']
+      end
+    end
+
+    def identifier_system(ident)
+      return nil unless ident.present?
+
+      ident.respond_to?(:system) ? ident.system : ident['system']
+    end
+
+    def find_identifier_by_system(identifiers, system_url)
+      return nil if identifiers.blank? || system_url.blank?
+
+      identifiers.find { |ident| identifier_system(ident).to_s.strip == system_url.to_s.strip }
+    end
+
+    def identifier_type_display(ident)
+      return '' unless ident.present?
+
+      type_val = ident.respond_to?(:type) ? ident.type : ident['type']
+      return '' if type_val.blank?
+
+      coding_suffix_from_type_value(type_val)
+    end
+
+    def coding_suffix_from_type_value(type_val)
+      return coding_display_suffix(type_val.coding.first) if type_val.respond_to?(:coding) && type_val.coding.present?
+      return coding_display_suffix_hash(type_val['coding'].first) if type_val.is_a?(Hash) && type_val['coding'].present?
+
+      ''
+    end
+
+    def coding_display_suffix(coding)
+      display = coding.respond_to?(:display) ? coding.display : coding['display']
+      code = coding.respond_to?(:code) ? coding.code : coding['code']
+      ", type: #{display.presence || code.presence || '—'}"
+    end
+
+    def coding_display_suffix_hash(coding)
+      ", type: #{coding['display'].presence || coding['code'].presence || '—'}"
+    end
+
+    def guard_populated_resource(container_type)
+      resource_is_poluated = raw_resource_type_is_valid(container_type)
+      skip_if !resource_is_poluated[:valid?], resource_is_poluated[:msg]
+    end
+
+    def author_and_device_resource?(container_type, resource)
+      # TODO: This function should be more generic in the future.
+      is_author_and_device = container_type == 'author' && resource_type(resource) == 'Device'
+      omit_if is_author_and_device, 'Test is ommited because the author reference resolves to a Device resource'
+    end
+  end
+end

data/lib/au_ps_inferno/utils/basic_test/scratch_bundle_entries_module.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+module AUPSTestKit
+  # Saving and retrieving bundle entities from scratch.
+  module BasicTestScratchBundleEntriesModule
+    def save_bundle_entities_to_scratch(bundle)
+      scratch[:bundle_entities] = bundle.entry.map do |entry|
+        {
+          full_url: entry.fullUrl,
+          resource_type: entry.resource.resourceType,
+          resource: entry.resource
+        }
+      end
+    end
+
+    def bundle_entities_from_scratch
+      scratch[:bundle_entities] || []
+    end
+
+    def bundle_entity_from_scratch(full_url)
+      bundle_entities_from_scratch.find { |entity| entity[:full_url] == full_url }
+    end
+
+    def bundle_entity_resource_from_scratch(full_url)
+      return nil if bundle_entity_from_scratch(full_url).nil?
+
+      bundle_entity_from_scratch(full_url)[:resource]
+    end
+  end
+end

data/lib/au_ps_inferno/utils/basic_test/section_bundle_validation_module.rb

@@ -0,0 +1,70 @@
+# frozen_string_literal: true
+
+module AUPSTestKit
+  # Per-section bundle row validation (optional, mandatory, and mixed strictness).
+  module BasicTestSectionBundleValidationModule
+    private
+
+    def validate_populated_undefined_sections_in_bundle(sections_code_to_filter, elements_array)
+      skip_if scratch_bundle.blank?, 'No Bundle resource provided'
+
+      bundle_resource = BundleDecorator.new(scratch_bundle)
+      sections_to_validate = bundle_resource.composition_resource.section_codes.filter do |section_code|
+        !sections_code_to_filter.include?(section_code)
+      end
+
+      skip_if sections_to_validate.blank?, 'No sections to validate'
+      validate_populated_sections_in_bundle(sections_to_validate, elements_array, optional: true)
+    end
+
+    def validate_populated_sections_in_bundle(section_codes_array, elements_array, optional: false)
+      skip_if scratch_bundle.blank?, 'No Bundle resource provided'
+      skip_if section_codes_array.blank?, 'No sections to validate'
+
+      composition = BundleDecorator.new(scratch_bundle).composition_resource
+      all_errors = section_codes_array.filter_map do |section_code|
+        section_bundle_row_failure?(composition, section_code, elements_array, optional: optional)
+      end
+
+      assert all_errors.empty?,
+             'Some of the sections are not populated. See the list of populated sections in messages tab.'
+    end
+
+    def section_bundle_row_failure?(composition, section_code, elements_array, optional:)
+      section = composition.section_by_code(section_code)
+      return section_bundle_blank_outcome?(section_code, optional) if section.blank?
+
+      section_bundle_ms_population_outcome?(section, elements_array)
+    end
+
+    def section_bundle_blank_outcome?(section_code, optional)
+      add_message(optional ? 'warning' : 'error', "#{get_section_name(section_code)} is missing")
+      optional ? false : true
+    end
+
+    def section_bundle_ms_population_outcome?(section, elements_array)
+      body = section_ms_elements_message(section, elements_array)
+      return section_bundle_all_ms_ok?(body) if all_paths_are_populated?(section, elements_array)
+
+      add_message('error', section_ms_missing_mandatory_message(body))
+      true
+    end
+
+    def section_bundle_all_ms_ok?(body)
+      add_message('info', "Section correctly populated\n\n#{body}")
+      false
+    end
+
+    def section_ms_missing_mandatory_message(body)
+      "For section with any mandatory Must Support element in section missing (i.e. title, code, text)\n\n#{body}"
+    end
+
+    def section_ms_elements_message(section, elements_array)
+      title = "### #{section.code_display_str}"
+      elements_list = elements_array.map do |element|
+        "**#{element}**: #{boolean_to_existent_string(resolve_path_with_dar(section, element).first.present?)}"
+      end.join("\n\n")
+      [title, 'List of Must Support elements populated or missing:', elements_list].join("\n\n")
+    end
+  end
+end

data/lib/au_ps_inferno/utils/basic_test_class.rb

@@ -0,0 +1,56 @@
+# frozen_string_literal: true
+
+require_relative 'bundle_decorator'
+require_relative 'composition_utils'
+require_relative 'validator_helpers'
+require_relative 'section_test_module'
+require_relative 'section_names_mapping'
+require_relative 'basic_test_contants_module'
+require_relative 'attester/basic_test_attester_module'
+require_relative 'subject/basic_test_subject_module'
+require_relative 'author/basic_test_author_module'
+require_relative 'custodian/basic_test_custodian_module'
+require_relative 'basic_test/bundle_module'
+require_relative 'basic_test/capability_operations_module'
+require_relative 'basic_test/composition_section_read_module'
+require_relative 'basic_test/paths_module'
+require_relative 'basic_test/resource_helpers_module'
+require_relative 'basic_test/composition_subelements_module'
+require_relative 'basic_test/ms_identifier_slices_module'
+require_relative 'basic_test/composition_elements_and_slices_module'
+require_relative 'basic_test/section_bundle_validation_module'
+require_relative 'basic_test/resolve_path_debug_module'
+require_relative 'basic_test/scratch_bundle_entries_module'
+require_relative 'basic_test/ms_elements_populated_module'
+require_relative 'basic_test/ms_sub_elements_populated_module'
+require_relative 'basic_test/resolve_resource_type_module'
+
+module AUPSTestKit
+  # A base class for all tests to decrease code duplication.
+  # Shared behavior is composed from BasicTest* modules under utils/basic_test/.
+  class BasicTest < Inferno::Test
+    include CompositionUtils
+    include ValidatorHelpers
+    include SectionTestModule
+    include SectionNamesMapping
+    include BasicTestConstants
+    include BasicTestSubjectModule
+    include BasicTestAuthorModule
+    include BasicTestCustodianModule
+    include BasicTestAttesterModule
+    include BasicTestBundleModule
+    include BasicTestCapabilityOperationsModule
+    include BasicTestCompositionSectionReadModule
+    include BasicTestPathsModule
+    include BasicTestResourceHelpersModule
+    include BasicTestCompositionSubelementsModule
+    include BasicTestMsIdentifierSlicesModule
+    include BasicTestCompositionElementsAndSlicesModule
+    include BasicTestSectionBundleValidationModule
+    include BasicTestResolvePathDebugModule
+    include BasicTestScratchBundleEntriesModule
+    include BasicTestMsElementsPopulatedModule
+    include BasicTestMsSubElementsPopulatedModule
+    include BasicTestResolveResourceTypeModule
+  end
+end

data/lib/au_ps_inferno/utils/basic_test_contants_module.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+module AUPSTestKit
+  module BasicTestConstants
+    # AU PS Patient Must Support identifier slices (optional). System URLs for IHI, DVA, Medicare.
+    PATIENT_MS_IDENTIFIER_SLICES = [
+      { name: 'IHI', system: 'http://ns.electronichealth.net.au/id/hi/ihi/1.0' },
+      { name: 'DVA', system: 'http://ns.electronichealth.net.au/id/dva' },
+      { name: 'MEDICARE', system: 'http://ns.electronichealth.net.au/id/medicare-number' }
+    ].freeze
+    ORGANIZATION_MS_IDENTIFIER_SLICES = [
+      { name: 'ABN', system: 'http://hl7.org.au/id/abn' },
+      { name: 'HPIO', system: 'http://ns.electronichealth.net.au/id/hi/hpio/1.0' }
+    ].freeze
+    PRACTITIONER_ROLE_MS_IDENTIFIER_SLICES = [
+      { name: 'MEDICARE PROVIDER', system: 'http://ns.electronichealth.net.au/id/medicare-provider-number' }
+    ].freeze
+    PRACTITIONER_MS_IDENTIFIER_SLICES = [
+      { name: 'HPII', system: 'http://ns.electronichealth.net.au/id/hi/hpii/1.0' }
+    ].freeze
+
+    # Author resource type -> Must Support identifier slices (empty for Device, RelatedPerson).
+    AUTHOR_MS_IDENTIFIER_SLICES_BY_TYPE = {
+      'Practitioner' => PRACTITIONER_MS_IDENTIFIER_SLICES,
+      'PractitionerRole' => PRACTITIONER_ROLE_MS_IDENTIFIER_SLICES,
+      'Patient' => PATIENT_MS_IDENTIFIER_SLICES,
+      'Organization' => ORGANIZATION_MS_IDENTIFIER_SLICES,
+      'RelatedPerson' => [],
+      'Device' => []
+    }.freeze
+  end
+end

data/lib/au_ps_inferno/utils/basic_test_with_url.rb

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+module AUPSTestKit
+  # A base class for all tests with FHIR server URL to decrease code duplication
+  class BasicTestWithURL < BasicTest
+    id :basic_test_with_url
+  end
+end

data/lib/au_ps_inferno/utils/basic_validate_bundle_test.rb

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+module AUPSTestKit
+  # Basic test for validating a Bundle resource against the AU PS Bundle or IPS Bundle profile
+  class BasicValidateBundleTest < BasicTest
+    OMIT_AU_PS_MESSAGE = 'Validation against AU PS Bundle is disabled'
+    OMIT_IPS_MESSAGE = 'Validation against IPS Bundle is disabled'
+
+    id :basic_validate_bundle_test
+
+    input :validate_against,
+          title: 'Validate Against',
+          optional: true,
+          type: 'checkbox',
+          default: %w[au_ps_bundle],
+          options: {
+            list_options: [
+              {
+                label: 'AU PS Bundle Validation',
+                value: 'au_ps_bundle'
+              },
+              {
+                label: 'IPS Bundle Validation',
+                value: 'ips_bundle'
+              }
+            ]
+          }
+
+    def omit_au_ps_validation?
+      omit_test_wrapper?('au_ps_bundle')
+    end
+
+    def omit_ips_validation?
+      omit_test_wrapper?('ips_bundle')
+    end
+
+    private
+
+    def omit_test_wrapper?(include_str)
+      validate_against.blank? || !validate_against.include?(include_str)
+    end
+  end
+end