au_ps_inferno 0.1.0

data/lib/au_ps_inferno/suite/retrieve_au_ps_bundle_validation_tests/bundle_validation/suite_retrieve_au_ps_bundle_validation_tests_bundle_validation_bundle_valid.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+require_relative '../../../utils/basic_test_class'
+require_relative '../../../utils/metadata_manager'
+
+require_relative '../../../utils/retrieve_bundle_test_class'
+
+require_relative '../../../utils/ips_retrieve_bundle_test_class'
+
+module AUPSTestKit
+  # Automatically generated primitive test for Retrieved Bundle is valid against AU PS Bundle profile
+  class AUPSSuiteRetrieveAuPsBundleValidationTestsBundleValidationRetrievedBundleIsValidAgainstAuPsBundleProfile < RetrieveBundleTestClass
+    title 'Retrieved Bundle is valid against AU PS Bundle profile'
+    description 'Verifies that a bundle retrieved from the server conforms to the AU PS Bundle profile.'
+    id :suite_retrieve_au_ps_bundle_validation_tests_bundle_validation_bundle_valid
+
+    def metadata_manager
+      @metadata_manager ||= MetadataManager.new(File.expand_path('../../../metadata.yaml', __dir__))
+    end
+  end
+end

data/lib/au_ps_inferno/suite/retrieve_au_ps_bundle_validation_tests/bundle_validation/suite_retrieve_au_ps_bundle_validation_tests_bundle_validation_bundle_valid_ips.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+require_relative '../../../utils/basic_test_class'
+require_relative '../../../utils/metadata_manager'
+
+require_relative '../../../utils/retrieve_bundle_test_class'
+
+require_relative '../../../utils/ips_retrieve_bundle_test_class'
+
+module AUPSTestKit
+  # Automatically generated primitive test for Retrieved Bundle is valid against IPS Bundle profile
+  class AUPSSuiteRetrieveAuPsBundleValidationTestsBundleValidationRetrievedBundleIsValidAgainstIpsBundleProfile < IpsRetrieveBundleTestClass
+    title 'Retrieved Bundle is valid against IPS Bundle profile'
+    description 'Verifies that a bundle retrieved from the server conforms to the IPS Bundle profile.'
+    id :suite_retrieve_au_ps_bundle_validation_tests_bundle_validation_bundle_valid_ips
+
+    def metadata_manager
+      @metadata_manager ||= MetadataManager.new(File.expand_path('../../../metadata.yaml', __dir__))
+    end
+  end
+end

data/lib/au_ps_inferno/suite/retrieve_au_ps_bundle_validation_tests/bundle_validation.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+require_relative 'bundle_validation/suite_retrieve_au_ps_bundle_validation_tests_bundle_validation_bundle_valid'
+
+require_relative 'bundle_validation/suite_retrieve_au_ps_bundle_validation_tests_bundle_validation_bundle_valid_ips'
+
+module AUPSTestKit
+  # Automatically generated primitive group for Bundle Validation
+  class AUPSSuiteRetrieveAuPsBundleValidationTestsBundleValidation < Inferno::TestGroup
+    title 'Bundle Validation'
+    description 'Validates that the bundle conforms to the Bundle profiles.'
+    id :suite_retrieve_au_ps_bundle_validation_tests_bundle_validation
+
+    run_as_group
+
+    test from: :suite_retrieve_au_ps_bundle_validation_tests_bundle_validation_bundle_valid
+
+    test from: :suite_retrieve_au_ps_bundle_validation_tests_bundle_validation_bundle_valid_ips
+  end
+end

data/lib/au_ps_inferno/suite/retrieve_au_ps_bundle_validation_tests/retrieve_au_ps_bundle_validation_tests.rb

@@ -0,0 +1,56 @@
+# frozen_string_literal: true
+
+require_relative 'bundle_validation'
+
+require_relative 'au_ps_bundle_must_support_conformance'
+
+require_relative 'au_ps_composition_must_support_conformance'
+
+require_relative 'au_ps_composition_mandatory_sections'
+
+require_relative 'au_ps_composition_recommended_sections'
+
+require_relative 'au_ps_composition_optional_sections'
+
+require_relative 'au_ps_composition_undefined_sections'
+
+require_relative 'au_ps_composition_subject'
+
+require_relative 'au_ps_composition_author'
+
+require_relative 'au_ps_composition_custodian'
+
+require_relative 'au_ps_composition_attester'
+
+module AUPSTestKit
+  # Automatically generated high order group for Retrieve AU PS Bundle validation tests
+  class AUPSSuiteRetrieveAuPsBundleValidationTests < Inferno::TestGroup
+    title 'Retrieve AU PS Bundle validation tests'
+    description 'Retrieve document Bundle using Bundle read interaction or other HTTP GET request and verify response is valid AU PS Bundle'
+    id :suite_retrieve_au_ps_bundle_validation_tests
+
+    run_as_group
+
+    group from: :suite_retrieve_au_ps_bundle_validation_tests_bundle_validation
+
+    group from: :suite_retrieve_au_ps_bundle_validation_tests_au_ps_bundle_must_support_conformance
+
+    group from: :suite_retrieve_au_ps_bundle_validation_tests_au_ps_composition_must_support_conformance
+
+    group from: :suite_retrieve_au_ps_bundle_validation_tests_au_ps_composition_mandatory_sections
+
+    group from: :suite_retrieve_au_ps_bundle_validation_tests_au_ps_composition_recommended_sections
+
+    group from: :suite_retrieve_au_ps_bundle_validation_tests_au_ps_composition_optional_sections
+
+    group from: :suite_retrieve_au_ps_bundle_validation_tests_au_ps_composition_undefined_sections
+
+    group from: :suite_retrieve_au_ps_bundle_validation_tests_au_ps_composition_subject
+
+    group from: :suite_retrieve_au_ps_bundle_validation_tests_au_ps_composition_author
+
+    group from: :suite_retrieve_au_ps_bundle_validation_tests_au_ps_composition_custodian
+
+    group from: :suite_retrieve_au_ps_bundle_validation_tests_au_ps_composition_attester
+  end
+end

data/lib/au_ps_inferno/utils/attester/basic_test_attester_identifier_slices.rb

@@ -0,0 +1,74 @@
+# frozen_string_literal: true
+
+require_relative '../basic_test_contants_module'
+
+module AUPSTestKit
+  # Must Support identifier slice validation for Composition attester.party reference.
+  module BasicTestAttesterIdentifierSlices
+    include BasicTestConstants
+
+    def validate_attester_party_ms_identifier_slices(resource, slices, resource_type_str, profile_str)
+      return unless resource.present? && slices.present?
+
+      identifiers = identifiers_from_resource(resource) || []
+      slice_results = attester_party_build_slice_results(slices, identifiers)
+      header = attester_party_referenced_type_profile_header(resource_type_str, profile_str)
+      lines = slice_results.map { |r| attester_party_format_identifier_slice_line(r) }
+      message_type = slice_results.all? { |r| r[:identifier].present? } ? 'info' : 'warning'
+      add_message(message_type, attester_party_identifier_slices_full_message(header, lines))
+    end
+
+    def test_composition_attester_party_ms_identifier_slices
+      check_bundle_exists_in_scratch
+      resource = attester_party_resource
+      skip_if resource.blank?, 'Attester or attester.party is not populated'
+
+      resource_type_str = resource_type(resource)
+      slices = AUTHOR_MS_IDENTIFIER_SLICES_BY_TYPE[resource_type_str] || []
+      skip_if slices.blank?, 'Referenced attester.party resource type has no Must Support identifier slices'
+
+      rtype_str, profile_str = author_resource_type_and_profiles(resource)
+      validate_attester_party_ms_identifier_slices(resource, slices, rtype_str, profile_str)
+    end
+
+    private
+
+    def attester_party_build_slice_results(slices, identifiers)
+      slices.map do |slice|
+        ident = find_identifier_by_system(identifiers, slice[:system])
+        { slice: slice, identifier: ident }
+      end
+    end
+
+    def attester_party_format_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 attester_party_identifier_slices_full_message(header, lines)
+      attester_party_join_message_sections(
+        attester_party_identifier_slices_message_parts(header, lines)
+      )
+    end
+
+    def attester_party_identifier_slices_message_parts(header, lines)
+      [
+        'Must support identifier slices correctly populated', '',
+        header, '',
+        attester_party_identifier_slices_heading, '',
+        lines.join("\n\n")
+      ]
+    end
+
+    def attester_party_identifier_slices_heading
+      [
+        '## List of Must Support identifier slices populated or missing',
+        '(type and system when populated)'
+      ].join(' ')
+    end
+  end
+end

data/lib/au_ps_inferno/utils/attester/basic_test_attester_message_helpers.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+module AUPSTestKit
+  # Shared message formatting helpers for attester.party Must Support validation modules.
+  module BasicTestAttesterMessageHelpers
+    private
+
+    def attester_party_join_message_sections(parts)
+      parts.join("\n\n")
+    end
+
+    def attester_party_referenced_type_profile_header(resource_type_str, profile_str)
+      "**Referenced attester.party**: #{resource_type_str}#{" — #{profile_str}" if profile_str.present?}"
+    end
+  end
+end

data/lib/au_ps_inferno/utils/attester/basic_test_attester_module.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+require_relative 'basic_test_attester_message_helpers'
+require_relative 'basic_test_attester_resource'
+require_relative 'basic_test_attester_identifier_slices'
+
+module AUPSTestKit
+  # Composes attester.party Must Support validation helpers for BasicTest.
+  module BasicTestAttesterModule
+    include BasicTestAttesterMessageHelpers
+    include BasicTestAttesterResource
+    include BasicTestAttesterIdentifierSlices
+  end
+end

data/lib/au_ps_inferno/utils/attester/basic_test_attester_resource.rb

@@ -0,0 +1,54 @@
+# frozen_string_literal: true
+
+require_relative '../bundle_decorator'
+
+module AUPSTestKit
+  # Resolves Composition attester.party reference from the scratch bundle and loads attester metadata.
+  module BasicTestAttesterResource
+    def attester_party_resource
+      return nil unless scratch_bundle.present?
+
+      ref_str = attester_party_ref_from_bundle(BundleDecorator.new(scratch_bundle))
+      return nil if ref_str.blank?
+
+      bundle_entity_resource_from_scratch(ref_str)
+    end
+
+    private
+
+    def attester_composition_attesters(composition_resource)
+      composition_resource.respond_to?(:attester) ? composition_resource.attester : nil
+    end
+
+    def attester_party_for_attester(attester)
+      attester.respond_to?(:party) ? attester.party : attester['party']
+    end
+
+    def find_first_attester_with_party(attesters)
+      attesters.find { |a| attester_party_for_attester(a).present? }
+    end
+
+    def attester_party_reference_from_attester(attester_with_party)
+      party_ref = attester_party_for_attester(attester_with_party)
+      return nil if party_ref.blank?
+
+      party_ref.respond_to?(:reference) ? party_ref.reference : party_ref['reference']
+    end
+
+    def attester_party_ref_from_bundle(bundle_resource)
+      composition_resource = bundle_resource.composition_resource
+      return nil unless composition_resource.present?
+
+      attesters = attester_composition_attesters(composition_resource)
+      return nil if attesters.blank?
+
+      attester_with_party = find_first_attester_with_party(attesters)
+      return nil unless attester_with_party.present?
+
+      ref_str = attester_party_reference_from_attester(attester_with_party)
+      return nil if ref_str.blank?
+
+      ref_str
+    end
+  end
+end

data/lib/au_ps_inferno/utils/author/basic_test_author_module.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+require_relative 'basic_test_author_resource'
+require_relative 'basic_test_author_tests'
+
+module AUPSTestKit
+  # Composes Composition author Must Support helpers for BasicTest.
+  module BasicTestAuthorModule
+    include BasicTestAuthorResource
+    include BasicTestAuthorTests
+  end
+end

data/lib/au_ps_inferno/utils/author/basic_test_author_resource.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+require_relative '../bundle_decorator'
+
+module AUPSTestKit
+  # Resolves Composition.author reference from the scratch bundle.
+  module BasicTestAuthorResource
+    def author_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?
+
+      author_ref = first_composition_author_reference(composition_resource)
+      return nil unless author_ref.present?
+
+      ref_str = author_ref.respond_to?(:reference) ? author_ref.reference : author_ref['reference']
+      return nil if ref_str.blank?
+
+      bundle_entity_resource_from_scratch(ref_str)
+    end
+
+    private
+
+    def first_composition_author_reference(composition_resource)
+      return nil unless composition_resource.respond_to?(:author) && composition_resource.author.present?
+
+      composition_resource.author.first
+    end
+  end
+end

data/lib/au_ps_inferno/utils/author/basic_test_author_tests.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+require_relative '../basic_test_contants_module'
+
+module AUPSTestKit
+  # Inferno tests for Composition.author Must Support.
+  module BasicTestAuthorTests
+    include BasicTestConstants
+
+    def test_composition_author_ms_identifier_slices
+      guard_populated_resource('author')
+
+      resource = author_resource
+      author_and_device_resource?('author', resource)
+      resource_type_str = resource_type(resource)
+      slices = AUTHOR_MS_IDENTIFIER_SLICES_BY_TYPE[resource_type_str] || []
+      omit_if slices.blank?,
+              'No Must Support identifier slices are defined for the referenced author type (e.g. AU PS RelatedPerson)'
+
+      # rtype_str, profile_str = author_resource_type_and_profiles(resource)
+      validate_ms_identifier_slices_in_resource(resource, slices)
+    end
+  end
+end

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

@@ -0,0 +1,87 @@
+# frozen_string_literal: true
+
+require_relative '../../version'
+
+module AUPSTestKit
+  # Bundle-level checks, mandatory MS list info, and IPS bundle profile validation.
+  module BasicTestBundleModule
+    def bundle_mandatory_ms_elements_info
+      check_bundle_exists_in_scratch
+      passed = [identifier_info?, type_info?, timestamp_info?, all_entries_have_full_url_info?].all?
+      message_type = passed ? 'info' : 'error'
+      add_message(message_type,
+                  "**List mandatory Must Support elements populated and missing**:\n\n#{mandatory_ms_elements_info}")
+      info "**List any entry resources by type (and meta.profile if exists)**:\n\n#{entry_resources_info}"
+      assert passed, 'Mandatory Must Support elements are not populated'
+    end
+
+    def mandatory_ms_elements_info
+      [
+        "**identifier**: #{boolean_to_existent_string(identifier_info?)}",
+        "**type**: #{boolean_to_existent_string(type_info?)}",
+        "**timestamp**: #{boolean_to_existent_string(timestamp_info?)}",
+        "**All entry exists fullUrl**: #{boolean_to_existent_string(all_entries_have_full_url_info?)}"
+      ].join("\n\n")
+    end
+
+    def skip_validation?
+      false
+    end
+
+    def validate_au_ps_bundle
+      validate_bundle_wrapper("http://hl7.org.au/fhir/ps/StructureDefinition/au-ps-bundle|#{AUPSTestKit::IG_VERSION}")
+    end
+
+    def validate_ips_bundle
+      validate_bundle_wrapper('http://hl7.org/fhir/uv/ips/StructureDefinition/Bundle-uv-ips')
+    end
+
+    private
+
+    def validate_bundle_wrapper(profile_with_version)
+      check_bundle_exists_in_scratch
+      validate_bundle(
+        scratch_bundle,
+        profile_with_version
+      )
+    end
+
+    def validate_bundle(resource, profile_with_version)
+      return if skip_validation?
+
+      show_validator_version
+
+      resource_is_valid?(resource: resource, profile_url: profile_with_version)
+      errors_found = messages.any? { |message| message[:type] == 'error' }
+      add_validation_errors_to_scratch if errors_found
+      assert !errors_found, "Resource does not conform to the profile #{profile_with_version}"
+    end
+
+    def error_messages
+      messages.select { |message| message[:type] == 'error' }
+    end
+
+    def add_validation_errors_to_scratch
+      existing_validation_errors = scratch[:validation_errors] || []
+      error_messages.each do |message|
+        existing_validation_errors << build_scratch_validation_error(message)
+      end
+      scratch[:validation_errors] = existing_validation_errors.compact.uniq
+    end
+
+    def build_scratch_validation_error(message)
+      match = message[:message].match(/Bundle.entry\[(\d+)\]/)
+      return nil if match.nil?
+
+      filtered_entry = scratch_bundle.entry[match[1].to_i]
+      resource = filtered_entry.resource
+
+      {
+        full_url: filtered_entry.fullUrl,
+        id: resource.id,
+        resource_type: resource.resourceType,
+        error_message: message[:message]
+      }
+    end
+  end
+end

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

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+module AUPSTestKit
+  # CapabilityStatement operation discovery (summary, docref, etc.).
+  module BasicTestCapabilityOperationsModule
+    def operation_defined?(operations, op_def_url, names_arr, scratch_key)
+      operation_defined = operations.any? do |operation|
+        operation.definition == op_def_url || names_arr.include?(operation.name.downcase)
+      end
+
+      message_base = 'Server CapabilityStatement declares support for operation with operation definition'
+
+      info "#{message_base} #{op_def_url}: #{boolean_to_existent_string(operation_defined)}"
+
+      scratch[scratch_key] = operation_defined
+    end
+
+    def operations
+      fhir_get_capability_statement
+      scratch[:capability_statement] = resource
+      resource.rest&.flat_map do |rest|
+        select_op(rest)
+      end&.compact
+    end
+
+    def select_op(rest)
+      rest.resource
+          &.select { |res| res.respond_to?(:operation) }
+          &.flat_map(&:operation)
+    end
+
+    def summary_op_defined?
+      operation_defined?(operations, 'http://hl7.org/fhir/uv/ips/OperationDefinition/summary',
+                         %w[summary patient-summary], :summary_op_defined)
+    end
+  end
+end

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

@@ -0,0 +1,98 @@
+# frozen_string_literal: true
+
+module AUPSTestKit
+  # Composition Must Support elements and optional slices (e.g. event:careProvisioningEvent).
+  module BasicTestCompositionElementsAndSlicesModule
+    private
+
+    def validate_populated_elements_in_composition(elements_array, required: true)
+      composition_resource = composition_resource_from_scratch
+      return false unless composition_resource.present?
+
+      result = all_paths_are_populated?(composition_resource, elements_array)
+      msg_type = composition_elements_message_type(result, required)
+      add_message(msg_type,
+                  populated_paths_info(composition_resource, elements_array,
+                                       mandatory_array: required ? elements_array : []))
+      assert_composition_elements_if_required(result, required)
+    end
+
+    def composition_elements_message_type(result, required)
+      return 'info' if result
+
+      required ? 'error' : 'warning'
+    end
+
+    def assert_composition_elements_if_required(result, required)
+      return unless required
+
+      assert result,
+             'Some of the elements are not populated. See the list of populated elements in messages tab.'
+    end
+
+    def validate_populated_slices_in_composition(slices_array)
+      return false unless scratch_bundle.present?
+
+      composition_resource = BundleDecorator.new(scratch_bundle).composition_resource
+      return false unless composition_resource.present?
+
+      check_event_slice_presence(composition_resource, slices_array)
+    end
+
+    def check_event_slice_presence(composition_resource, slices_array)
+      event = composition_resource.event_by_code('PCPR')
+
+      if event.nil?
+        add_message('warning', 'event:careProvisioningEvent slice is not present')
+        assert true
+      else
+        slices_array.all? do |slice|
+          composition_slice_validation_passes?(composition_resource, slice, event)
+        end
+      end
+    end
+
+    def composition_slice_validation_passes?(composition_resource, slice, event)
+      paths = composition_slice_element_paths(slice)
+      message_data = populated_paths_info(composition_resource, paths[:combined], mandatory_array: paths[:required])
+      full_data = composition_slice_full_message_data(message_data)
+      return false unless composition_slice_required_paths_ok?(composition_resource, paths, full_data)
+
+      composition_slice_optional_and_event_outcome?(composition_resource, paths, full_data, message_data, event)
+    end
+
+    def composition_slice_full_message_data(message_data)
+      "#{message_data}\n\nSlice: **event:careProvisioningEvent**"
+    end
+
+    def composition_slice_required_paths_ok?(composition_resource, paths, full_data)
+      return true if all_paths_are_populated?(composition_resource, paths[:required])
+
+      add_message('warning', full_data)
+      false
+    end
+
+    def composition_slice_optional_and_event_outcome?(composition_resource, paths, full_data, message_data, event)
+      unless all_paths_are_populated?(composition_resource, paths[:optional])
+        add_message('warning', full_data)
+        return true
+      end
+      return composition_slice_warn_if_event_nil?(message_data) if event.nil?
+
+      add_message('info', full_data)
+      true
+    end
+
+    def composition_slice_warn_if_event_nil?(message_data)
+      add_message('warning', message_data)
+      true
+    end
+
+    def composition_slice_element_paths(slice)
+      base = slice[:path]
+      required = slice[:mandatory_ms_sub_elements].map { |el| "#{base}.#{el}" }
+      optional = slice[:optional_ms_sub_elements].map { |el| "#{base}.#{el}" }
+      { required: required, optional: optional, combined: required + optional }
+    end
+  end
+end