au_core_test_kit 1.4.6 → 1.4.7

data/lib/au_core_test_kit/read_test.rb

@@ -1,123 +0,0 @@
-# frozen_string_literal: true
-
-module AUCoreTestKit
-  module ReadTest
-    def all_scratch_resources
-      scratch_resources[:all] ||= []
-    end
-
-    def perform_read_test(resources, _reply_handler = nil)
-      if resources.blank?
-        resource_ids_str = fetch_resource_ids(resource_type)
-        if resource_ids_str.blank?
-          skip no_resources_custom_skip_message
-        else
-          resources_to_read = get_resources_to_read_from_arr_ids(
-            resource_ids_str_to_arr(resource_ids_str),
-            resource_type
-          )
-          assert resources_to_read.present?, "No #{resource_type} id found."
-          read_and_validate_resourses_arr(resources_to_read)
-        end
-      else
-        resources_to_read = readable_resources(resources)
-        assert resources_to_read.present?, "No #{resource_type} id found."
-        read_and_validate_resourses_arr(resources_to_read)
-      end
-    end
-
-    def fetch_resource_ids(resource_type)
-      case resource_type
-      when 'Location'
-        location_ids
-      when 'Organization'
-        organization_ids
-      when 'Practitioner'
-        practitioner_ids
-      when 'PractitionerRole'
-        practitioner_role_ids
-      when 'HealthcareService'
-        healthcare_service_ids
-      else
-        ''
-      end
-    end
-
-    def resource_ids_str_to_arr(resource_ids_str)
-      resource_ids_str.split(',').map(&:strip)
-    end
-
-    def read_and_validate_resourses_arr(resources_to_read)
-      resources_to_read.each do |resource|
-        read_and_validate(resource)
-      end
-    end
-
-    def get_resources_to_read_from_arr_ids(resource_ids_arr, resource_type)
-      resource_ids_arr.map do |resource_id|
-        create_reference(resource_type, resource_id)
-      end
-    end
-
-    def create_reference(resource_type, resource_id)
-      FHIR::Reference.new(
-        reference: "#{resource_type}/#{resource_id}",
-        type: resource_type
-      )
-    end
-
-    def readable_resources(resources)
-      resources
-        .select { |resource| resource.is_a?(resource_class) || resource.is_a?(FHIR::Reference) }
-        .select { |resource| (resource.is_a?(FHIR::Reference) ? resource.reference.split('/').last : resource.id).present? }
-        .compact
-        .uniq { |resource| resource.is_a?(FHIR::Reference) ? resource.reference.split('/').last : resource.id }
-    end
-
-    def basic_read_and_validate(resource_to_read)
-      id = resource_id(resource_to_read)
-
-      fhir_read resource_type, id
-
-      assert_response_status(200)
-      assert_resource_type(resource_type)
-      assert resource.id.present? && resource.id == id, bad_resource_id_message(id)
-
-      nil unless resource_to_read.is_a? FHIR::Reference
-    end
-
-    def read_and_validate(resource_to_read)
-      basic_read_and_validate(resource_to_read)
-
-      all_scratch_resources << resource
-    end
-
-    def read_and_validate_as_first(resource_to_read, patient_id)
-      basic_read_and_validate(resource_to_read)
-
-      all_scratch_resources.concat([resource]).uniq!
-      scratch_resources_for_patient(patient_id).concat([resource]).uniq!
-    end
-
-    def resource_id(resource)
-      resource.is_a?(FHIR::Reference) ? resource.reference.split('/').last : resource.id
-    end
-
-    def no_resources_skip_message
-      "No #{resource_type} resources appear to be available. " \
-      'Please use patients with more information.'
-    end
-
-    def bad_resource_id_message(expected_id)
-      "Expected resource to have id: `#{expected_id.inspect}`, but found `#{resource.id.inspect}`"
-    end
-
-    def no_resources_custom_skip_message
-      "There are no resources of the type #{resource_type} from previous tests, and you didn't provide IDs to search."
-    end
-
-    def resource_class
-      FHIR.const_get(resource_type)
-    end
-  end
-end

data/lib/au_core_test_kit/reference_resolution_test.rb

@@ -1,185 +0,0 @@
-# frozen_string_literal: true
-
-require_relative 'fhir_resource_navigation'
-require_relative 'assert_helpers'
-
-module AUCoreTestKit
-  module ReferenceResolutionTest
-    extend Forwardable
-    include FHIRResourceNavigation
-    include AssertHelpers
-
-    def_delegators 'self.class', :metadata
-
-    def perform_reference_resolution_test(resources)
-      conditional_skip_with_msg resources.blank?, no_resources_skip_message
-
-      pass if unresolved_references(resources).empty?
-
-      skip_with_msg "Could not resolve and validate any Must Support references for #{unresolved_references_strings.join(', ')}"
-    end
-
-    def unresolved_references_strings
-      unresolved_reference_hash =
-        unresolved_references.each_with_object(Hash.new { |hash, key| hash[key] = [] }) do |missing, hash|
-          hash[missing[:path]] << missing[:target_profile]
-        end
-      unresolved_reference_hash.map do |path, profiles|
-        "#{path} element: Reference#{"(#{profiles.join('|')})" unless profiles.first.empty?}"
-      end
-    end
-
-    def record_resolved_reference(reference, target_profile)
-      saved_reference = resolved_references.find { |item| item[:reference] == reference.reference }
-
-      if saved_reference.present?
-        saved_reference[:profiles] << target_profile if target_profile.present? && !saved_reference[:profiles].include?(target_profile)
-      else
-        saved_reference = {
-          reference: reference.reference,
-          profiles: []
-        }
-
-        saved_reference[:profiles] << target_profile if target_profile.present?
-        resolved_references.add(saved_reference)
-      end
-    end
-
-    def is_reference_resolved?(reference, target_profile)
-      resolved_references.any? do |item|
-        item[:reference] == reference.reference &&
-          (
-            target_profile.blank? || item[:profiles].include?(target_profile)
-          )
-      end
-    end
-
-    def resolved_references
-      scratch[:resolved_references] ||= Set.new
-    end
-
-    def no_resources_skip_message
-      "No #{resource_type} resources appear to be available. " \
-      'Please use patients with more information.'
-    end
-
-    def must_support_references
-      metadata.must_supports[:elements].select do |element_definition|
-        element_definition[:types]&.include?('Reference')
-      end
-    end
-
-    def must_support_references_with_target_profile
-      # mapping array of target_profiles to array of {path, target_profile} pair
-      must_support_references.map do |element_definition|
-        (element_definition[:target_profiles] || ['']).map do |target_profile|
-          {
-            path: element_definition[:path],
-            target_profile:
-          }
-        end
-      end.flatten
-    end
-
-    def unresolved_references(resources = [])
-      @unresolved_references ||=
-        must_support_references_with_target_profile.select do |reference_path_profile_pair|
-          path = reference_path_profile_pair[:path]
-          target_profile = reference_path_profile_pair[:target_profile]
-
-          found_one_reference = false
-
-          resolve_one_reference = resources.any? do |resource|
-            value_found = resolve_path(resource, path)
-            next if value_found.empty?
-
-            found_one_reference = true
-
-            value_found.any? do |reference|
-              validate_reference_resolution(resource, reference, target_profile)
-            end
-          end
-
-          found_one_reference && !resolve_one_reference
-        end
-
-      if metadata.must_supports[:choices].present?
-        @unresolved_references.delete_if do |reference|
-          choice_profiles = metadata.must_supports[:choices].find do |choice|
-            choice[:target_profiles]&.include?(reference[:target_profile])
-          end
-
-          choice_profiles.present? &&
-            choice_profiles[:target_profiles]&.any? do |profile|
-              @unresolved_references.none? do |element|
-                element[:target_profile] == profile
-              end
-            end
-        end
-      end
-
-      @unresolved_references
-    end
-
-    def validate_reference_resolution(resource, reference, target_profile)
-      return true if is_reference_resolved?(reference, target_profile)
-
-      if reference.contained?
-        # if reference_id is blank it is referring to itself, so we know it exists
-        return true if reference.reference_id.blank?
-
-        return resource.contained.any? do |contained_resource|
-                 contained_resource&.id == reference.reference_id &&
-                 resource_is_valid_with_target_profile?(contained_resource, target_profile)
-               end
-      end
-
-      reference_type = reference.resource_type
-      reference_id = reference.reference_id
-
-      resolved_resource =
-        begin
-          if reference.relative?
-            begin
-              reference.resource_class
-            rescue NameError
-              return false
-            end
-
-            fhir_read(reference_type, reference_id)&.resource
-          elsif reference.base_uri.chomp('/') == fhir_client.instance_variable_get(:@base_service_url).chomp('/')
-            fhir_read(reference_type, reference_id)&.resource
-          else
-            get(reference.reference)&.resource
-          end
-        rescue StandardError => e
-          Inferno::Application['logger'].error("Unable to resolve reference #{reference.reference}")
-          Inferno::Application['logger'].error(e.full_message)
-          return false
-        end
-
-      return false unless resolved_resource&.resourceType == reference_type && resolved_resource&.id == reference_id
-
-      return false unless resource_is_valid_with_target_profile?(resolved_resource, target_profile)
-
-      record_resolved_reference(reference, target_profile)
-      true
-    end
-
-    def resource_is_valid_with_target_profile?(resource, target_profile)
-      return true if target_profile.blank?
-
-      validator = find_validator(:default)
-
-      target_profile_with_version = target_profile == "http://hl7.org.au/fhir/StructureDefinition/au-specimen" ? target_profile : "#{target_profile}|#{metadata.profile_version}"
-
-      # Only the boolean matters here, so add_messages_to_runnable is false: logging a
-      # validation message for every reference target would flood the test's messages.
-      # This is the supported way to validate without logging. The previous
-      # implementation hand-rolled the same thing out of Validator internals
-      # (operation_outcome_from_hl7_wrapped_response, message_hash_from_issue,
-      # filter_messages), all of which inferno_core removed in v1.1.0.
-      validator.resource_is_valid?(resource, target_profile_with_version, self, add_messages_to_runnable: false)
-    end
-  end
-end

data/lib/au_core_test_kit/request_logger.rb

@@ -1,48 +0,0 @@
-# frozen_string_literal: true
-
-module Inferno
-  module Utils
-    # @private
-    module Middleware
-      class RequestLogger
-        def log_response(response, start_time, end_time, exception = nil)
-          elapsed = end_time - start_time
-          status, _response_headers, body = response if response
-          status, = response if exception
-
-          logger.info("#{status} in #{elapsed.in_milliseconds} ms")
-          return unless body.present?
-
-          body = body.is_a?(Array) ? body.join : body
-
-          if body.length > 100
-            logger.info("#{body[0..100]}...")
-          else
-            logger.info(body)
-          end
-        end
-
-        def log_request(env)
-          method = env['REQUEST_METHOD']
-          scheme = env['rack.url_scheme']
-          host = env['HTTP_HOST']
-          path = env['REQUEST_URI']
-          query = env['rack.request.query_string']
-          body = env['rack.input']
-          body = body.instance_of?(Puma::NullIO) ? nil : body.string
-          query_string = query.blank? ? '' : "?#{query}"
-
-          logger.info("#{method} #{scheme}://#{host}#{path}#{query_string}")
-
-          return unless body.present?
-
-          if body.length > 100
-            logger.info("#{body[0..100]}...")
-          else
-            logger.info(body)
-          end
-        end
-      end
-    end
-  end
-end