au_ps_inferno 0.1.0

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

@@ -0,0 +1,197 @@
+# frozen_string_literal: true
+
+require_relative '../inferno_suite_generator_compat'
+require 'inferno_suite_generator/test_utils/ms_checker'
+module AUPSTestKit
+  module BasicTestCompositionSectionReadModule
+    # Composition Must Support elements in sections.
+    module BasicTestCompositionSectionCheckResourcesMSElementsModule # rubocop:disable Metrics/ModuleLength
+      AU_PS_PROFILE_BASE_URL = 'http://hl7.org.au/fhir/ps/StructureDefinition/'
+
+      def check_ms_elements_populated(profile_url, resources, all_present: false)
+        profile_metadata = group_metadata_for(profile_url)
+        collapsed_elements_statuses(ms_checker_for(profile_metadata).elements_present_statuses(resources, all_present:))
+      end
+
+      private
+
+      def collapsed_elements_statuses(elements_statuses)
+        to_collapse = parent_paths_to_collapse(elements_statuses)
+        elements_statuses.filter do |element|
+          next true unless element[:path].include?('.')
+
+          to_collapse.none? do |to_collapse_path|
+            element[:path].start_with?("#{to_collapse_path}.")
+          end
+        end
+      end
+
+      def parent_paths_to_collapse(elements_statuses)
+        optional_missing_parent_elements(elements_statuses).map { |element| element[:path] }.uniq
+      end
+
+      def complex_elements(elements_statuses)
+        elements_statuses.filter { |element| element[:path].include?('.') }.map { |element| element[:path] }
+      end
+
+      def optional_missing_parent_elements(elements_statuses)
+        complex_elements_paths = complex_elements(elements_statuses)
+        elements_statuses.filter do |element|
+          element[:present] == false &&
+            element[:mandatory] == false &&
+            !element[:path].include?('.') &&
+            complex_elements_paths.any? { |complex_element| complex_element.start_with?(element[:path]) }
+        end
+      end
+
+      def raw_sections_profiles(sections_codes)
+        sections_metadata = metadata_manager.sections_metadata_by_codes(sections_codes)
+        sections_metadata.flat_map do |section_metadata|
+          section_short = section_metadata[:short]
+          section_code = section_metadata[:code]
+          section_metadata[:entries].flat_map do |entry_metadata|
+            entry_metadata[:profiles].map do |profile|
+              {
+                profile: profile,
+                section_short: section_short,
+                section_code: section_code
+              }
+            end
+          end
+        end
+      end
+
+      def sections_profiles(sections_codes)
+        uniq_profiles = Set.new
+        raw_sections_profiles(sections_codes).filter do |profile|
+          _, profile_url = profile[:profile].split('|', 2)
+          next false unless profile_url.present? && profile_url.start_with?(AU_PS_PROFILE_BASE_URL)
+          next false if uniq_profiles.include?(profile_url)
+
+          uniq_profiles.add(profile_url)
+          true
+        end
+      end
+
+      def resources_to_check_ms(sections_codes:, bundle_resource:)
+        composition_resource = bundle_resource.composition_resource
+
+        entry_references = composition_resource.entry_references_by_codes(sections_codes)
+        bundle_resource.resources_by_references(entry_references)
+      end
+
+      def result_has?(results, result_type)
+        results.any? { |result| result == result_type }
+      end
+
+      def results_error?(results)
+        result_has?(results, 'error')
+      end
+
+      def check_ms_elements_populated_against_profiles(sections_profiles, resources_to_check_ms, all_present: false)
+        sections_profiles.map { |profile| process_profile(profile, resources_to_check_ms, all_present:) }
+      end
+
+      def normalize_resource_type_and_profile(profile)
+        parts = profile.split('|')
+        raise StandardError, 'Profile is not in the correct format' if parts.length < 2
+
+        {
+          resource_type: parts[0],
+          profile_url: parts[1]
+        }
+      end
+
+      def msg_line(title, text)
+        "**#{title}**: #{text}"
+      end
+
+      def ms_checker_for(profile_metadata, section_context = nil)
+        InfernoSuiteGenerator::MSChecker.new(profile_metadata, ms_checker_message_config(section_context))
+      end
+
+      def build_ms_outcome(profile_metadata, resources, section_context = nil, all_present: false)
+        ms_helper = ms_checker_for(profile_metadata, section_context)
+        ms_checks_results = check_ms_elements_populated(profile_metadata.profile_url, resources, all_present:)
+
+        {
+          status: ms_helper.calculate_elements_status_message_level(ms_checks_results),
+          message: ms_helper.build_report_message(profile_metadata, ms_checks_results)
+        }
+      end
+
+      def process_profile(section_profile, resources_to_check_ms, all_present: false)
+        profile_info_str, filtered_resources, _, profile_url =
+          build_profile_context(section_profile, resources_to_check_ms)
+        return report_missing_resources(profile_info_str) if filtered_resources.blank?
+
+        profile_metadata = group_metadata_for(profile_url)
+        outcome = build_ms_outcome(profile_metadata, filtered_resources, section_profile, all_present:)
+        add_message(outcome[:status], outcome[:message].join("\n\n"))
+
+        outcome[:status]
+      end
+
+      def build_profile_context(section_profile, resources_to_check_ms)
+        resource_type_and_profile = normalize_resource_type_and_profile(section_profile[:profile])
+        resource_type, profile_url = resource_type_and_profile.values_at(:resource_type, :profile_url)
+        profile_info_str = msg_line('Profile', "#{resource_type} — #{profile_url}")
+        filtered_resources = resources_by_type(resources_to_check_ms, resource_type)
+
+        [profile_info_str, filtered_resources, resource_type, profile_url]
+      end
+
+      def resources_by_type(resources, resource_type)
+        resources.filter { |resource| resource.resourceType == resource_type }
+      end
+
+      def group_metadata_for(profile_url)
+        resource_metadata_raw = metadata_manager.group_metadata_by_profile_url(profile_url)
+        InfernoSuiteGenerator::Generator::GroupMetadata.new(resource_metadata_raw)
+      end
+
+      def report_missing_resources(profile_info_str)
+        full_message_data = [
+          'No resources found',
+          profile_info_str
+        ]
+        add_message('warning', full_message_data.join("\n\n"))
+        nil
+      end
+
+      def section_context_label(section_context)
+        short = section_context[:section_short]
+        code = section_context[:section_code]
+        short.present? ? "#{short} (#{code})" : code.to_s
+      end
+
+      def ms_checker_message_config(section_context)
+        return {} if section_context.blank?
+
+        section_label = section_context_label(section_context)
+
+        {
+          'mandatory_error_message' =>
+            inject_section_into_ms_message(InfernoSuiteGenerator::MSChecker::MANDATORY_ERROR_MS_MESSAGE, section_label),
+          'optional_warning_message' =>
+            inject_section_into_ms_message(InfernoSuiteGenerator::MSChecker::OPTIONAL_MS_WARNING_MESSAGE,
+                                           section_label),
+          'okay_message' =>
+            inject_section_into_ms_message(InfernoSuiteGenerator::MSChecker::MS_OKAY_MESSAGE, section_label)
+        }
+      end
+
+      def inject_section_into_ms_message(message, section_label)
+        message.sub('.', " in the #{section_label} section.")
+      end
+
+      def composition_section_check_ms_pass?(sections_codes:, bundle_resource:, all_present: false)
+        results = check_ms_elements_populated_against_profiles(sections_profiles(sections_codes),
+                                                               resources_to_check_ms(sections_codes: sections_codes,
+                                                                                     bundle_resource: bundle_resource),
+                                                               all_present:)
+        !results_error?(results)
+      end
+    end
+  end
+end

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

@@ -0,0 +1,66 @@
+# frozen_string_literal: true
+
+module AUPSTestKit
+  # Helpers for reading composition section issues.
+  module BasicTestCompositionSectionReadIssuesHelpersModule
+    def references_resolution_report(section_metadata, bundle_resource)
+      section_code = section_metadata[:code]
+      composition_resource = bundle_resource.composition_resource
+      section = composition_resource.section_by_code(section_code)
+      entries_resource_types = permitted_resource_types(section_metadata)
+
+      section.entry_references.map do |ref|
+        issues = composition_section_ref_read_issues(ref, bundle_resource, entries_resource_types)
+        build_reference_resolution_report(ref, issues)
+      end
+    end
+
+    private
+
+    def read_composition_section_issues(section_metadata, bundle_resource)
+      section_code = section_metadata[:code]
+      if bundle_resource.composition_resource.section_by_code(section_code).blank?
+        return ["No composition section found for code: #{section_code}"]
+      end
+
+      references_resolution_report(section_metadata, bundle_resource).map do |ref_report|
+        ref_report[:issues]
+      end.flatten.compact
+    end
+
+    def build_reference_resolution_report(ref, issues)
+      {
+        reference: ref,
+        resolved: issues.empty?,
+        issues: issues
+      }
+    end
+
+    def composition_section_ref_read_issues(ref, bundle_resource, entries_resource_types)
+      resource = bundle_resource.resource_by_reference(ref)
+      issues = []
+      issues << "Resource not found for reference: #{ref}" if resource.blank?
+      if resource.present? && !entries_resource_types.include?(resource.resourceType)
+        issues << "Resource type: #{resource.resourceType} is not in the list " \
+                  "of expected resource types: #{entries_resource_types}"
+      end
+      issues
+    end
+
+    def permitted_resource_types(section_metadata)
+      section_metadata[:entries].map do |entry|
+        entry[:profiles].map do |profile|
+          profile.split('|').first
+        end
+      end.flatten.uniq
+    end
+
+    def empty_section_entry_reason_line(section)
+      if section.empty_reason_str.present?
+        "emptyReason: #{section.empty_reason_str}"
+      else
+        'No entries; no emptyReason.'
+      end
+    end
+  end
+end

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

@@ -0,0 +1,127 @@
+# frozen_string_literal: true
+
+require_relative '../inferno_suite_generator_compat'
+require_relative 'composition_section_check_resources_ms_elements_module'
+require_relative 'composition_section_read_issues_helpers_module'
+module AUPSTestKit
+  # Reading composition section rows: profile/entry matching and list outcomes.
+  module BasicTestCompositionSectionReadModule
+    # !!!!!!!!!!
+    # TODO: Remove generator and replace with runtime
+    MANDATORY_SECTIONS_CODES = %w[11450-4 48765-2 10160-0].freeze
+    RECOMMENDED_SECTIONS_CODES = %w[11369-6 30954-2 47519-4 46264-8].freeze
+    OPTIONAL_SECTIONS_CODES = %w[42348-3 104605-1 47420-5 11348-0 10162-6 81338-6 18776-5 29762-2 8716-3].freeze
+
+    include BasicTestCompositionSectionCheckResourcesMSElementsModule
+    include BasicTestCompositionSectionReadIssuesHelpersModule
+
+    private
+
+    def test_composition_mandatory_sections
+      check_bundle_exists_in_scratch
+      test_composition_sections_data(sections_codes: MANDATORY_SECTIONS_CODES, bundle_data: scratch_bundle,
+                                     mandatory: true)
+    end
+
+    def test_composition_recommended_sections
+      check_bundle_exists_in_scratch
+      test_composition_sections_data(sections_codes: RECOMMENDED_SECTIONS_CODES, bundle_data: scratch_bundle)
+    end
+
+    def test_composition_optional_sections
+      check_bundle_exists_in_scratch
+      test_composition_sections_data(sections_codes: OPTIONAL_SECTIONS_CODES, bundle_data: scratch_bundle)
+    end
+
+    def test_composition_sections_data(sections_codes:, bundle_data:, mandatory: false)
+      # Mandatory: true - FN should fail if any mandatory section is not populated correctly.
+      # Unresolved references always fail regardless of mandatory status.
+      bundle_resource = BundleDecorator.new(bundle_data)
+      refs_test_pass = composition_sections_references_resolution_pass?(sections_codes: sections_codes,
+                                                                        bundle_resource: bundle_resource,
+                                                                        mandatory: mandatory)
+      ms_test_pass = composition_section_check_ms_pass?(sections_codes: sections_codes,
+                                                        bundle_resource: bundle_resource,
+                                                        all_present: true)
+
+      assert refs_test_pass, 'Some section entry references cannot be resolved.'
+      assert ms_test_pass,
+             'Some of the sections are not populated with the correct Must Support elements.'
+    end
+
+    def composition_sections_references_resolution_pass?(sections_codes:, bundle_resource:, mandatory: false)
+      composition_resource = bundle_resource.composition_resource
+      sections_metadata = metadata_manager.sections_metadata_by_codes(sections_codes)
+      sections_metadata.map do |section_metadata|
+        composition_section_references_resolution_issues?(section_metadata: section_metadata,
+                                                          composition_resource: composition_resource,
+                                                          bundle_resource: bundle_resource,
+                                                          mandatory: mandatory)
+      end.all?
+    end
+
+    def section_reference_message_level(mandatory:, has_unresolved:)
+      mandatory || has_unresolved ? 'error' : 'warning'
+    end
+
+    def composition_section_references_resolution_issues?(section_metadata:, composition_resource:, bundle_resource:,
+                                                          mandatory:)
+      section_code = section_metadata[:code]
+      section = composition_resource.section_by_code(section_code)
+      issues = read_composition_section_issues(section_metadata, bundle_resource)
+      text = composition_section_read_report_message(section_metadata, section, bundle_resource, section_code)
+      has_unresolved = issues.any? { |issue| issue.start_with?('Resource not found for reference:') }
+      level = section_reference_message_level(mandatory:, has_unresolved:)
+      add_message(issues.empty? ? 'info' : level, text)
+      issues.empty? || (!mandatory && !has_unresolved)
+    end
+
+    def composition_section_read_report_message(section_metadata, section, bundle_resource, section_code)
+      short = section_metadata[:short]
+      header = short.present? ? "#{short} (#{section_code})" : section_code.to_s
+      body = composition_section_read_list_body(section, bundle_resource, section_code, section_metadata)
+      "#{header}\n\n#{body}"
+    end
+
+    def composition_section_read_list_body(section, bundle_resource, section_code, section_metadata)
+      return "No composition section found for code: #{section_code}" if section.blank?
+      return empty_section_entry_reason_line(section) if section.entry_references.empty?
+
+      section.entry_references.each.map do |ref|
+        format_composition_section_entry_line(ref, bundle_resource, section_metadata)
+      end.join("\n\n")
+    end
+
+    def format_composition_section_entry_line(ref, bundle_resource, section_metadata)
+      resource = bundle_resource.resource_by_reference(ref)
+      index = get_section_entry_index(section_metadata, bundle_resource, ref)
+      return composition_section_entry_line_unresolved(ref) if resource.blank?
+      unless permitted_resource_types(section_metadata).include?(resource.resourceType)
+        return composition_section_entry_line_bad_type(index, ref, resource.resourceType)
+      end
+
+      composition_section_entry_line_resolved(index, ref, resource)
+    end
+
+    def get_section_entry_index(section_metadata, bundle_resource, ref)
+      section = bundle_resource.composition_resource.section_by_code(section_metadata[:code])
+      return nil if section.blank?
+
+      section.get_entry_index_by_reference(ref)
+    end
+
+    def composition_section_entry_line_unresolved(ref)
+      "**#{ref}** -> ❌ Reference does not resolve"
+    end
+
+    def composition_section_entry_line_bad_type(index, ref, resource_type)
+      "entry[#{index}]: **#{ref}** -> ❌ Invalid resource type: #{resource_type}"
+    end
+
+    def composition_section_entry_line_resolved(index, ref, resource)
+      profiles = resource.meta&.profile || []
+      suffix = profiles.any? ? "(meta.profile: #{profiles.join(', ')})" : '(no meta.profile)'
+      "entry[#{index}]: **#{ref}** -> #{resource.resourceType} #{suffix}"
+    end
+  end
+end

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

@@ -0,0 +1,84 @@
+# frozen_string_literal: true
+
+module AUPSTestKit
+  # Composition Must Support sub-elements (grouped paths) and parent-group validation on arbitrary resources.
+  module BasicTestCompositionSubelementsModule
+    private
+
+    def validate_populated_sub_elements_in_composition(mandatory_ms, optional_ms)
+      composition_resource = composition_resource_from_scratch
+      return false unless composition_resource.present?
+
+      grouped_elements = (mandatory_ms + optional_ms).group_by { |element| element.split('.').first }
+      run_composition_subelements_assertions(composition_resource, grouped_elements, mandatory_ms)
+    end
+
+    def composition_resource_from_scratch
+      return nil unless scratch_bundle.present?
+
+      BundleDecorator.new(scratch_bundle).composition_resource
+    end
+
+    def run_composition_subelements_assertions(composition_resource, grouped_elements, mandatory_ms)
+      any_parent = composition_any_subelement_parent_populated?(composition_resource, grouped_elements)
+      mandatory_ok = composition_mandatory_subelements_ok?(composition_resource, grouped_elements, mandatory_ms)
+
+      # Error: when any mandatory Must Support sub-elements are missing (i.e. subject.reference and attester.mode).
+      # Warning: when any optional Must Support sub-elements are missing (i.e. attester.time and attester.party)
+      # Info: when all optional Must Support sub-elements are populated
+      # One message for each complex element with Must Support sub-elements, i.e. subject and attester
+      # Include list of Must Support sub-elements populated and missing.
+
+      grouped_elements.each do |parent_path, sub_elements|
+        add_composition_subelements_messages(composition_resource, parent_path, sub_elements, mandatory_ms)
+      end
+
+      skip_if !any_parent, 'No complex element with Must Support sub-elements is populated'
+      msg = 'Some of the mandatory Must Support sub-elements are not populated. ' \
+            'See the list of populated sub-elements in messages tab.'
+      assert mandatory_ok, msg
+    end
+
+    def composition_any_subelement_parent_populated?(composition_resource, grouped_elements)
+      grouped_elements.any? do |parent_path, _|
+        resolve_path_with_dar(composition_resource, parent_path).first.present?
+      end
+    end
+
+    def composition_mandatory_subelements_ok?(composition_resource, grouped_elements, mandatory_ms)
+      grouped_elements.all? do |parent_path, sub_elements|
+        next true unless resolve_path_with_dar(composition_resource, parent_path).first.present?
+
+        (mandatory_ms & sub_elements).all? { |el| resolve_path_with_dar(composition_resource, el).first.present? }
+      end
+    end
+
+    def add_composition_subelements_messages(composition_resource, parent_path, sub_elements, mandatory_ms)
+      unless resolve_path_with_dar(composition_resource, parent_path).first.present?
+        add_message('warning', composition_subelement_parent_unpopulated_message(parent_path, sub_elements))
+        return
+      end
+
+      level = composition_subelements_worst_level(composition_resource, sub_elements, mandatory_ms)
+      add_message(level, populated_paths_info(composition_resource, sub_elements, mandatory_array: mandatory_ms))
+    end
+
+    def composition_subelement_parent_unpopulated_message(parent_path, sub_elements)
+      detail = "**Complex element #{parent_path}** is not populated. " \
+               "Must Support sub-elements that would be validated: #{sub_elements.join(', ')}."
+      ['Must Support sub-elements correctly populated', 'Composition', detail].join("\n\n")
+    end
+
+    def composition_subelements_worst_level(composition_resource, sub_elements, mandatory_ms)
+      levels = sub_elements.map do |sub_element|
+        present = resolve_path_with_dar(composition_resource, sub_element).first.present?
+        next 'info' if present
+
+        mandatory_ms.include?(sub_element) ? 'error' : 'warning'
+      end
+      return 'error' if levels.include?('error')
+
+      levels.include?('warning') ? 'warning' : 'info'
+    end
+  end
+end

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

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+module AUPSTestKit
+  # Internal helpers to keep the populated-message module concise.
+  module BasicTestMsElementsPopulatedHelpersModule
+    private
+
+    def assert_message
+      'When any mandatory Must Support element is missing. See the list in messages tab.'
+    end
+
+    def get_target_metadata_by_container_type(container_type)
+      case container_type
+      when 'subject'
+        metadata_manager.subject_metadata
+      when 'author'
+        metadata_manager.author_metadata
+      when 'custodian'
+        metadata_manager.custodian_metadata
+      when 'attester'
+        metadata_manager.attester_metadata
+      end
+    end
+
+    def get_resource_by_container_type(container_type)
+      case container_type
+      when 'subject'
+        subject_resource
+      when 'author'
+        author_resource
+      when 'custodian'
+        custodian_resource
+      when 'attester'
+        attester_party_resource
+      end
+    end
+  end
+end

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

@@ -0,0 +1,71 @@
+# frozen_string_literal: true
+
+require_relative 'ms_elements_populated_helpers_module'
+
+module AUPSTestKit
+  # Must Support elements populated or missing message.
+  module BasicTestMsElementsPopulatedModule
+    include BasicTestMsElementsPopulatedHelpersModule
+
+    def ms_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)
+
+      resource_metadata_raw = metadata_manager.group_metadata_by_resource_type(resource.resourceType)
+      return unless resource_metadata_raw.present?
+
+      profile_metadata = InfernoSuiteGenerator::Generator::GroupMetadata.new(resource_metadata_raw)
+
+      assert all_ms_mandatory_elements_populated?(resource, profile_metadata), assert_message
+    end
+
+    private
+
+    def all_ms_mandatory_elements_populated?(resource, profile_metadata)
+      ms_checker = InfernoSuiteGenerator::MSChecker.new(profile_metadata)
+      ms_checks_results = elements(ms_checker, [resource])
+      ms_slices_results = slices(ms_checker, [resource])
+      ms_extension_results = extensions(ms_checker, [resource])
+      all_check_results = [*ms_checks_results, *ms_slices_results, *ms_extension_results]
+
+      status = ms_checker.calculate_elements_status_message_level(all_check_results)
+      message = ms_checker.build_report_message(profile_metadata, all_check_results)
+      add_message(status, message.join("\n\n"))
+
+      all_check_results.none? { |result| !result[:present] && result[:mandatory] }
+    end
+
+    def elements(checker, resources)
+      elements_statuses = checker.elements_present_statuses(resources, all_present: false)
+      elements_statuses.filter { |result| element_simple?(result[:path]) }
+    end
+
+    def slices(checker, resources)
+      slices_statuses = checker.slices_present_statuses(resources, all_present: false)
+      slices_statuses.filter { |result| element_simple?(result[:path]) }
+    end
+
+    def extensions(checker, resources)
+      ms_extension_results = checker.extensions_present_statuses(resources, all_present: false)
+      normalized_ms_extension_results(ms_extension_results)
+    end
+
+    def normalized_ms_extension_results(ms_extension_results)
+      ms_extension_results.map do |result|
+        {
+          definition: result[:definition],
+          path: result[:definition][:id].split(':')[-1],
+          present: result[:present],
+          mandatory: false
+        }
+      end
+    end
+
+    def element_simple?(path)
+      !path.include?('.')
+    end
+  end
+end

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

@@ -0,0 +1,61 @@
+# frozen_string_literal: true
+
+module AUPSTestKit
+  # Must Support identifier slices (IHI, DVA, Medicare) on a resource (e.g. Patient).
+  module BasicTestMsIdentifierSlicesModule
+    private
+
+    # Validates Must Support identifier slices (IHI, DVA, Medicare) on a resource (e.g. Patient).
+    # Two messages: (1) Must support identifier slices correctly populated; (2) At least one slice populated.
+    # Pass: all messages info or warning. No error level used.
+    #
+    # @param resource [Hash, FHIR::Model] The resource with identifier array (e.g. Patient)
+    # @param slices [Array<Hash>] Each hash has :name (String) and :system (String URL)
+    def validate_ms_identifier_slices_in_resource(resource, slices)
+      return unless resource.present?
+
+      slice_results = build_ms_identifier_slice_results(identifiers_from_resource(resource) || [], slices)
+      add_ms_identifier_slices_populated_message(slice_results)
+      add_ms_identifier_slices_at_least_one_message(slice_results)
+    end
+
+    def add_ms_identifier_slices_populated_message(slice_results)
+      lines = slice_results.map { |r| ms_identifier_slice_line_with_type(r) }
+      heading = '## List of Must Support identifier slices populated or missing'
+      body = ['Must support identifier slices correctly populated', heading, lines.join("\n\n")].join("\n\n")
+      add_message(slice_results.all? { |r| r[:identifier].present? } ? 'info' : 'warning', body)
+    end
+
+    def add_ms_identifier_slices_at_least_one_message(slice_results)
+      lines = slice_results.map { |r| ms_identifier_slice_line_system_only(r) }
+      heading = '## List of Must Support identifier slices populated or missing (system when populated)'
+      intro = 'At least one Must Support identifier slices is populated'
+      body = [intro, heading, lines.join("\n\n")].join("\n\n")
+      add_message(slice_results.any? { |r| r[:identifier].present? } ? 'info' : 'warning', body)
+    end
+
+    def build_ms_identifier_slice_results(identifiers, slices)
+      slices.map do |slice|
+        ident = find_identifier_by_system(identifiers, slice[:system])
+        { slice: slice, identifier: ident }
+      end
+    end
+
+    def ms_identifier_slice_line_with_type(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 ms_identifier_slice_line_system_only(result)
+      if result[:identifier].present?
+        "✅ Populated: **#{result[:slice][:name]}** — system: #{result[:slice][:system]}"
+      else
+        "⚠️ Missing: **#{result[:slice][:name]}**"
+      end
+    end
+  end
+end