davinci_pdex_test_kit 0.10.6 → 0.11.0

data/lib/davinci_pdex_test_kit/ext/inferno_core/record_response_route.rb

@@ -1,98 +0,0 @@
-require 'hanami/controller'
-
-module Inferno
-  module DSL
-    # A base class for creating routes with custom response logic. Requests and responses are tagged and saved.
-    # @private
-    # @see Inferno::DSL::Runnable#resume_test_route
-    class RecordResponseRoute < Hanami::Action
-      include Import[
-                requests_repo: 'inferno.repositories.requests',
-                results_repo: 'inferno.repositories.results',
-                test_runs_repo: 'inferno.repositories.test_runs',
-                tests_repo: 'inferno.repositories.tests'
-              ]
-
-      def self.call(...)
-        new.call(...)
-      end
-
-      # @private
-      def test_run_identifier_block
-        self.class.singleton_class.instance_variable_get(:@test_run_identifier_block)
-      end
-
-      # @private
-      def build_response_block
-        self.class.singleton_class.instance_variable_get(:@build_response_block)
-      end
-
-      # @private
-      def tags
-        self.class.singleton_class.instance_variable_get(:@tags)
-      end
-
-      # @private
-      def resumes?(test)
-        instance_exec(test, &self.class.singleton_class.instance_variable_get(:@resumes))
-      end
-
-      # @private
-      def find_test_run(test_run_identifier)
-        test_runs_repo.find_latest_waiting_by_identifier(test_run_identifier)
-      end
-
-      # @private
-      def find_waiting_result(test_run)
-        results_repo.find_waiting_result(test_run_id: test_run.id)
-      end
-
-      # @private
-      def update_result(waiting_result)
-        results_repo.update_result(waiting_result.id, 'pass')
-      end
-
-      # @private
-      def persist_request(request, test_run, waiting_result, test)
-        requests_repo.create(
-          request.to_hash.merge(
-            test_session_id: test_run.test_session_id,
-            result_id: waiting_result.id,
-            name: test.config.request_name(test.incoming_request_name),
-            tags:
-          )
-        )
-      end
-
-      # @private
-      def find_test(waiting_result)
-        tests_repo.find(waiting_result.test_id)
-      end
-
-      # @private
-      def handle(req, res)
-        request = Inferno::Entities::Request.from_hanami_request(req)
-
-        test_run_identifier = instance_exec(request, &test_run_identifier_block)
-
-        test_run = find_test_run(test_run_identifier)
-
-        halt 500, "Unable to find test run with identifier '#{test_run_identifier}'." if test_run.nil?
-
-        waiting_result = find_waiting_result(test_run)
-        test = find_test(waiting_result)
-
-        test_runs_repo.mark_as_no_longer_waiting(test_run.id) if resumes? test
-
-        update_result(waiting_result) if resumes? test
-
-        instance_exec(request, test, waiting_result, &build_response_block)
-
-        Inferno::Entities::Request.to_hanami_response(request, res)
-        persist_request(request, test_run, waiting_result, test)
-
-        Jobs.perform(Jobs::ResumeTestRun, test_run.id) if resumes? test
-      end
-    end
-  end
-end

data/lib/davinci_pdex_test_kit/ext/inferno_core/request.rb

@@ -1,19 +0,0 @@
-module Inferno
-  module Entities
-    class Request
-      def self.to_hanami_response(request, response)
-        response.status = request.status
-        response.body = request.response_body
-        request.response_headers.each do |header|
-          response.headers[header.name] = header.value
-        end
-
-        response
-      end
-
-      def response_headers=(headers_hash)
-        headers.concat(headers_hash.map { |key, value| Header.new(name: key.to_s, value:, type: 'response') })
-      end
-    end
-  end
-end

data/lib/davinci_pdex_test_kit/ext/inferno_core/runnable.rb

@@ -1,18 +0,0 @@
-require_relative 'record_response_route'
-
-module Inferno
-  module DSL
-    module Runnable
-      def record_response_route(method, path, tags, build_response, resumes: ->(_) { true }, &block)
-        route_class = Class.new(Inferno::DSL::RecordResponseRoute) do |klass|
-          klass.singleton_class.instance_variable_set(:@build_response_block, build_response)
-          klass.singleton_class.instance_variable_set(:@test_run_identifier_block, block)
-          klass.singleton_class.instance_variable_set(:@tags, Array.wrap(tags))
-          klass.singleton_class.instance_variable_set(:@resumes, resumes)
-        end
-
-        route(method, path, route_class)
-      end
-    end
-  end
-end

data/lib/davinci_pdex_test_kit/mock_server.rb

@@ -1,281 +0,0 @@
-require_relative 'user_input_response'
-require_relative 'urls'
-require_relative 'pdex_payer_client/collection'
-require_relative 'pdex_payer_client/client_validation_test'
-#require_relative 'metadata/mock_capability_statement'
-
-
-module DaVinciPDexTestKit
-  # Serve responses to PAS requests
-  #
-  # Note that there are numerous expected validation issues that can safely be ignored.
-  # See here for full list: https://hl7.org/fhir/us/davinci-pas/STU2/qa.html#suppressed
-  module MockServer
-    include URLs
-
-    def server_proxy
-      @server_proxy ||= Faraday.new(
-          url: ENV.fetch('FHIR_REFERENCE_SERVER'),
-          params: {},
-          headers: {'Content-Type' => 'application/json', 'Authorization' => 'Bearer SAMPLE_TOKEN', 'Host' => ENV.fetch('HOST_HEADER')},
-        ) do |proxy| 
-          proxy.use FaradayMiddleware::Gzip
-        end
-    end
-
-    def token_response(request, _test = nil, _test_result = nil)
-      # Placeholder for a more complete mock token endpoint
-      request.response_body = { access_token: SecureRandom.hex, token_type: 'bearer', expires_in: 300 }.to_json
-      request.status = 200
-    end
-
-    def claim_response(request, test = nil, test_result = nil)
-      endpoint = resource_endpoint(request.url)
-      params = match_request_to_expectation(endpoint, request.query_parameters)
-      if params
-        response = server_proxy.get(endpoint, params)
-        request.status = response.status
-        response_resource = replace_bundle_urls(FHIR.from_contents(response.body))
-        request.response_headers = remove_transfer_encoding_header(response.headers)
-        request.response_body = response_resource.to_json
-        request.response_header("content-length").value = request.response_body.length
-      else
-        response = server_proxy.get('Patient', {_id: 999})
-        response_resource = FHIR.from_contents(response.body)
-        response_resource.entry = [{fullUrl: 'urn:uuid:2866af9c-137d-4458-a8a9-eeeec0ce5583', resource: mock_operation_outcome_resource, search: {mode: 'outcome'}}]
-        response_resource.link.first.url = request.url #specific case for Operation Outcome handling
-        request.status = 400
-        request.response_body = response_resource.to_json
-      end
-    end
-
-    def read_next_page(request, test = nil, test_result = nil)
-      response = server_proxy.get('', request.query_parameters)
-      request.status = response.status
-      request.response_headers = remove_transfer_encoding_header(response.headers)
-      request.response_body = replace_bundle_urls(FHIR.from_contents(response.body)).to_json
-    end
-
-    def everything_response(request, test = nil, test_result = nil)
-      response = server_proxy.get('Patient/999/$everything') #TODO: Change from static response
-      request.status = response.status
-      request.response_headers = remove_transfer_encoding_header(response.headers)
-      request.response_body = replace_bundle_urls(FHIR.from_contents(response.body)).to_json
-    end
-
-    def export_response(request, test = nil, test_result = nil)
-      headers_as_hash = request.request_headers.map { |header| {"#{header.name}": header.value}}.reduce({}) { |reduced, curr| reduced.merge(curr)}
-      response = server_proxy.get do |req|
-        req.url 'Group/pdex-Group/$export' #TODO: change from static response
-        req.headers = headers_as_hash.merge(server_proxy.headers)
-      end
-      request.status = response.status
-      request.response_headers = response.env.response_headers
-      request.response_header("content-location").value.gsub!(/(.*)\?/, "#{new_link}/$export-poll-status?")
-      request.response_body = response.body
-    end
-
-    def export_status_response(request, test = nil, test_result = nil)
-      headers_as_hash = request.request_headers.map { |header| {"#{header.name}": header.value}}.reduce({}) { |reduced, curr| reduced.merge(curr)}
-      response = server_proxy.get do |req|
-        req.url '$export-poll-status'
-        req.params = request.query_parameters
-        req.headers = headers_as_hash.merge(server_proxy.headers)
-      end
-      request.status = response.status
-      request.response_headers = remove_transfer_encoding_header(response.env.response_headers)
-      request.response_body = response.status.to_i == 200 ? replace_export_urls(JSON.parse(response.body)).to_json : response.body
-      request.response_header("content-length").value = request.response_body.length
-    end
-
-    def binary_read_response(request, test = nil, test_result = nil)
-      binary_id = request.url.split('/').last
-      response = server_proxy.get('Binary/'+binary_id)
-      request.status = response.status
-      request.response_headers = response.headers
-      request.response_body = response.body
-    end
-
-    def member_match_response(request, test = nil, test_result = nil)
-      #remove token from request as well
-      original_request_as_hash = JSON.parse(request.request_body).to_h
-      request.request_body = original_request_as_hash.to_json
-      #TODO: Change from static response
-      request.response_body = {
-        resourceType: "Parameters",
-        parameter: [
-          {
-            name: "MemberIdentifier",
-            valueIdentifier: {
-              type: {
-                coding: [
-                  {
-                    system: "http://terminology.hl7.org/CodeSystem/v2-0203",
-                    code: "MB"
-                  }
-                ]
-              },
-              system: "https://github.com/inferno-framework/target-payer/identifiers/member",
-              value: "99999",
-              assigner: {
-                display: "Old Payer"
-              }
-            }
-          }
-        ]
-      }.to_json
-      request.status = 200
-    end
-
-    def get_metadata
-      proc { [200, {'Content-Type' => 'application/fhir+json;charset=utf-8'}, [File.read("lib/davinci_pdex_test_kit/metadata/mock_capability_statement.json")]] }
-    end
-
-    def remove_transfer_encoding_header(headers)
-      if !headers["transfer-encoding"].nil?
-        headers.reject!{|key, value| key == "transfer-encoding"}
-      else
-        headers
-      end
-    end
-
-    def match_request_to_expectation(endpoint, params)
-      matched_search = SEARCHES_BY_PRIORITY[endpoint.to_sym].find {|expectation| (params.keys.map{|key| key.to_s} & expectation).sort == expectation}
-      # matched_search_without_patient = SEARCHES_BY_PRIORITY[endpoint.to_sym].find {|expectation| (params.keys.map{|key| key.to_s} << "patient" & expectation) == expectation}
-
-      if matched_search
-        params.select {|key, value| matched_search.include?(key.to_s) || key == "_revInclude" || key == "_include"}
-      else
-        nil
-      end
-      # else
-      #   new_params = params.select {|key, value| matched_search_without_patient.include?(key.to_s) || key == "_revInclude" || key == "_include"}
-      #   new_params["patient"] = patient_id_from_match_request
-      #   new_params
-      # end
-    end
-
-    def extract_client_id(request)
-      URI.decode_www_form(request.request_body).to_h['client_id']
-    end
-
-    # Header expected to be a bearer token of the form "Bearer: <token>"
-    def extract_bearer_token(request)
-      request.request_header('Authorization')&.value&.split&.last
-    end
-
-    def extract_token_from_query_params(request)  
-      request.query_parameters['token']
-    end
-
-    # Pull resource type from url
-    # e.g. http://example.org/fhir/Patient/123 -> Patient
-    # @private
-    def resource_endpoint(url)
-      return unless url.start_with?('http://', 'https://')
-
-      /custom\/pdex_payer_client\/fhir\/(.*)\?/.match(url)[1]
-    end
-
-    # @private
-    def referenced_entities(resource, entries, root_url)
-      matches = []
-      attributes = resource&.source_hash&.keys
-      attributes.each do |attr|
-        value = resource.send(attr.to_sym)
-        if value.is_a?(FHIR::Reference) && value.reference.present?
-          match = find_matching_entry(value.reference, entries, root_url)
-          if match.present? && matches.none?(match)
-            value.reference = match.fullUrl
-            matches.concat([match], referenced_entities(match.resource, entries, root_url))
-          end
-        elsif value.is_a?(Array) && value.all? { |elmt| elmt.is_a?(FHIR::Model) }
-          value.each { |val| matches.concat(referenced_entities(val, entries, root_url)) }
-        end
-      end
-
-      matches
-    end
-
-    def mock_operation_outcome_resource
-      FHIR.from_contents(File.read("lib/davinci_pdex_test_kit/metadata/mock_operation_outcome_resource.json"))
-    end
-
-    def replace_bundle_urls(bundle)
-      reference_server_base = ENV.fetch('FHIR_REFERENCE_SERVER')
-      bundle&.link.map! {|link| {relation: link.relation, url: link.url.gsub(reference_server_base, new_link)}}
-      bundle&.entry&.map! do |bundled_resource| 
-        {fullUrl: bundled_resource.fullUrl.gsub(reference_server_base, new_link),
-         resource: bundled_resource.resource,
-         search: bundled_resource.search
-        }
-      end
-      bundle
-    end
-
-    def replace_export_urls(export_status_output)
-      reference_server_base = ENV.fetch('FHIR_REFERENCE_SERVER')
-      export_status_output['output'].map! { |binary| {type: binary["type"], url: binary["url"].gsub(reference_server_base, new_link)} }
-      export_status_output['request'] = new_link + '/Patient/$export'
-      export_status_output
-    end
-
-    def new_link
-      "#{Inferno::Application['base_url']}\/custom\/pdex_payer_client\/fhir"
-    end
-
-    # @private
-    def absolute_reference(ref, entries, root_url)
-      url = find_matching_entry(ref&.reference, entries, root_url)&.fullUrl
-      ref.reference = url if url
-      ref
-    end
-
-    def fetch_all_bundled_resources(
-          reply_handler: nil,
-          max_pages: 0,
-          additional_resource_types: [],
-          resource_type: self.resource_type
-        )
-      page_count = 1
-      resources = []
-      bundle = resource
-      resources += bundle&.entry&.map { |entry| entry&.resource }
-
-      until bundle.nil? || (page_count == max_pages && max_pages != 0)
-        
-        next_bundle_link = bundle&.link&.find { |link| link.relation == 'next' }&.url
-        reply_handler&.call(response)
-
-        break if next_bundle_link.blank?
-
-        reply = fhir_client.raw_read_url(next_bundle_link)
-
-        store_request('outgoing') { reply }
-        error_message = cant_resolve_next_bundle_message(next_bundle_link)
-
-        assert_response_status(200)
-        assert_valid_json(reply.body, error_message)
-
-        bundle = fhir_client.parse_reply(FHIR::Bundle, fhir_client.default_format, reply)
-        resources += bundle&.entry&.map { |entry| entry&.resource }
-
-        page_count += 1
-      end
-      valid_resource_types = [resource_type, 'OperationOutcome'].concat(additional_resource_types)
-      resources
-    end
-
-    # @private
-    def find_matching_entry(ref, entries, root_url = '')
-      ref = "#{root_url}/#{ref}" if relative_reference?(ref) && root_url&.present?
-
-      entries&.find { |entry| entry&.fullUrl == ref }
-    end
-
-    # @private
-    def relative_reference?(ref)
-      ref&.count('/') == 1
-    end
-  end
-end

data/lib/davinci_pdex_test_kit/pdex_payer_client/client_member_match_tests/client_member_match_submit_test.rb

@@ -1,24 +0,0 @@
-require_relative '../../urls'
-
-module DaVinciPDexTestKit
-  class PDexClientMemberMatchSubmitTest < Inferno::Test
-    include URLs
-
-    id :initial_member_match_submit_test
-    title 'Client makes a $member-match request'
-    description %(
-      This test will await a $member-match request and proceed once a request is received.
-    )
-    input :access_token
-
-    run do
-      wait(
-        identifier: access_token,
-        message: %(
-          Access Token: #{access_token} \n
-          Submit a PDex $member-match request to `#{member_match_url}`.
-        )
-      )
-    end
-  end
-end

data/lib/davinci_pdex_test_kit/pdex_payer_client/client_must_support_tests/client_member_match_must_support_submit_test.rb

@@ -1,26 +0,0 @@
-require_relative '../../urls'
-
-module DaVinciPDexTestKit
-  class PDexClientMemberMatchMustSupportSubmitTest < Inferno::Test
-    include URLs
-
-    id :initial_member_match_must_support_submit_test
-    title '$member-match requests span all Must Supports'
-    description %(
-      This test will receive $member-match requests until the user specifies they are done.  It then checks all received $member-match requests for Must Support coverage.
-    )
-    input :access_token
-    config options: { accepts_multiple_requests: true }
-
-    run do
-      wait(
-        identifier: access_token,
-        message: %(
-          Access Token: #{access_token} \n
-          Submit PDex $member-match request(s) to `#{member_match_url}`, and [click here](#{resume_pass_url}?token=#{access_token}) when all Must Support
-          elements have been covered.
-        )
-      )
-    end
-  end
-end

data/lib/davinci_pdex_test_kit/pdex_payer_client/client_must_support_tests/client_member_match_must_support_validation_test.rb

@@ -1,32 +0,0 @@
-require_relative '../client_validation_test.rb'
-require_relative '../../group_metadata.rb'
-
-module DaVinciPDexTestKit
-  class PDexInitialMemberMatchMustSupportValidationTest < Inferno::Test
-    include DaVinciPDexTestKit::MustSupportTest
-    include DaVinciPDexTestKit::ClientValidationTest
-    include URLs
-
-    id :initial_member_match_must_support_validation_test
-    title 'All must support elements are provided in the received $member-match requests'
-    description %(
-      This test verifies that the client is capable of making $member-match requests 
-    )
-    input :access_token
-
-    def resource_type
-      'Parameters'
-    end
-
-    def self.metadata
-      @metadata ||= DaVinciPDexTestKit::GroupMetadata.new(YAML.load_file(File.join(__dir__, 'metadata.yml'), aliases: true))
-    end
-
-    run do
-
-      assert all_member_match_requests, "No previous $member-match requests received"
-
-      perform_must_support_test(all_member_match_requests.map {|match_request| FHIR::Parameters.new(JSON.parse(match_request.request_body).to_h)})
-    end
-  end
-end

data/lib/davinci_pdex_test_kit/pdex_payer_client/client_must_support_tests/metadata.yml

@@ -1,61 +0,0 @@
----
-:name: hrex_member_match_request_parameters
-:class_name: HRexMemberMatchRequestParameters
-:version: 1.0.0
-:reformatted_version: v1.0.0
-:resource: Parameters
-:profile_url: http://hl7.org/fhir/us/davinci-hrex/StructureDefinition/hrex-parameters-member-match-in
-:profile_name: HRex Member Match Request Parameters
-:profile_version: 1.0.0
-:title: Member Match Request Parameters
-:short_description: "The Parameters profile for Da Vinci Find Member using Patient and Coverage Resources Request. The resource must contain: \n * MemberPatient - US Core Patient containing member demographics \n  * CoverageToMatch - details of prior health plan coverage provided by the member, typically from their health plan coverage card \n  * CoverageToLink - details of new or prospective health plan coverage, provided by the health plan based upon the member's enrolment"
-:is_delayed: false
-:interactions: []
-:operations: []
-:include_params: []
-:revincludes: []
-:required_concepts: []
-:must_supports:
-  :extensions: []
-  :slices: 
-  - :slice_id: Parameters.parameter:MemberPatient
-    :slice_name: MemberPatient
-    :path: parameter
-    :discriminator:
-      :type: value
-      :values:
-      - :path: name
-        :value: MemberPatient
-  - :slice_id: Parameters.parameter:CoverageToMatch
-    :slice_name: CoverageToMatch
-    :path: parameter
-    :discriminator:
-      :type: value
-      :values:
-      - :path: name
-        :value: CoverageToMatch
-  - :slice_id: Parameters.parameter:CoverageToLink
-    :slice_name: CoverageToLink
-    :path: parameter
-    :discriminator:
-      :type: value
-      :values:
-      - :path: name
-        :value: CoverageToLink
-  - :slice_id: Parameters.parameter:Consent
-    :slice_name: Consent
-    :path: parameter
-    :discriminator:
-      :type: value
-      :values:
-      - :path: name
-        :value: Consent
-  :elements:
-  - :path: parameter:MemberPatient.resource
-  - :path: parameter:CoverageToMatch.resource
-  - :path: parameter:CoverageToLink.resource
-  - :path: parameter:Consent.resource
-:mandatory_elements:
-
-
-

data/lib/davinci_pdex_test_kit/pdex_payer_client/clinical_data_request_tests/initial_scratch_storing.rb

@@ -1,32 +0,0 @@
-require_relative '../client_validation_test.rb'
-module DaVinciPDexTestKit
-  class PDexClientScratchStorage < Inferno::Test
-    include DaVinciPDexTestKit::ClientValidationTest
-
-    id :initial_scratch_storing
-    title 'Client makes clinical data requests that capture an entire patient'
-    description %(
-      This test organizes the received requests in order to validate all expected specific resources were returned
-    )
-    input :access_token
-
-    run do
-      previous_clinical_data_request_resources.each do |request, resources|
-        resources.each do |resource|
-          scratch[resource.resourceType.to_sym] ||= []
-          scratch[resource.resourceType.to_sym] |= [resource]
-        end
-      end
-      if !export_resources.empty?
-        info "Attempted an $export request"
-        export_resources.each do |resource|
-          scratch[resource.resourceType.to_sym] ||= []
-          scratch[resource.resourceType.to_sym] |= [resource]
-        end
-      end
-      if everything_request
-        info "Attempted an $everything request"
-      end
-    end
-  end
-end

data/lib/davinci_pdex_test_kit/pdex_payer_client/clinical_data_request_tests/initial_wait_test.rb

@@ -1,31 +0,0 @@
-require_relative '../../urls'
-module DaVinciPDexTestKit
-  class PDexClientSubmitMustSupportTest < Inferno::Test
-    include URLs
-
-    id :initial_wait_test
-    title 'Client makes clinical data requests'
-    description %(
-      This test will receive clinical data requests until the user confirms they are done. 
-    )
-    input :access_token
-    config options: { accepts_multiple_requests: true }
-
-    run do
-      wait(
-        identifier: access_token,
-        message: %(
-          Access Token: #{access_token} \n
-          Submit PDex requests via at least one of the following methods:
-          * Single Resource API: `#{submit_url}`, with `:endpoint` replaced with the endpoint you want to reach
-          * $everything method: `#{everything_url}`, with `:patient` replaced with the patient you are matching
-          * $export method: `#{export_url}`, see workflow process at the [Bulk Data IG](https://hl7.org/fhir/uv/bulkdata/STU2/)
-          * $export-poll-status: `#{export_status_url}`, then continue to make reads from the binaries if a payload is delivered
-          
-          and [click here](#{resume_clinical_data_url}?token=#{access_token}) when done.
-        ),
-        timeout: 900
-      )
-    end
-  end
-end

data/lib/davinci_pdex_test_kit/tags.rb

@@ -1,11 +0,0 @@
-# frozen_string_literal: true
-
-module DaVinciPDexTestKit
-  AUTH_TAG = 'pdex_auth'
-  SUBMIT_TAG = 'pdex_submit'
-  BINARY_TAG = 'pdex_binary'
-  EXPORT_TAG = 'pdex_export'
-  EXPORT_STATUS_TAG = 'pdex_export_status'
-  EVERYTHING_TAG = 'pdex_everything'
-  MEMBER_MATCH_TAG = 'pdex_member_match'
-end