davinci_crd_test_kit 0.13.0 → 0.14.0

data/lib/davinci_crd_test_kit/client/endpoints/gather_response_generation_data.rb

@@ -0,0 +1,410 @@
+require_relative '../../cross_suite/tags'
+
+module DaVinciCRDTestKit
+  # Make requests to client's FHIR server to use in building responses
+  module GatherResponseGenerationData
+    REFERENCES_TO_READ_BY_RESOURCE_TYPE = {
+      Appointment: [
+        'basedOn',
+        'participant.actor'
+      ],
+      CommunicationRequest: [
+        'requester',
+        'sender',
+        'recipient'
+      ],
+      DeviceRequest: [
+        'requester',
+        'performer'
+      ],
+      MedicationRequest: [
+        'requester',
+        'performer',
+        'medicationReference',
+        'dispenseRequest.performer'
+      ],
+      NutritionOrder: [
+        'orderer'
+      ],
+      ServiceRequest: [
+        'requester',
+        'performer',
+        'locationReference'
+      ],
+      VisionPrescription: [
+        'prescriber'
+      ],
+      Encounter: [
+        'participant.individual',
+        'location.location',
+        'serviceProvider'
+      ],
+      PractitionerRole: [
+        'practitioner',
+        'organization',
+        'location'
+      ]
+    }.freeze
+
+    def hook_instance_data_fetch_tag
+      @hook_instance_data_fetch_tag ||= TagMethods.hook_instance_data_fetch_tag(request_body['hookInstance'])
+    end
+
+    def gather_appointment_book_data
+      appointment_book_to_read = []
+      patient_id = request_body.dig('context', 'patientId')
+      encounter_id = request_body.dig('context', 'encounterId')
+      user_id = request_body.dig('context', 'userId')
+      appointment_book_to_read << "Patient/#{patient_id}" if patient_id.present?
+      appointment_book_to_read << "Encounter/#{encounter_id}" if encounter_id.present?
+      appointment_book_to_read << user_id if user_id.present?
+
+      appointment_book_to_analyze = extract_bundle_entries(request_body.dig('context', 'appointments'))
+
+      gather_data_for_request(appointment_book_to_read, appointment_book_to_analyze)
+    end
+
+    def gather_encounter_start_data
+      encounter_start_to_read = []
+      patient_id = request_body.dig('context', 'patientId')
+      encounter_id = request_body.dig('context', 'encounterId')
+      user_id = request_body.dig('context', 'userId')
+      encounter_start_to_read << "Patient/#{patient_id}" if patient_id.present?
+      encounter_start_to_read << "Encounter/#{encounter_id}" if encounter_id.present?
+      encounter_start_to_read << user_id if user_id.present?
+
+      gather_data_for_request(encounter_start_to_read, [])
+    end
+
+    def gather_encounter_discharge_data
+      encounter_discharge_to_read = []
+      patient_id = request_body.dig('context', 'patientId')
+      encounter_id = request_body.dig('context', 'encounterId')
+      user_id = request_body.dig('context', 'userId')
+      encounter_discharge_to_read << "Patient/#{patient_id}" if patient_id.present?
+      encounter_discharge_to_read << "Encounter/#{encounter_id}" if encounter_id.present?
+      encounter_discharge_to_read << user_id if user_id.present?
+
+      gather_data_for_request(encounter_discharge_to_read, [])
+    end
+
+    def gather_order_select_data
+      order_sign_to_read = []
+      patient_id = request_body.dig('context', 'patientId')
+      encounter_id = request_body.dig('context', 'encounterId')
+      user_id = request_body.dig('context', 'userId')
+      order_sign_to_read << "Patient/#{patient_id}" if patient_id.present?
+      order_sign_to_read << "Encounter/#{encounter_id}" if encounter_id.present?
+      order_sign_to_read << user_id if user_id.present?
+
+      order_sign_to_analyze = extract_bundle_entries(request_body.dig('context', 'draftOrders')).select do |resource|
+        request_body.dig('context', 'selections').include?("#{resource['resourceType']}/#{resource['id']}")
+      end
+
+      gather_data_for_request(order_sign_to_read, order_sign_to_analyze)
+    end
+
+    def gather_order_sign_data
+      order_sign_to_read = []
+      patient_id = request_body.dig('context', 'patientId')
+      encounter_id = request_body.dig('context', 'encounterId')
+      user_id = request_body.dig('context', 'userId')
+      order_sign_to_read << "Patient/#{patient_id}" if patient_id.present?
+      order_sign_to_read << "Encounter/#{encounter_id}" if encounter_id.present?
+      order_sign_to_read << user_id if user_id.present?
+
+      order_sign_to_analyze = extract_bundle_entries(request_body.dig('context', 'draftOrders'))
+
+      gather_data_for_request(order_sign_to_read, order_sign_to_analyze)
+    end
+
+    def gather_order_dispatch_data
+      order_dispatch_to_read = []
+      patient_id = request_body.dig('context', 'patientId')
+      order_id = request_body.dig('context', 'order')
+      performer_id = request_body.dig('context', 'performer')
+      order_dispatch_to_read << "Patient/#{patient_id}" if patient_id.present?
+      order_dispatch_to_read << order_id if order_id.present?
+      order_dispatch_to_read << performer_id if performer_id.present?
+
+      gather_data_for_request(order_dispatch_to_read, [request_body.dig('context', 'task')].compact)
+    end
+
+    def extract_bundle_entries(bundle)
+      return [] unless bundle.present? && bundle.is_a?(Hash) && bundle['entry'].is_a?(Array)
+
+      bundle['entry'].map do |entry|
+        next unless entry.is_a?(Hash) && entry['resource'].is_a?(Hash)
+
+        entry['resource']
+      end.compact
+    end
+
+    def gather_data_for_request(to_read_list, to_analyze_list)
+      to_analyze_list.each do |resource|
+        next unless resource.present?
+
+        find_references_to_read(resource, to_read_list)
+        analyzed_resources["#{resource['resourceType']}/#{resource['id']}"] = resource
+      end
+
+      read_and_analyze(to_read_list.pop, to_read_list) until to_read_list.empty?
+    end
+
+    def read_and_analyze(reference, to_read_list)
+      normalized_reference = normalize_reference(reference)
+      return if analyzed_resources.key?(normalized_reference)
+
+      resource =
+        if prefetched_resources.key?(normalized_reference)
+          prefetched_resources[normalized_reference]
+        else
+          fetch_reference(normalized_reference)
+        end
+      analyzed_resources[normalized_reference] = resource
+      return unless resource.present?
+
+      find_references_to_read(resource, to_read_list)
+    end
+
+    # turn absolute references into relative if
+    # for the fhir server indicated in the request
+    def normalize_reference(reference)
+      server = "#{request_body['fhirServer']&.chomp('/')}/"
+
+      if request_body['fhirServer'].present? && reference.starts_with?(server)
+        reference[server.length..]
+      else
+        reference
+      end
+    end
+
+    def fetch_reference(reference, additional_tag: nil, parse_as_fhir: false)
+      response = execute_request(reference)
+      return nil unless response.present?
+
+      tags = [DATA_FETCH_TAG, hook_instance_data_fetch_tag]
+      tags << additional_tag if additional_tag.present?
+      persist_query_request(response, tags)
+      return nil unless response.status.to_s.starts_with?('2')
+
+      begin
+        parse_as_fhir ? FHIR.from_contents(response.body) : JSON.parse(response.body)
+      rescue JSON::ParserError
+        nil
+      end
+    end
+
+    def find_references_to_read(resource, to_read_list)
+      references_to_read = REFERENCES_TO_READ_BY_RESOURCE_TYPE[resource['resourceType']&.to_sym]
+      return [] unless references_to_read.present?
+
+      references_to_read.each do |target_path|
+        get_literal_reference_values(resource, target_path).each do |reference|
+          to_read_list << reference unless to_read_list.include?(reference)
+        end
+      end
+    end
+
+    # Precondition: at most one level of nesting in the path
+    def get_literal_reference_values(resource, path)
+      if path.include?('.')
+        first_element, path = path.split('.')
+        resource = resource[first_element]
+      end
+
+      reference_objects =
+        case resource
+        when Hash
+          [resource[path]].flatten
+        when Array
+          resource.map { |entry| entry[path] }
+        else
+          []
+        end
+
+      reference_objects.map { |entry| entry['reference'] if entry.present? }.compact
+    end
+
+    def request_coverage
+      @request_coverage ||= find_coverage_for_request
+    end
+
+    def prefetched_coverage
+      @prefetched_coverage ||=
+        if request_body.dig('prefetch', 'coverage').present?
+          FHIR.from_contents(request_body.dig('prefetch', 'coverage').to_json)
+        elsif request_body.dig('prefetch', 'cov').present?
+          FHIR.from_contents(request_body.dig('prefetch', 'cov').to_json)
+        end
+    end
+
+    def find_coverage_for_request
+      resource =
+        if prefetched_coverage.present?
+          prefetched_coverage
+        else
+          query_for_coverages
+        end
+
+      return unless resource.is_a?(FHIR::Bundle)
+
+      resource.entry&.first&.resource
+    end
+
+    def fhir_server_connection
+      @fhir_server_connection ||=
+        if request_body['fhirServer'].present? &&
+           request_body['fhirAuthorization'].present? &&
+           request_body['fhirAuthorization']['access_token'].present?
+          Faraday.new(url: request_body['fhirServer'], request: { open_timeout: 10 },
+                      headers: data_request_headers)
+        end
+    end
+
+    def data_request_headers
+      @data_request_headers ||=
+        { 'Authorization' => "Bearer #{request_body['fhirAuthorization']['access_token']}" }
+    end
+
+    def execute_request(query)
+      fhir_server_connection&.get(query)
+    rescue Faraday::Error => e
+      # Warning: This is a hack. If there is an error with the request such that we never get a response, we have
+      #          no clean way to persist that information for the Inferno test to check later. The solution here
+      #          is to persist the request anyway with a status of nil, using the error message as response body
+      Faraday::Response.new(response_body: e.message, url: fhir_server_connection.url_prefix.to_s)
+    end
+
+    def persist_query_request(response, tags)
+      inferno_request_headers = data_request_headers.map { |name, value| { name:, value: } }
+      inferno_response_headers = response.headers&.map { |name, value| { name:, value: } }
+      requests_repo.create(
+        verb: 'GET',
+        url: response.env.url.to_s,
+        direction: 'outgoing',
+        status: response.status,
+        request_body: response.env.request_body,
+        response_body: response.env.response_body,
+        test_session_id: test_run.test_session_id,
+        result_id: result.id,
+        request_headers: inferno_request_headers,
+        response_headers: inferno_response_headers,
+        tags:
+      )
+    end
+
+    def query_for_coverages
+      query = "Coverage?patient=#{request_body.dig('context', 'patientId')}&status=active"
+      response = execute_request(query)
+      return nil unless response.present?
+
+      persist_query_request(response, [DATA_FETCH_TAG, hook_instance_data_fetch_tag])
+      return nil unless response.status.to_s.starts_with?('2')
+
+      FHIR.from_contents(response.body)
+    end
+
+    def analyzed_resources
+      @analyzed_resources ||= {}
+    end
+
+    def prefetched_resources
+      @prefetched_resources ||=
+        if request_body['prefetch'].blank? || !request_body['prefetch'].is_a?(Hash)
+          {}
+        else
+          request_body['prefetch'].values.each_with_object({}) do |prefetched_resource, resource_hash|
+            next unless prefetched_resource.is_a?(Hash)
+
+            add_prefetch_resource_to_resource_hash(prefetched_resource, resource_hash)
+          end
+        end
+    end
+
+    def add_prefetch_resource_to_resource_hash(prefetched_resource, resource_hash)
+      if prefetched_resource['resourceType'] == 'Bundle'
+        prefetched_resource['entry']&.each do |entry|
+          next unless entry_has_required_details?(entry)
+
+          one_resource = entry['resource']
+          key = "#{one_resource['resourceType']}/#{one_resource['id']}"
+          resource_hash[key] = one_resource
+        end
+      elsif resource_has_required_details?(prefetched_resource)
+
+        key = "#{prefetched_resource['resourceType']}/#{prefetched_resource['id']}"
+        resource_hash[key] = prefetched_resource
+      end
+    end
+
+    def entry_has_required_details?(entry)
+      entry.present? &&
+        entry.is_a?(Hash) &&
+        entry['resource'].present? &&
+        resource_has_required_details?(entry['resource'])
+    end
+
+    def resource_has_required_details?(resource)
+      resource.is_a?(Hash) && resource['resourceType'].present? && resource['id'].present?
+    end
+
+    # gather additional fhir resources not requested via prefetch
+    # not used for response generation, but verified later
+    def request_additional_fhir_data
+      request_coverage_payer
+      request_parent_locations
+    end
+
+    def prefetched_coverage_resource
+      if prefetched_coverage.is_a?(FHIR::Bundle)
+        prefetched_coverage.entry.first&.resource
+      else
+        prefetched_coverage
+      end
+    end
+
+    def request_coverage_payer
+      return unless prefetched_coverage.present?
+
+      coverage_resource = prefetched_coverage_resource
+      return unless coverage_resource.present? && coverage_resource.payor.first&.reference.present?
+
+      fetch_reference(coverage_resource.payor.first.reference, additional_tag: PAYER_ORG_FETCH_TAG)
+    end
+
+    def request_parent_locations
+      prefetched_locations_and_parents_hash
+    end
+
+    def prefetched_location_bundle
+      locations_data = request_body.dig('prefetch', 'locations') || request_body.dig('prefetch', 'locs')
+      locations = FHIR.from_contents(locations_data.to_json) if locations_data.present?
+      return locations if locations.is_a?(FHIR::Bundle)
+      return nil unless locations.is_a?(FHIR::Location)
+
+      FHIR::Bundle.new({ entry: [FHIR::Bundle::Entry.new({ resource: locations })] })
+    end
+
+    def prefetched_locations_and_parents_hash
+      prefetched_location_bundle&.entry&.each_with_object({}) do |entry, hash|
+        add_location_to_hash(entry.resource, hash)
+      end
+    end
+
+    def add_location_to_hash(location, location_hash)
+      return unless location.is_a?(FHIR::Location) && location.id.present?
+
+      relative_reference = "#{location.resourceType}/#{location.id}"
+      return if location_hash.key?(relative_reference)
+
+      location_hash[relative_reference] = location
+      return unless location.partOf&.reference.present?
+
+      parent_location = fetch_reference(location.partOf.reference,
+                                        additional_tag: PARENT_LOCATION_FETCH_TAG,
+                                        parse_as_fhir: true)
+      add_location_to_hash(parent_location, location_hash)
+    end
+  end
+end

data/lib/davinci_crd_test_kit/client/endpoints/hook_request_endpoint.rb

@@ -0,0 +1,233 @@
+require_relative 'gather_response_generation_data'
+require_relative 'mock_service_response'
+require_relative 'custom_service_response'
+require_relative '../../cross_suite/cards_identification'
+require_relative '../../cross_suite/tags'
+
+module DaVinciCRDTestKit
+  class HookRequestEndpoint < Inferno::DSL::SuiteEndpoint
+    include DaVinciCRDTestKit::MockServiceResponse
+    include DaVinciCRDTestKit::GatherResponseGenerationData
+    include DaVinciCRDTestKit::CustomServiceResponse
+    include DaVinciCRDTestKit::CardsIdentification
+
+    AVAILABLE_HOOKS = [
+      'appointment-book',
+      'encounter-start',
+      'encounter-discharge',
+      'order-select',
+      'order-sign',
+      'order-dispatch'
+    ].freeze
+
+    def ig_version
+      @ig_version ||= requested_version || request.env['PATH_INFO'].match(/(v\d+)/)&.[](1) || 'v201'
+    end
+
+    # JSON round-trip normalizes the Hanami params object to a plain string-keyed Hash
+    def request_body
+      @request_body ||= JSON.parse(request.params.to_json)
+    end
+
+    def requested_version
+      requested = request_body.dig('extension', 'davinci-crd.requestedVersion').to_s
+      if requested == '2.2'
+        'v221'
+      elsif requested == '2.0'
+        'v201'
+      end
+    end
+
+    def test_run_identifier
+      iss
+    end
+
+    def iss
+      @iss ||=
+        begin
+          payload, = JWT.decode(token, nil, false)
+          payload['iss']
+        rescue JWT::DecodeError
+          nil
+        end
+    end
+
+    def token
+      @token ||= request.headers['authorization']&.delete_prefix('Bearer ')
+    end
+
+    # from the hook body
+    def requested_hook
+      @requested_hook ||= request_body['hook']
+    end
+
+    # from the url
+    def invoked_hook
+      @invoked_hook ||= request.env['PATH_INFO'].match(%r{/([^/]+)-(?:service|subset)$})&.[](1)
+    end
+
+    # from the waiting test
+    def tested_hook
+      @tested_hook ||= test.config.options[:hook_name]
+    end
+
+    def wrong_hook_for_test?
+      tested_hook.present? && tested_hook != ANY_HOOK_TAG && requested_hook != tested_hook
+    end
+
+    def make_response
+      if invoked_hook != requested_hook
+        error_response("#{request.env['PATH_INFO']} serves the #{invoked_hook}, but the client " \
+                       "requested the #{requested_hook} hook.",
+                       code: 400,
+                       outcome_code: 'value')
+      elsif wrong_hook_for_test?
+        error_response("Hook '#{requested_hook}' is not being tested in the current session. " \
+                       "This session is currently testing the '#{tested_hook}' hook.",
+                       code: 422,
+                       outcome_code: 'value')
+      elsif hook_instance_already_used?
+        error_response(
+          "Invalid Request: Hook instance `#{request_body['hookInstance']}` has already been used in this session.",
+          outcome_code: 'value'
+        )
+      elsif AVAILABLE_HOOKS.include?(requested_hook)
+        process_valid_hook
+      else
+        error_response("Invalid Request: hook `#{requested_hook}` is not supported by this server.",
+                       outcome_code: 'value')
+      end
+    rescue StandardError => e
+      error_response("Inferno failed to generate a response: #{e.message} at #{e.backtrace.first}",
+                     code: 500,
+                     outcome_code: 'exception')
+    end
+
+    def process_valid_hook
+      if ig_version == 'v201'
+        send(:"gather_#{requested_hook.gsub('-', '_')}_data")
+        request_coverage
+      elsif ig_version == 'v221'
+        request_additional_fhir_data
+      end
+      response_body = apply_hook_configuration(hook_response)
+      return unless response_body.present?
+
+      response.body = response_body.to_json
+      response.headers.merge!({ 'Content-Type' => 'application/json', 'Access-Control-Allow-Origin' => '*' })
+      response.status = 200
+      response.format = :json
+    end
+
+    def response_approach
+      JSON.parse(result.input_json)
+        .find { |input| input['name'].ends_with?('_response_approach') }
+        &.dig('value')
+    end
+
+    def hook_response
+      if response_approach == 'custom'
+        build_custom_hook_response
+      else
+        build_mock_hook_response
+      end
+    rescue StandardError => e
+      error_response("Inferno failed to generate a response: #{e.message} at #{e.backtrace.first}", code: 500)
+      nil
+    end
+
+    def apply_hook_configuration(response_body)
+      return response_body unless response_body.present? && coverage_info_disabled?
+
+      cards = response_body['cards']
+      response_body['cards'] = cards.reject { |card| coverage_info_card_type?(card) } if cards.is_a?(Array)
+
+      system_actions = response_body['systemActions']
+      if system_actions.is_a?(Array)
+        response_body['systemActions'] = system_actions.reject { |action| coverage_info_system_action_type?(action) }
+      end
+
+      response_body
+    end
+
+    def coverage_info_disabled?
+      request_body.dig('extension', 'davinci-crd.configuration', COVERAGE_INFO_CONFIGURATION_CODE) == false
+    end
+
+    def hook_instance_already_used?
+      requests_repo.tagged_requests(test_run.test_session_id, [hook_instance_tag]).present?
+    end
+
+    def tags
+      return [LONG_RUNNING_GROUP_TAG] if long_running_group?
+      return [DUPLICATED_HOOK_INSTANCE_TAG] if hook_instance_already_used?
+
+      return [] if invoked_hook != requested_hook ||
+                   wrong_hook_for_test? ||
+                   !AVAILABLE_HOOKS.include?(requested_hook)
+
+      [hook_instance_tag, hook_or_group_tag]
+    end
+
+    def hook_instance_tag
+      TagMethods.hook_instance_tag(request_body['hookInstance'])
+    end
+
+    def hook_or_group_tag
+      if test.config.options[:crd_test_group].present?
+        test.config.options[:crd_test_group]
+      else
+        DaVinciCRDTestKit.const_get(:"#{name.upcase}_TAG")
+      end
+    end
+
+    def error_response(error_message, code: 400, outcome_code: 'invalid')
+      response.status = code
+      response.body = error_operation_outcome(outcome_code, error_message).to_json
+      response.headers.merge!({ 'Content-Type' => 'application/json', 'Access-Control-Allow-Origin' => '*' })
+      response.format = :json
+    end
+
+    def error_operation_outcome(code, text)
+      {
+        resourceType: 'OperationOutcome',
+        issue: [
+          {
+            severity: 'error',
+            code:,
+            details: {
+              text:
+            }
+          }
+        ]
+      }
+    end
+
+    def name
+      requested_hook.gsub('-', '_')
+    end
+
+    # -----------------------
+    # Long Running Group handling
+    # -----------------------
+
+    def long_running_group?
+      test.config.options[:crd_test_group] == LONG_RUNNING_GROUP_TAG
+    end
+
+    def long_running_pause_time
+      JSON.parse(result.input_json)
+        .find { |input| input['name'].include?('long_running_pause_time') }
+        &.dig('value').to_i
+    end
+
+    # end the wait immediately after the long-running request returns
+    # pause here because update_result runs before response generation
+    def update_result
+      return unless long_running_group?
+
+      sleep long_running_pause_time
+      results_repo.update(result.id, result: 'pass', result_message: '')
+    end
+  end
+end