au_core_test_kit 1.4.5 → 1.4.7

data/lib/au_core_test_kit/search_test_helpers.rb

@@ -1,21 +0,0 @@
-# frozen_string_literal: true
-
-module SearchTestHelpers
-  def self.search_by_reference?(search_param)
-    search_param = search_param.transform_keys(&:to_s)
-    search_param.keys.map { |key| search_param_is_reference?(search_param[key]) }.include?(true)
-  end
-
-  def self.replace_full_reference_search_param_to_id(search_param)
-    search_param = search_param.transform_keys(&:to_s)
-    search_param.each_key do |key|
-      search_param[key] = search_param[key].split('/').last if search_param_is_reference?(search_param[key])
-    end
-    search_param
-  end
-
-  def self.search_param_is_reference?(single_search_param)
-    single_search_param = single_search_param.to_s
-    single_search_param.include?('/') && single_search_param.split('/').length == 2
-  end
-end

data/lib/au_core_test_kit/search_test_properties.rb

@@ -1,67 +0,0 @@
-# frozen_string_literal: true
-
-module AUCoreTestKit
-  class SearchTestProperties
-    ATTRIBUTES = %i[
-      resource_type
-      search_param_names
-      first_search
-      fixed_value_search
-      saves_delayed_references
-      possible_status_search
-      test_medication_inclusion
-      token_search_params
-      test_reference_variants
-      params_with_comparators
-      multiple_or_search_params
-      optional_multiple_or_search_params
-      multiple_and_search_params
-      optional_multiple_and_search_params
-      test_post_search
-      attr_paths
-      target_identifier
-      first_search_for_patient_by_patient_id
-      includes
-      use_any_data_for_search
-      search_by_target_resource_data
-    ].freeze
-
-    ATTRIBUTES.each { |name| attr_reader name }
-
-    def initialize(**properties)
-      properties.each do |key, value|
-        raise StandardError, "Unkown search test property: #{key}" unless ATTRIBUTES.include?(key)
-
-        instance_variable_set(:"@#{key}", value)
-      end
-    end
-
-    def first_search?
-      !!first_search
-    end
-
-    def fixed_value_search?
-      !!fixed_value_search
-    end
-
-    def saves_delayed_references?
-      !!saves_delayed_references
-    end
-
-    def possible_status_search?
-      !!possible_status_search
-    end
-
-    def test_medication_inclusion?
-      !!test_medication_inclusion
-    end
-
-    def test_reference_variants?
-      !!test_reference_variants
-    end
-
-    def test_post_search?
-      !!test_post_search
-    end
-  end
-end

data/lib/au_core_test_kit/special_identifier_search_test.rb

@@ -1,94 +0,0 @@
-# frozen_string_literal: true
-
-require_relative 'search_test_properties'
-require_relative 'search_test'
-require_relative 'assert_helpers'
-
-module AUCoreTestKit
-  module SpecialIdentifierSearchTest
-    extend Forwardable
-    include SearchTest
-    include AssertHelpers
-
-    def_delegators 'self.class', :metadata, :provenance_metadata, :properties
-    def_delegators 'properties',
-                   :resource_type,
-                   :search_param_names,
-                   :saves_delayed_references?,
-                   :first_search?,
-                   :fixed_value_search?,
-                   :possible_status_search?,
-                   :test_medication_inclusion?,
-                   :test_post_search?,
-                   :token_search_params,
-                   :test_reference_variants?,
-                   :params_with_comparators,
-                   :multiple_or_search_params,
-                   :optional_multiple_or_search_params,
-                   :multiple_and_search_params,
-                   :optional_multiple_and_search_params,
-                   :target_identifier
-
-    def all_search_params
-      @all_search_params ||=
-        patient_id_list.each_with_object({}) do |patient_id, params|
-          params[patient_id] ||= []
-          new_params = [search_params_with_values(search_param_names, patient_id)]
-          new_params.reject! do |params|
-            params.any? { |_key, value| value.blank? }
-          end
-          params[patient_id].concat(new_params)
-        end
-    end
-
-    def search_params_with_values(search_param_names, patient_id, include_system: false)
-      resources = scratch_resources_for_patient(patient_id)
-
-      return default_search_params if resources.empty?
-
-      resources.each_with_object({}) do |resource, outer_params|
-        results_from_one_resource = search_param_names.each_with_object({}) do |name, params|
-          value = search_param_value(name, resource, include_system:)
-          params[name] = value
-        end
-
-        outer_params.merge!(results_from_one_resource)
-        # stop if all parameter values are found
-        return outer_params if outer_params.all? { |_key, value| value.present? }
-      end
-    end
-
-    def default_search_params(search_param_names, patient_id)
-      search_param_names.each_with_object({}) do |name, params|
-        value = patient_id_param?(name) ? patient_id : nil
-        params[name] = value
-      end
-    end
-
-    def get_resource_identifiers(resource, target_identifier)
-      resource.identifier.filter { |ident| ident.system == target_identifier[:url] }
-    end
-
-    def search_param_value(_name, resource, include_system: false)
-      search_value = nil
-      resource_identifiers = get_resource_identifiers(resource, target_identifier)
-      if resource_identifiers.length.positive?
-        resource_identifier = resource_identifiers.first
-        search_value = include_system ? "#{resource_identifier.system}|#{resource_identifier.value}" : resource_identifier.value.to_s
-      end
-      search_value&.gsub(',', '\\,')
-    end
-
-    def run_special_identifier_search_test
-      conditional_skip_with_msg scratch_resources[:all].empty?, no_resources_skip_message
-      conditional_skip_with_msg !any_valid_search_params?(all_search_params), unable_to_resolve_params_message
-
-      resources_returned =
-        all_search_params.flat_map do |patient_id, params_list|
-          params_list.flat_map { |params| perform_search_with_system(params, patient_id) }
-        end
-
-      conditional_skip_with_msg resources_returned.empty?, no_resources_skip_message
-    end
-  end
-end

data/lib/au_core_test_kit/validation_test.rb

@@ -1,65 +0,0 @@
-# frozen_string_literal: true
-
-require_relative 'assert_helpers'
-require_relative 'validator_helpers'
-
-module AUCoreTestKit
-  module ValidationTest
-    include AssertHelpers
-    include ValidatorHelpers
-
-    DAR_CODE_SYSTEM_URL = 'http://terminology.hl7.org/CodeSystem/data-absent-reason'
-    DAR_EXTENSION_URL = 'http://hl7.org/fhir/StructureDefinition/data-absent-reason'
-
-    def perform_validation_test(resources,
-                                profile_url,
-                                profile_version,
-                                skip_if_empty: true)
-      conditional_skip_with_msg skip_if_empty && resources.blank?,
-                                "No #{resource_type} resources conforming to the #{profile_url} profile were returned"
-
-      omit_if resources.blank?,
-              "No #{resource_type} resources provided so the #{profile_url} profile does not apply"
-
-      show_validator_version
-
-      profile_with_version = "#{profile_url}|#{profile_version}"
-      resources.each do |resource|
-        resource_is_valid?(resource:, profile_url: profile_with_version)
-        check_for_dar(resource)
-      end
-
-      errors_found = messages.any? { |message| message[:type] == 'error' }
-
-      assert !errors_found, "Resource does not conform to the profile #{profile_with_version}"
-    end
-
-    def check_for_dar(resource)
-      unless scratch[:dar_code_found]
-        resource.each_element do |element, _meta, _path|
-          next unless element.is_a?(FHIR::Coding)
-
-          check_for_dar_code(element)
-        end
-      end
-
-      return if scratch[:dar_extension_found]
-
-      check_for_dar_extension(resource)
-    end
-
-    def check_for_dar_code(coding)
-      return unless coding.code == 'unknown' && coding.system == DAR_CODE_SYSTEM_URL
-
-      scratch[:dar_code_found] = true
-      output dar_code_found: 'true'
-    end
-
-    def check_for_dar_extension(resource)
-      return unless resource.source_contents&.include? DAR_EXTENSION_URL
-
-      scratch[:dar_extension_found] = true
-      output dar_extension_found: 'true'
-    end
-  end
-end

data/lib/au_core_test_kit/validator_helpers.rb

@@ -1,90 +0,0 @@
-# frozen_string_literal: true
-
-# Helpers for validating FHIR resources
-module ValidatorHelpers
-  VALIDATOR_KEY = 'validator_version'
-  WRAPPER_KEY = 'validator_wrapper_version'
-  RESPONSE_VALIDATOR_KEY = 'validatorVersion'
-  RESPONSE_WRAPPER_KEY = 'validatorWrapperVersion'
-  RESPONSE_KEYS = [RESPONSE_VALIDATOR_KEY, RESPONSE_WRAPPER_KEY].freeze
-  DEFAULT_VALUE = 'Unknown'
-
-  def show_validator_version
-    versions = read_or_create_validator_version
-    if versions.nil?
-      info 'Unable to fetch validator version'
-      return
-    end
-
-    validator_version = versions[VALIDATOR_KEY] || DEFAULT_VALUE
-    wrapper_version = versions[WRAPPER_KEY] || DEFAULT_VALUE
-
-    info "Using validator version #{validator_version} and validator wrapper version #{wrapper_version}"
-  end
-
-  private
-
-  def read_or_create_validator_version
-    return cached_versions if version_cached?
-
-    fetch_and_cache_versions
-  end
-
-  def validator_url
-    ENV['FHIR_RESOURCE_VALIDATOR_URL']
-  end
-
-  def response_valid?(version_data)
-    RESPONSE_KEYS.all? { |key| version_data.keys.include?(key) }
-  end
-
-  def fetch_and_cache_versions
-    response_body = fetch_validator_version(validator_url)
-    return warning("Unable to fetch validator version from #{validator_url}") if response_body.nil?
-
-    version_data = parse_response(response_body)
-
-    return warning "Invalid response from validator at #{validator_url}: #{version_data}" unless response_valid?(version_data)
-
-    cache_versions(version_data[RESPONSE_VALIDATOR_KEY], version_data[RESPONSE_WRAPPER_KEY])
-    build_version_hash(version_data[RESPONSE_VALIDATOR_KEY], version_data[RESPONSE_WRAPPER_KEY])
-  end
-
-  def cache_versions(validator_version, validator_wrapper_version)
-    scratch[VALIDATOR_KEY.to_sym] = validator_version
-    scratch[WRAPPER_KEY.to_sym] = validator_wrapper_version
-  end
-
-  def version_cached?
-    scratch[VALIDATOR_KEY.to_sym] && scratch[WRAPPER_KEY.to_sym]
-  end
-
-  def cached_versions
-    build_version_hash(scratch[VALIDATOR_KEY.to_sym], scratch[WRAPPER_KEY.to_sym])
-  end
-
-  def fetch_validator_version(url)
-    version_url = "#{url}/validator/version"
-    begin
-      response = Faraday.get(version_url)
-      response.body
-    rescue Faraday::Error => e
-      warning "Error connecting to validator at #{url}: #{e.message}"
-      nil
-    end
-  end
-
-  def parse_response(response_body)
-    JSON.parse(response_body)
-  rescue JSON::ParserError => e
-    warning "Error parsing response from validator: #{e.message}"
-    nil
-  end
-
-  def build_version_hash(validator_version, validator_wrapper_version)
-    {
-      'validator_version' => validator_version,
-      'validator_wrapper_version' => validator_wrapper_version
-    }
-  end
-end