au_core_test_kit 1.4.5 → 1.4.7

data/lib/au_core_test_kit/generator.rb

@@ -1,146 +0,0 @@
-# frozen_string_literal: true
-
-require 'fhir_models'
-require 'inferno/ext/fhir_models'
-
-require_relative 'generator/ig_loader'
-require_relative 'generator/ig_metadata_extractor'
-require_relative 'generator/group_generator'
-require_relative 'generator/must_support_test_generator'
-require_relative 'generator/provenance_revinclude_search_test_generator'
-require_relative 'generator/read_test_generator'
-require_relative 'generator/reference_resolution_test_generator'
-require_relative 'generator/search_test_generator'
-require_relative 'generator/suite_generator'
-require_relative 'generator/validation_test_generator'
-require_relative 'generator/multiple_or_search_test_generator'
-require_relative 'generator/multiple_and_search_test_generator'
-require_relative 'generator/chain_search_test_generator'
-require_relative 'generator/special_identifier_search_test_generator'
-require_relative 'generator/special_identifiers_chain_search_test_generator'
-require_relative 'generator/include_search_test_generator'
-
-module AUCoreTestKit
-  class Generator
-    def self.generate
-      ig_packages = Dir.glob(File.join(Dir.pwd, 'lib', 'au_core_test_kit', 'igs', '*.tgz'))
-
-      ig_packages.each do |ig_package|
-        new(ig_package).generate
-      end
-    end
-
-    attr_accessor :ig_resources, :ig_metadata, :ig_file_name
-
-    def initialize(ig_file_name)
-      self.ig_file_name = ig_file_name
-    end
-
-    def generate
-      puts "Generating tests for IG #{File.basename(ig_file_name)}"
-      load_ig_package
-      extract_metadata
-      generate_search_tests
-      generate_read_tests
-      generate_provenance_revinclude_search_tests
-      generate_include_search_tests
-      generate_validation_tests
-      generate_must_support_tests
-      generate_reference_resolution_tests
-      generate_groups
-      generate_suites
-      use_tests
-    end
-
-    def extract_metadata
-      self.ig_metadata = IGMetadataExtractor.new(ig_resources).extract
-
-      FileUtils.mkdir_p(base_output_dir)
-      File.open(File.join(base_output_dir, 'metadata.yml'), 'w') do |file|
-        file.write(YAML.dump(ig_metadata.to_hash))
-      end
-    end
-
-    def base_output_dir
-      File.join(__dir__, 'generated', ig_metadata.ig_version)
-    end
-
-    def load_ig_package
-      FHIR.logger = Logger.new('/dev/null')
-      self.ig_resources = IGLoader.new(ig_file_name).load
-    end
-
-    def generate_reference_resolution_tests
-      ReferenceResolutionTestGenerator.generate(ig_metadata, base_output_dir)
-    end
-
-    def generate_must_support_tests
-      MustSupportTestGenerator.generate(ig_metadata, base_output_dir)
-    end
-
-    def generate_validation_tests
-      ValidationTestGenerator.generate(ig_metadata, base_output_dir)
-    end
-
-    def generate_read_tests
-      ReadTestGenerator.generate(ig_metadata, base_output_dir)
-    end
-
-    def generate_search_tests
-      SearchTestGenerator.generate(ig_metadata, base_output_dir)
-      generate_multiple_or_search_tests
-      generate_multiple_and_search_tests
-      generate_chain_search_tests
-      generate_special_identifier_search_tests
-      generate_special_identifiers_chain_search_tests
-    end
-
-    def generate_include_search_tests
-      IncludeSearchTestGenerator.generate(ig_metadata, base_output_dir)
-    end
-
-    def generate_provenance_revinclude_search_tests
-      ProvenanceRevincludeSearchTestGenerator.generate(ig_metadata, base_output_dir)
-    end
-
-    def generate_multiple_or_search_tests
-      MultipleOrSearchTestGenerator.generate(ig_metadata, base_output_dir)
-    end
-
-    def generate_multiple_and_search_tests
-      MultipleAndSearchTestGenerator.generate(ig_metadata, base_output_dir)
-    end
-
-    def generate_chain_search_tests
-      ChainSearchTestGenerator.generate(ig_metadata, base_output_dir)
-    end
-
-    def generate_special_identifier_search_tests
-      SpecialIdentifierSearchTestGenerator.generate(ig_metadata, base_output_dir)
-    end
-
-    def generate_special_identifiers_chain_search_tests
-      SpecialIdentifiersChainSearchTestGenerator.generate(ig_metadata, base_output_dir)
-    end
-
-    def generate_groups
-      GroupGenerator.generate(ig_metadata, base_output_dir)
-    end
-
-    def generate_suites
-      SuiteGenerator.generate(ig_metadata, base_output_dir)
-    end
-
-    def use_tests
-      file_path = File.expand_path('../au_core_test_kit.rb', __dir__)
-
-      file_content = File.read(file_path)
-      string_to_add = "require_relative '#{base_output_dir.split('/opt/inferno/lib/').last}/au_core_test_suite'"
-
-      return if file_content.include? string_to_add
-
-      file_content << "\n#{string_to_add}"
-      File.write(file_path, file_content)
-    end
-  end
-end

data/lib/au_core_test_kit/helpers.rb

@@ -1,238 +0,0 @@
-# frozen_string_literal: true
-
-module Helpers
-  DAR_CODE_SYSTEM_URL = 'http://terminology.hl7.org/CodeSystem/data-absent-reason'
-  DAR_EXTENSION_URL = 'http://hl7.org/fhir/StructureDefinition/data-absent-reason'
-
-  def self.test_on_target_resource_data?(special_cases_hash, resource_type, search_param_names)
-    if special_cases_hash.keys.include? resource_type
-      special_cases_hash[resource_type].include? search_param_names
-    end
-  end
-
-  def self.multiple_test_description(multiple_type, conformance_expectation, search_param_name_string, resource_type, url_version)
-    multiple_type_str = multiple_type == 'OR' ? 'multipleOr' : 'multipleAnd' 
-    <<~DESCRIPTION.gsub(/\n{3,}/, "\n\n")
-    A server #{conformance_expectation} support searching by #{multiple_type_str}
-    #{search_param_name_string} on the #{resource_type} resource. This test
-    will pass if resources are returned and match the search criteria. If
-    none are returned, the test is skipped.
-
-    [AU Core Server CapabilityStatement](http://hl7.org.au/fhir/core/#{url_version}/CapabilityStatement-au-core-server.html)
-    DESCRIPTION
-  end
-
-  def self.get_http_header(header_name, header_value)
-    (header_name && header_value) ? {header_name => header_value} : {}
-  end
-
-  def self.extract_extensions_from_resource(resource, extensions = [])
-    resource_hash = convert_resource_to_hash(resource)
-    process_resource_element(resource_hash, extensions)
-    extensions
-  end
-
-  def self.get_capability_statement_group_description_text(title, for_group_description = true)
-    background_title = for_group_description ? '# Background' : '#### Background'
-    testing_methodology_title = for_group_description ? '# Testing Methodology' : '#### Testing Methodology'
-
-    <<~DESCRIPTION
-      #{background_title}
-      The #{title} Sequence tests a FHIR server's ability to formally describe
-      features supported by the API by using the [Capability
-      Statement](https://www.hl7.org/fhir/capabilitystatement.html) resource.
-      The features described in the Capability Statement must be consistent with
-      the required capabilities of a AU Core **Responder**.
-
-      The Capability Statement resource allows clients to determine which
-      resources are supported by a FHIR Server. Not all servers are expected to
-      implement all possible queries and data elements described in the AU Core
-      API. The **AU Core Responder Capability Statement** requires that
-      the Patient resource and **at least** one additional resource profile from the AU Core profiles.
-
-      #{testing_methodology_title}
-
-      This test sequence accesses the server endpoint at `/metadata` using a
-      `GET` request. It parses the Capability Statement and verifies that:
-
-      * The endpoint is secured by an appropriate cryptographic protocol
-      * The resource matches the expected FHIR version defined by the tests
-      * The resource is a valid FHIR resource
-      * The server claims support for JSON encoding of resources
-      * The server claims support for the Patient resource and one other
-        resource
-
-      It collects the following information that is saved in the testing session
-      for use by later tests:
-
-      * List of resources supported
-      * List of queries parameters supported
-    DESCRIPTION
-  end
-
-  def self.get_group_description_text(title, resource_type, profile_name, group_version, profile_url,
-                                      required_searches, search_param_name_string, search_validation_resource_type,
-                                      for_group_description = true)
-    background_title = for_group_description ? '# Background' : '#### Background'
-    testing_methodology_title = for_group_description ? '# Testing Methodology' : '#### Testing Methodology'
-    must_support_title = for_group_description ? '## Must Support' : '##### Must Support'
-    profile_validation_title = for_group_description ? '## Profile Validation' : '##### Profile Validation'
-    reference_validation_title = for_group_description ? '## Reference Validation' : '##### Reference Validation'
-
-    <<~DESCRIPTION
-      #{background_title}
-
-      The AU Core #{title} sequence verifies that the system under test is
-      able to provide correct responses for #{resource_type} queries. These queries
-      must contain resources conforming to the #{profile_name} as
-      specified in the AU Core #{group_version} Implementation Guide.
-
-      #{testing_methodology_title}
-      #{search_description(required_searches, search_param_name_string, search_validation_resource_type, for_group_description, resource_type)}
-
-      #{must_support_title}
-      Each profile contains elements marked as "must support". This test
-      sequence expects to see each of these elements at least once. If at
-      least one cannot be found, the test will fail. The test will look
-      through the #{resource_type} resources found in the first test for these
-      elements.
-
-      #{profile_validation_title}
-      Each resource returned from the first search is expected to conform to
-      the [#{profile_name}](#{profile_url}). Each element is checked against
-      teminology binding and cardinality requirements.
-
-      Elements with a required binding are validated against their bound
-      ValueSet. If the code/system in the element is not part of the ValueSet,
-      then the test will fail.
-
-      #{reference_validation_title}
-      At least one instance of each external reference in elements marked as
-      "must support" within the resources provided by the system must resolve.
-      The test will attempt to read each reference found and will fail if no
-      read succeeds.
-    DESCRIPTION
-  end
-
-  def self.search_description(required_searches, search_param_name_string, search_validation_resource_type, for_group_description, resource_type)
-    return '' if required_searches.blank?
-
-    is_independant_group = ['Practitioner', 'PractitionerRole', 'Location', 'Organization'].include? resource_type
-    basic_search_parameters_text = 'The first search uses the selected patient(s) from the prior launch sequence. Any subsequent searches will look for its parameter values from the results of the first search. For example, the `identifier` search in the patient sequence is performed by looking for an existing `Patient.identifier` from any of the resources returned in the `_id` search. If a value cannot be found this way, the search is skipped.'
-    independant_search_parameters_text = 'Resources for this test group can\'t be found using patient search parameters. This means that in this particular case, the first test will be a read test, not a search. To ensure that this resource will be available for reading, please review the [prerequisites](https://github.com/hl7au/au-fhir-core-inferno/blob/master/docs/pre-requisites.md). Additionally, you can run this test group separately by using specific resource IDs.'
-    search_parameters_text = is_independant_group ? independant_search_parameters_text : basic_search_parameters_text
-
-    searching_title = for_group_description ? '## Searching' : '##### Searching'
-    search_parameters_title = for_group_description ? '### Search Parameters' : '###### Search Parameters'
-    search_validation_title = for_group_description ? '### Search Validation' : '###### Search Validation'
-
-    <<~SEARCH_DESCRIPTION
-      #{searching_title}
-      This test sequence will first perform each required search associated
-      with this resource. This sequence will perform searches with the
-      following parameters:
-
-      #{search_param_name_string}
-
-      #{search_parameters_title}
-      #{search_parameters_text}
-
-      #{search_validation_title}
-      Inferno will retrieve up to the first 20 bundle pages of the reply for
-      #{search_validation_resource_type} and save them for subsequent tests. Each of
-      these resources is then checked to see if it matches the searched
-      parameters in accordance with [FHIR search
-      guidelines](https://www.hl7.org/fhir/search.html). The test will fail,
-      for example, if a Patient search for `gender=male` returns a `female`
-      patient.
-    SEARCH_DESCRIPTION
-  end
-
-  def self.convert_resource_to_hash(resource)
-    if defined?(FHIR) && resource.is_a?(FHIR::Model)
-      resource.source_hash.deep_stringify_keys
-    else
-      resource
-    end
-  end
-
-  def self.process_resource_element(element, extensions)
-    case element
-    when Hash
-      extensions.concat(element['extension']) if element['extension'].is_a?(Array)
-      element.each_value do |value|
-        process_resource_element(value, extensions)
-      end
-    when Array
-      element.each { |item| process_resource_element(item, extensions) }
-    end
-  end
-
-  def self.custom_validation_group_title_text
-    'Custom Validation Group'
-  end
-
-  def self.custom_validation_group_description_text
-    %(
-      This test group is designed to validate the conformity of FHIR resources against specified profiles.
-      Leveraging the dynamic capabilities of FHIR, this validation ensures that the resources adhere to the standards and guidelines established within the relevant AU Core.
-    )
-  end
-
-  def self.custom_validation_test_title_text
-    'Custom validation of the resource'
-  end
-
-  def self.custom_validation_test_input_text
-    'FHIR resource in JSON format (custom validation)'
-  end
-
-  def self.custom_validation_test_description_text
-    %(
-      This test automatically identifies and validates any provided FHIR resource.
-      Users are required to input the FHIR resource in JSON format, referred to as 'resource_json'.
-      The test extracts the applicable profile for validation from the first element in the 'meta.profile' array, located at the path: resource.meta.profile.0.
-      This profile serves as the benchmark for the validation process.
-
-      Given the optional nature of this test, its results do not influence the final outcome of the test report.
-    )
-  end
-
-  def self.custom_validation_test_info_resource_type_text(resource_type)
-    "Resource type to validate is #{resource_type}"
-  end
-
-  def self.custom_validation_test_info_profile_text(fhir_resource_profile)
-    "Resource profile to validate is #{fhir_resource_profile}"
-  end
-
-  def self.custom_validation_test_info_ig_text(ig_version)
-    "IG version to validate is #{ig_version}"
-  end
-
-  def self.default_patient_ids_string
-    'baratz-toni, irvine-ronny-lawrence, italia-sofia, howe-deangelo, hayes-arianne, baby-banks-john, banks-mia-leanne'
-  end
-
-  def self.check_for_dar(resource)
-    resource.each_element do |element, _meta, path|
-      next unless element.is_a?(FHIR::Coding)
-
-      return true if (element.code == 'masked' || element.code == 'unknown') && element.system == DAR_CODE_SYSTEM_URL
-    end
-
-    false
-  end
-
-  def self.check_for_dar_extension(resource)
-    return resource.source_contents&.include? DAR_EXTENSION_URL
-  end
-
-  def self.return_uniq_list_resources(resource_list)
-    return resource_list.uniq
-  end
-
-  def self.is_message_exist_in_list(message_list, message)
-    message_list.any? { |list_message| message.include? list_message }
-  end
-end

data/lib/au_core_test_kit/must_support_test.rb

@@ -1,221 +0,0 @@
-# frozen_string_literal: true
-
-require_relative 'fhir_resource_navigation'
-require_relative 'helpers'
-require_relative 'assert_helpers'
-
-module AUCoreTestKit
-  module MustSupportTest
-    extend Forwardable
-    include FHIRResourceNavigation
-    include AssertHelpers
-
-    def_delegators 'self.class', :metadata
-
-    def all_scratch_resources
-      scratch_resources[:all]
-    end
-
-    def perform_must_support_test(resources)
-      conditional_skip_with_msg resources.blank?, "No #{resource_type} resources were found"
-
-      missing_elements(resources)
-      missing_slices(resources)
-      missing_extensions(resources)
-
-      handle_must_support_choices if metadata.must_supports[:choices].present?
-
-      pass if (missing_elements + missing_slices + missing_extensions).empty?
-      skip_with_msg "Could not find #{missing_must_support_strings.join(', ')} element(s) in the #{resources.length} " \
-           "provided #{resource_type} resource(s). To prevent this issue, please add the missing must support "\
-           "elements to at least one #{resource_type} resource on the server."
-    end
-
-    def handle_must_support_choices
-      missing_elements.delete_if do |element|
-        choices = metadata.must_supports[:choices].find { |choice| choice[:paths]&.include?(element[:path]) }
-        is_any_choice_supported?(choices)
-      end
-
-      missing_extensions.delete_if do |extension|
-        choices = metadata.must_supports[:choices].find { |choice| choice[:extension_ids]&.include?(extension[:id]) }
-        is_any_choice_supported?(choices)
-      end
-
-      missing_slices.delete_if do |slice|
-        choices = metadata.must_supports[:choices].find { |choice| choice[:slice_names]&.include?(slice[:name]) }
-        is_any_choice_supported?(choices)
-      end
-    end
-
-    def is_any_choice_supported?(choices)
-      choices.present? &&
-        (
-          choices[:paths]&.any? { |path| missing_elements.none? { |element| element[:path] == path } } ||
-          choices[:extension_ids]&.any? do |extension_id|
-            missing_extensions.none? do |extension|
-              extension[:id] == extension_id
-            end
-          end ||
-          choices[:slice_names]&.any? { |slice_name| missing_slices.none? { |slice| slice[:name] == slice_name } }
-        )
-    end
-
-    def missing_must_support_strings
-      result = missing_elements.map { |element_definition| missing_element_string(element_definition) } +
-        missing_slices.map { |slice_definition| slice_definition[:slice_id] } +
-        missing_extensions.map { |extension_definition| extension_definition[:id] }
-
-      result.map { |missing_element| "'#{missing_element}'" }
-    end
-
-    def missing_element_string(element_definition)
-      if element_definition[:fixed_value].present?
-        "#{element_definition[:path]}:#{element_definition[:fixed_value]}"
-      else
-        element_definition[:path]
-      end
-    end
-
-    def exclude_uscdi_only_test?
-      config.options[:exclude_uscdi_only_test] == true
-    end
-
-    def must_support_extensions
-      if exclude_uscdi_only_test?
-        metadata.must_supports[:extensions].reject { |extension| extension[:uscdi_only] }
-      else
-        metadata.must_supports[:extensions]
-      end
-    end
-
-    def missing_extensions(resources = [])
-      @missing_extensions ||=
-        must_support_extensions.select do |extension_definition|
-          resources.none? do |resource|
-            resource_extensions_url_arr = Helpers.extract_extensions_from_resource(resource).map { |ext| ext['url'] }
-            resource_extensions_url_arr.include? extension_definition[:url]
-          end
-        end
-    end
-
-    def must_support_elements
-      if exclude_uscdi_only_test?
-        metadata.must_supports[:elements].reject { |element| element[:uscdi_only] }
-      else
-        metadata.must_supports[:elements]
-      end
-    end
-
-    def missing_elements(resources = [])
-      @missing_elements ||=
-        must_support_elements.select do |element_definition|
-          resources.none? do |resource|
-            path = element_definition[:path] # .delete_suffix('[x]')
-            value_found = find_a_value_at(resource, path) do |value|
-              value_without_extensions =
-                value.respond_to?(:to_hash) ? value.to_hash.reject { |key, _| key == 'extension' } : value
-
-              (value_without_extensions.present? || value_without_extensions == false) &&
-                (element_definition[:fixed_value].blank? || value == element_definition[:fixed_value])
-            end
-            # Note that false.present? => false, which is why we need to add this extra check
-            value_found.present? || value_found == false
-          end
-        end
-      @missing_elements
-    end
-
-    def must_support_slices
-      if exclude_uscdi_only_test?
-        metadata.must_supports[:slices].reject { |slice| slice[:uscdi_only] }
-      else
-        metadata.must_supports[:slices]
-      end
-    end
-
-    def missing_slices(resources = [])
-      @missing_slices ||=
-        must_support_slices.select do |slice|
-          resources.none? do |resource|
-            path = slice[:path] # .delete_suffix('[x]')
-            find_slice(resource, path, slice[:discriminator]).present?
-          end
-        end
-    end
-
-    def find_slice(resource, path, discriminator)
-      find_a_value_at(resource, path) do |element|
-        case discriminator[:type]
-        when 'patternCodeableConcept'
-          coding_path = discriminator[:path].present? ? "#{discriminator[:path]}.coding" : 'coding'
-          find_a_value_at(element, coding_path) do |coding|
-            coding.code == discriminator[:code] && coding.system == discriminator[:system]
-          end
-        when 'patternCoding'
-          coding_path = discriminator[:path].present? ? discriminator[:path] : ''
-          find_a_value_at(element, coding_path) do |coding|
-            coding.code == discriminator[:code] && coding.system == discriminator[:system]
-          end
-        when 'patternIdentifier'
-          find_a_value_at(element, discriminator[:path]) { |identifier| identifier.system == discriminator[:system] }
-        when 'value'
-          values = discriminator[:values].map { |value| value.merge(path: value[:path].split('.')) }
-          find_slice_by_values(element, values)
-        when 'type'
-          case discriminator[:code]
-          when 'Date'
-            begin
-              Date.parse(element)
-            rescue ArgumentError
-              false
-            end
-          when 'DateTime'
-            begin
-              DateTime.parse(element)
-            rescue ArgumentError
-              false
-            end
-          when 'String'
-            element.is_a? String
-          else
-            element.is_a? FHIR.const_get(discriminator[:code])
-          end
-        when 'requiredBinding'
-          coding_path = discriminator[:path].present? ? "#{discriminator[:path]}.coding" : 'coding'
-          find_a_value_at(element, coding_path) { |coding| discriminator[:values].include?(coding.code) }
-        end
-      end
-    end
-
-    def find_slice_by_values(element, value_definitions)
-      path_prefixes = value_definitions.map { |value_definition| value_definition[:path].first }.uniq
-      Array.wrap(element).find do |el|
-        path_prefixes.all? do |path_prefix|
-          value_definitions_for_path =
-            value_definitions
-            .select { |value_definition| value_definition[:path].first == path_prefix }
-            .each { |value_definition| value_definition[:path].shift }
-
-          find_a_value_at(el, path_prefix) do |el_found|
-            child_element_value_definitions, current_element_value_definitions =
-              value_definitions_for_path.partition { |value_definition| value_definition[:path].present? }
-
-            current_element_values_match =
-              current_element_value_definitions
-              .all? { |value_definition| value_definition[:value] == el_found }
-
-            child_element_values_match =
-              if child_element_value_definitions.present?
-                find_slice_by_values(el_found, child_element_value_definitions)
-              else
-                true
-              end
-
-            current_element_values_match && child_element_values_match
-          end
-        end
-      end
-    end
-  end
-end

data/lib/au_core_test_kit/provenance_validator.rb

@@ -1,38 +0,0 @@
-# frozen_string_literal: true
-
-module AUCoreTestKit
-  class ProvenanceValidator
-    include FHIRResourceNavigation
-
-    def self.validate(...)
-      new(...).validate
-    end
-
-    attr_reader :resource, :validation_messages
-
-    def initialize(resource)
-      @resource = resource
-      @validation_messages = []
-    end
-
-    def validate
-      # Invariant provenance-1 in AU Core 5 causes validation error. See FHIR-39518
-      return validation_messages unless resource.instance_of?(FHIR::Provenance)
-
-      failed_provenance =
-        find_a_value_at(resource, 'agent') do |agent|
-          %w[Practitioner Device].any? { |resource_type| agent.who.reference&.include?(resource_type) } &&
-            agent.onBehalfOf.nil?
-        end
-
-      if failed_provenance.present?
-        validation_messages << {
-          type: 'error',
-          message: "#{resource.resourceType}/#{resource.id}: Rule provenance-1: 'onBehalfOf SHALL be present when Provenance.agent.who is a Practitioner or Device' Failed"
-        }
-      end
-
-      validation_messages
-    end
-  end
-end