au_ps_inferno 0.1.0

data/lib/au_ps_inferno/utils/bundle_decorator.rb

@@ -0,0 +1,81 @@
+# frozen_string_literal: true
+
+require_relative 'composition_decorator'
+require_relative 'bundle_entry_decorator'
+
+# A decorator for FHIR::Bundle to add convenience methods
+class BundleDecorator < FHIR::Bundle
+  def initialize(data)
+    if data.is_a?(Hash)
+      super
+    else
+      super(data.respond_to?(:source_hash) ? data.source_hash : data.to_hash)
+    end
+  end
+
+  def composition_resource
+    return nil if composition_entry.nil?
+
+    CompositionDecorator.new(composition_entry.resource)
+  end
+
+  def composition_entry
+    entry.find { |entr| entr.resource.resourceType == 'Composition' }
+  end
+
+  def resources_by_references(entry_references)
+    entry_references.filter_map { |ref| resource_by_reference(ref) }.uniq
+  end
+
+  def resource_by_reference(entry_reference)
+    entry = resolve_entry_reference(entry_reference)
+    entry&.resource
+  end
+
+  private
+
+  def resolve_entry_reference_as_reference(entry_reference)
+    base_url = BundleEntryDecorator.new(composition_entry).full_url_base
+    return resolve_by_base_url(entry_reference, base_url) if base_url
+
+    resolve_by_suffix_match(entry_reference)
+  end
+
+  def resolve_by_base_url(entry_reference, base_url)
+    entry.find do |entr|
+      next unless entr.fullUrl&.start_with?('http')
+
+      entr.fullUrl == base_url + entry_reference
+    end
+  end
+
+  def resolve_by_suffix_match(entry_reference)
+    # Composition fullUrl is a URN so no base URL is derivable. Fall back to
+    # suffix match: a relative {Type}/{id} reference can resolve to an absolute
+    # fullUrl that ends with /{Type}/{id} (FHIR bundle reference rules).
+    # Only resolve when exactly one entry matches — multiple matches are
+    # ambiguous (entries from different servers share the same type/id).
+    matches = entry.select { |entr| entr.fullUrl&.end_with?("/#{entry_reference}") }
+    matches.length == 1 ? matches.first : nil
+  end
+
+  def resolve_entry_reference_by_exact_url(entry_reference)
+    canonical = strip_history_suffix(entry_reference)
+    entry.find { |entr| entr.fullUrl == canonical }
+  end
+
+  def resolve_entry_reference(entry_reference)
+    is_urn = entry_reference.start_with?('urn:')
+    is_url = entry_reference.start_with?('http')
+    is_reference = !is_urn && !is_url && entry_reference.split('/').length == 2
+
+    return resolve_entry_reference_by_exact_url(entry_reference) if is_urn || is_url
+    return resolve_entry_reference_as_reference(entry_reference) if is_reference
+
+    nil
+  end
+
+  def strip_history_suffix(url)
+    url&.sub(%r{/_history/[^/]+$}, '')
+  end
+end

data/lib/au_ps_inferno/utils/bundle_entry_decorator.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+# Decorator for FHIR::Bundle::Entry
+class BundleEntryDecorator < FHIR::Bundle::Entry
+  def initialize(data)
+    if data.is_a?(Hash)
+      super
+    else
+      super(data.respond_to?(:source_hash) ? data.source_hash : data.to_hash)
+    end
+  end
+
+  def full_url_base
+    return nil if fullUrl.nil?
+    return nil unless fullUrl.start_with?('http') || fullUrl.start_with?('https')
+
+    fullUrl.split("#{resource.resourceType}/#{resource.id}").first
+  end
+end

data/lib/au_ps_inferno/utils/bundle_is_valid_class.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+require_relative 'basic_validate_bundle_test'
+
+module AUPSTestKit
+  # The Bundle resource is valid against the AU PS Bundle profile
+  class BundleIsValidClass < BasicValidateBundleTest
+    id :bundle_is_valid_class_test
+    input :bundle_resource,
+          optional: true,
+          description: 'If you want to check existing Bundle resource',
+          type: 'textarea'
+
+    def skip_test?
+      bundle_resource.blank?
+    end
+
+    def read_and_save_data
+      resource = FHIR.from_contents(bundle_resource)
+      scratch[:bundle_ips_resource] = resource
+      save_bundle_entities_to_scratch(scratch_bundle)
+    end
+
+    run do
+      skip_if skip_test?, 'No Bundle resource provided'
+      read_and_save_data
+      omit_if omit_au_ps_validation?, OMIT_AU_PS_MESSAGE
+      validate_au_ps_bundle
+    end
+  end
+end

data/lib/au_ps_inferno/utils/capability_statement_decorator.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+# Decorator for FHIR::CapabilityStatement
+class CapabilityStatementDecorator < FHIR::CapabilityStatement
+  def all_profiles
+    profiles + supported_profiles
+  end
+
+  def profiles
+    rest.map do |rest_item|
+      rest_item.resource.map(&:profile)
+    end.flatten.compact.uniq
+  end
+
+  def supported_profiles
+    rest.map do |rest_item|
+      rest_item.resource.map(&:supportedProfile)
+    end.flatten.compact.uniq
+  end
+end

data/lib/au_ps_inferno/utils/composition_decorator.rb

@@ -0,0 +1,56 @@
+# frozen_string_literal: true
+
+require_relative 'section_decorator'
+
+# Decorator for FHIR::Composition to add convenience methods
+class CompositionDecorator < FHIR::Composition
+  def initialize(data)
+    if data.is_a?(Hash)
+      super
+    else
+      super(data.respond_to?(:source_hash) ? data.source_hash : data.to_hash)
+    end
+  end
+
+  def section_codes
+    section.map { |sect| section_first_code(sect) }.compact
+  end
+
+  def entry_references_by_codes(codes)
+    sections = sections_by_codes(codes).compact
+    sections.map(&:entry_references).flatten
+  end
+
+  def sections_by_codes(codes)
+    codes.map { |code| section_by_code(code) }
+  end
+
+  def section_by_code(code)
+    section_data = section.find { |sect| section_first_code(sect) == code }
+    return nil if section_data.nil?
+
+    SectionDecorator.new(section_data.to_hash)
+  end
+
+  def event_by_code(code)
+    return nil if event.nil?
+
+    event.find { |elem| event_element_code(elem) == code }
+  end
+
+  private
+
+  def event_element_code(event_elem)
+    cc = event_elem.code&.first
+    return nil if cc.nil?
+
+    cc.coding&.first&.code
+  end
+
+  def section_first_code(section)
+    cc = section.code
+    return nil if cc.nil?
+
+    cc.coding&.first&.code
+  end
+end

data/lib/au_ps_inferno/utils/composition_utils/boolean_and_stats.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+# Bundle-level booleans and per-path statistics lines for CompositionUtils.
+module CompositionUtilsBooleanAndStats
+  def boolean_to_existent_string(boolean_value, optional: false)
+    missing_icon = optional ? '⚠️' : '❌'
+    boolean_value ? '✅ Populated' : "#{missing_icon} Missing"
+  end
+
+  def all_entries_have_full_url_info?
+    entry_full_url_count = resolve_path_with_dar(scratch_bundle, 'entry.fullUrl').length
+    entries_count = resolve_path_with_dar(scratch_bundle, 'entry').length
+
+    entry_full_url_count == entries_count
+  end
+
+  def timestamp_info?
+    resolve_path_with_dar(scratch_bundle, 'timestamp').first.present?
+  end
+
+  def type_info?
+    resolve_path_with_dar(scratch_bundle, 'type').first.present?
+  end
+
+  def identifier_info?
+    resolve_path_with_dar(scratch_bundle, 'identifier').first.present?
+  end
+end

data/lib/au_ps_inferno/utils/composition_utils.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+require_relative 'bundle_decorator'
+require_relative 'composition_utils/boolean_and_stats'
+
+# Utilities for FHIR Composition resources
+module CompositionUtils
+  include CompositionUtilsBooleanAndStats
+
+  def scratch_bundle
+    scratch[:bundle_ips_resource]
+  end
+
+  def check_bundle_exists_in_scratch
+    skip_if scratch_bundle.blank?, 'No Bundle resource provided'
+  end
+
+  def group_section_output(section_info_array)
+    section_entities = {}
+    section_info_array.each do |section_info|
+      if section_entities.keys.include?(section_info)
+        section_entities[section_info] += 1
+      else
+        section_entities[section_info] = 1
+      end
+    end
+    section_entities.keys.map { |section_entity| "#{section_entity} x#{section_entities[section_entity]}" }
+  end
+end

data/lib/au_ps_inferno/utils/custodian/basic_test_custodian_identifier_slices.rb

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+module AUPSTestKit
+  # Custodian Must Support identifier slices (Organization).
+  module BasicTestCustodianIdentifierSlices
+    def validate_custodian_ms_identifier_slices(resource, slices, resource_type_str, profile_str)
+      return unless resource.present? && slices.present?
+
+      custodian_header = custodian_identifier_slices_header(resource_type_str, profile_str)
+      slice_results = custodian_identifier_slice_results(identifiers_from_resource(resource) || [], slices)
+      custodian_post_identifier_slices_message(custodian_header, slice_results)
+    end
+
+    private
+
+    def custodian_identifier_slices_header(resource_type_str, profile_str)
+      "**Referenced custodian**: #{resource_type_str}#{" — #{profile_str}" if profile_str.present?}"
+    end
+
+    def custodian_identifier_slice_results(identifiers, slices)
+      slices.map do |slice|
+        ident = find_identifier_by_system(identifiers, slice[:system])
+        { slice: slice, identifier: ident }
+      end
+    end
+
+    def custodian_post_identifier_slices_message(custodian_header, slice_results)
+      lines = slice_results.map { |result| custodian_identifier_slice_line(result) }
+      message_type = slice_results.all? { |r| r[:identifier].present? } ? 'info' : 'warning'
+      add_message(message_type, custodian_identifier_slices_full_message(custodian_header, lines))
+    end
+
+    def custodian_identifier_slice_line(result)
+      if result[:identifier].present?
+        type_str = identifier_type_display(result[:identifier])
+        "✅ Populated: **#{result[:slice][:name]}** — system: #{result[:slice][:system]}#{type_str}"
+      else
+        "⚠️ Missing: **#{result[:slice][:name]}**"
+      end
+    end
+
+    def custodian_identifier_slices_full_message(custodian_header, lines)
+      heading = '## List of Must Support identifier slices populated or missing (type and system when populated)'
+      ['Must support identifier slices correctly populated', custodian_header, heading, lines.join("\n\n")].join("\n\n")
+    end
+  end
+end

data/lib/au_ps_inferno/utils/custodian/basic_test_custodian_module.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+require_relative 'basic_test_custodian_resource'
+require_relative 'basic_test_custodian_identifier_slices'
+require_relative 'basic_test_custodian_tests'
+
+module AUPSTestKit
+  # Composes Composition.custodian Must Support helpers for BasicTest.
+  module BasicTestCustodianModule
+    include BasicTestCustodianResource
+    include BasicTestCustodianIdentifierSlices
+    include BasicTestCustodianTests
+  end
+end

data/lib/au_ps_inferno/utils/custodian/basic_test_custodian_resource.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+require_relative '../bundle_decorator'
+
+module AUPSTestKit
+  # Resolves Composition.custodian reference from the scratch bundle.
+  module BasicTestCustodianResource
+    def custodian_resource
+      return nil unless scratch_bundle.present?
+
+      bundle_resource = BundleDecorator.new(scratch_bundle)
+      composition_resource = bundle_resource.composition_resource
+      return nil unless composition_resource.present?
+
+      custodian_ref = first_composition_custodian_reference(composition_resource)
+      return nil unless custodian_ref.present?
+
+      ref_str = custodian_ref.respond_to?(:reference) ? custodian_ref.reference : custodian_ref['reference']
+      return nil if ref_str.blank?
+
+      bundle_entity_resource_from_scratch(ref_str)
+    end
+
+    private
+
+    def first_composition_custodian_reference(composition_resource)
+      return nil unless composition_resource.respond_to?(:custodian) && composition_resource.custodian.present?
+
+      composition_resource.custodian
+    end
+  end
+end

data/lib/au_ps_inferno/utils/custodian/basic_test_custodian_tests.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+require_relative '../basic_test_contants_module'
+
+module AUPSTestKit
+  # Inferno tests for Composition.custodian Must Support.
+  module BasicTestCustodianTests
+    include BasicTestConstants
+
+    def test_composition_custodian_ms_identifier_slices
+      check_bundle_exists_in_scratch
+      resource = custodian_resource
+      skip_if resource.blank?, 'Custodian is not populated'
+
+      rtype_str, profile_str = author_resource_type_and_profiles(resource)
+      validate_custodian_ms_identifier_slices(resource, ORGANIZATION_MS_IDENTIFIER_SLICES, rtype_str, profile_str)
+    end
+  end
+end

data/lib/au_ps_inferno/utils/inferno_suite_generator_compat.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+# Compatibility shim for pinned inferno_suite_generator versions
+# that still reference FHIR::R4::* classes.
+FHIR.const_set(:R4, FHIR) if defined?(FHIR) && !FHIR.const_defined?(:R4)
+
+require 'inferno_suite_generator'

data/lib/au_ps_inferno/utils/ips_bundle_is_valid_class.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+require_relative 'bundle_is_valid_class'
+
+module AUPSTestKit
+  # The Bundle resource is valid against the IPS Bundle profile
+  class IpsBundleIsValidClass < BundleIsValidClass
+    id :ips_bundle_is_valid_class_base
+
+    run do
+      omit_if omit_ips_validation?, OMIT_IPS_MESSAGE
+      validate_ips_bundle
+    end
+  end
+end

data/lib/au_ps_inferno/utils/ips_retrieve_bundle_test_class.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+require_relative 'retrieve_bundle_test_class'
+
+module AUPSTestKit
+  # Retrieve a bundle and validate against the IPS Bundle profile
+  class IpsRetrieveBundleTestClass < RetrieveBundleTestClass
+    id :ips_retrieve_bundle_test_class_base
+
+    run do
+      skip_if skip_test?, 'There is no FHIR server URL, Bundle ID or Bundle URL provided'
+      read_and_save_data
+      omit_if omit_ips_validation?, OMIT_IPS_MESSAGE
+      validate_ips_bundle
+    end
+  end
+end

data/lib/au_ps_inferno/utils/ips_summary_valid_bundle_class.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+require_relative 'summary_valid_bundle_class'
+
+module AUPSTestKit
+  # Bundle from $summary validated against the IPS Bundle profile
+  class IpsSummaryValidBundleClass < SummaryValidBundleClass
+    id :ips_summary_valid_bundle_class_base
+
+    run do
+      omit_if omit_ips_validation?, OMIT_IPS_MESSAGE
+      validate_ips_bundle
+    end
+  end
+end

data/lib/au_ps_inferno/utils/metadata_manager.rb

@@ -0,0 +1,58 @@
+# frozen_string_literal: true
+
+require 'yaml'
+
+module AUPSTestKit
+  # Manages metadata from the ballot YAML file.
+  class MetadataManager
+    def initialize(metadata_yaml_path)
+      @metadata_yaml_path = metadata_yaml_path
+    end
+
+    def metadata
+      @metadata ||= YAML.safe_load_file(@metadata_yaml_path, permitted_classes: [Symbol], aliases: true)
+    end
+
+    def sections_metadata_by_codes(codes)
+      composition_sections_metadata.filter { |section| codes.include?(section[:code]) }
+    end
+
+    def group_metadata_by_resource_type(resource_type)
+      group_metadata = groups_metadata.find { |group| group[:resource] == resource_type }
+      return nil if group_metadata.nil?
+
+      group_metadata
+    end
+
+    def group_metadata_by_profile_url(profile_url)
+      group_metadata = groups_metadata.find { |group| group[:profile_url] == profile_url }
+      return nil if group_metadata.nil?
+
+      group_metadata
+    end
+
+    def composition_sections_metadata
+      metadata[:composition_sections]
+    end
+
+    def subject_metadata
+      metadata[:subject]
+    end
+
+    def author_metadata
+      metadata[:author]
+    end
+
+    def custodian_metadata
+      metadata[:custodian]
+    end
+
+    def attester_metadata
+      metadata[:attester]
+    end
+
+    def groups_metadata
+      metadata[:groups]
+    end
+  end
+end

data/lib/au_ps_inferno/utils/retrieve_bundle_test_class.rb

@@ -0,0 +1,81 @@
+# frozen_string_literal: true
+
+require 'net/http'
+require 'uri'
+
+require_relative 'basic_validate_bundle_test'
+
+module AUPSTestKit
+  # A base class for all tests that retrieve a Bundle resource
+  class RetrieveBundleTestClass < BasicValidateBundleTest
+    id :retrieve_bundle_test_class
+    input_order :bundle_url, :url, :bundle_id, :credentials, :header_name, :header_value
+
+    input :bundle_id,
+          optional: true,
+          description: 'To request Bundle/{bundle_id}'
+
+    input :bundle_url,
+          optional: true,
+          description: 'To retrieve document Bundle using HTTP GET request'
+
+    input :url,
+          title: 'FHIR Server Base Url',
+          optional: true
+
+    input :credentials,
+          title: 'OAuth Credentials',
+          type: :oauth_credentials,
+          optional: true
+
+    input :header_name,
+          title: 'Header name',
+          optional: true
+
+    input :header_value,
+          title: 'Header value',
+          optional: true
+
+    fhir_client do
+      url :url
+      oauth_credentials :credentials
+      headers(header_name.present? && header_value.present? ? { header_name => header_value } : {})
+    end
+
+    def get_bundle_resource_from_fhir_server(bundle_id)
+      fhir_read(:bundle, bundle_id)
+      assert_response_status(200)
+      assert_resource_type(:bundle)
+      scratch[:bundle_ips_resource] = resource
+    end
+
+    def get_bundle_resource_from_url(bundle_url)
+      uri = URI(bundle_url)
+      response = Net::HTTP.get_response(uri)
+      assert response.code == '200', "Bundle resource not found at #{bundle_url}"
+      bundle_resource = FHIR.from_contents(response.body)
+      assert bundle_resource.resourceType == 'Bundle', 'Resource have different type than Bundle'
+      scratch[:bundle_ips_resource] = bundle_resource
+      save_bundle_entities_to_scratch(scratch_bundle)
+    end
+
+    def skip_test?
+      !((url.present? && bundle_id.present?) || bundle_url.present?)
+    end
+
+    def read_and_save_data
+      if url.present? && bundle_id.present?
+        get_bundle_resource_from_fhir_server(bundle_id) if url.present? && bundle_id.present?
+      elsif bundle_url.present?
+        get_bundle_resource_from_url(bundle_url)
+      end
+    end
+
+    run do
+      skip_if skip_test?, 'There is no FHIR server URL, Bundle ID or Bundle URL provided'
+      read_and_save_data
+      omit_if omit_au_ps_validation?, OMIT_AU_PS_MESSAGE
+      validate_au_ps_bundle
+    end
+  end
+end

data/lib/au_ps_inferno/utils/rich_message_class.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+require 'digest'
+
+# A class to represent a rich message for the better and informative output
+class RichMessage
+  attr_reader :message, :type, :resource_type, :profile
+
+  def initialize(resource, message, profile, _idx, _ref)
+    message_body = cleanup_message_body(message[:message], resource.resourceType, resource.id)
+    @resource_type = resource.resourceType
+    @message = message_body
+    @type = message[:type]
+    @profile = profile
+  end
+
+  private
+
+  def cleanup_message_body(message, resource_type, resource_id)
+    string_to_replace = resource_id.present? ? "#{resource_type}/#{resource_id}: " : "#{resource_type}: "
+    message.sub(string_to_replace, '')
+  end
+end

data/lib/au_ps_inferno/utils/rich_validation_message.rb

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+# A class to represent a rich validation message for the better and informative output
+class RichValidationMessage
+  def initialize(rich_messages)
+    @rich_messages = rich_messages
+    @title = calculate_title(rich_messages.first)
+    @indexes = uniq_attribute_values(rich_messages, :idx)
+    @entry_references = uniq_attribute_values(rich_messages, :ref)
+    @resource_ids = uniq_attribute_values(rich_messages, :resource_id)
+    @message = rich_messages.first.message
+  end
+
+  def to_s
+    [
+      [nil, @title],
+      ['Indexes', @indexes.join(', ')],
+      ['Entry References', @entry_references.join(', ')],
+      ['Resource IDs', @resource_ids.join(', ')],
+      [nil, @message]
+    ].map { |part| msg_line(title: part[0], value: part[1]) }.compact.join("\n\n")
+  end
+
+  private
+
+  def uniq_attribute_values(messages_array, attribute)
+    messages_array.map { |message| message.send(attribute) }.uniq.sort
+  end
+
+  def msg_line(title: nil, value: nil)
+    return nil if title.blank? && value.blank?
+    return nil if value.blank?
+
+    title.present? ? "**#{title}**: #{value}" : value
+  end
+
+  def calculate_title(message)
+    profile = message.profile
+    resource_type = message.resource_type
+    profile.present? ? "### #{resource_type} (#{profile})" : "### #{resource_type}"
+  end
+end

data/lib/au_ps_inferno/utils/section_decorator.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+# Decorator for FHIR::Composition::Section
+class SectionDecorator < FHIR::Composition::Section
+  def get_entry_index_by_reference(reference)
+    entry&.index { |entr| entr.reference == reference }
+  end
+
+  def entry_references
+    entry&.map(&:reference) || []
+  end
+
+  def empty_reason_str
+    er_coding = emptyReason&.coding&.first
+    return unless er_coding.present?
+
+    "#{er_coding.display} (#{er_coding.code})"
+  end
+
+  def code_display_str
+    "#{code.coding.first.display || title} (#{code.coding.first.code})"
+  end
+end