davinci_pdex_test_kit 0.9.1

data/lib/davinci_pdex_test_kit/metadata/mock_operation_outcome_resource.json

@@ -0,0 +1,16 @@
+{
+  "resourceType" : "OperationOutcome",
+  "id" : "warning",
+  "text" : {
+    "status" : "generated",
+    "div" : "<div xmlns=\"http://www.w3.org/1999/xhtml\">Inferno does not support a query of this kind.</div>"
+  },
+  "issue" : [{
+    "severity" : "warning",
+    "code" : "not-found",
+    "details" : {
+      "text" : "Inferno does not support a query of this kind."
+    }
+  }]
+}
+

data/lib/davinci_pdex_test_kit/mock_server.rb

@@ -0,0 +1,247 @@
+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'},
+        )
+    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 = response.headers.reject!{|key, value| key == "transfer-encoding"} # chunked causes problems for client
+        request.response_body = response_resource.to_json
+      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 = response.headers.reject!{|key, value| key == "transfer-encoding"}
+      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 = response.headers.reject!{|key, value| key == "transfer-encoding"}
+      request.response_body = replace_bundle_urls(FHIR.from_contents(response.body)).to_json
+    end
+
+    # def export_response(request, test = nil, test_result = nil)
+    #   response = server_proxy.get do |req|
+    #     req.url 'Group/pdex-Group/$export' #TODO: change from static response
+    #     req.headers['Prefer'] = 'respond-async'
+    #     req.headers['Accept'] = 'application/fhir+json'
+    #   end
+    #   request.status = response.status
+    #   request.response_headers = response.env.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 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
+
+    # Drop the last two segments of a URL, i.e. the resource type and ID of a FHIR resource
+    # e.g. http://example.org/fhir/Patient/123 -> http://example.org/fhir
+    # @private
+    def base_url(url)
+      return unless url.start_with?('http://', 'https://')
+
+      # Drop everything after the second to last '/', ignoring a trailing slash
+      url.sub(%r{/[^/]*/[^/]*(/)?\z}, '')
+    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, 'http://localhost:4567/custom/pdex_payer_client/fhir')}}
+      bundle&.entry&.map! do |bundled_resource| 
+        {fullUrl: bundled_resource.fullUrl.gsub(reference_server_base, 'http://localhost:4567/custom/pdex_payer_client/fhir'),
+         resource: bundled_resource.resource,
+         search: bundled_resource.search
+        }
+      end
+      bundle
+    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/must_support_test.rb

@@ -0,0 +1,252 @@
+require_relative 'fhir_resource_navigation'
+
+module DaVinciPDexTestKit
+  module MustSupportTest
+    extend Forwardable
+    include FHIRResourceNavigation
+
+    def_delegators 'self.class', :metadata
+
+    def all_scratch_resources
+      scratch_resources[:all] ||= []
+    end
+
+    def tagged_resources(tag)
+      resources = []
+      load_tagged_requests(tag)
+      return resources if requests.empty?
+
+      requests.each do |req|
+        begin
+          bundle = FHIR.from_contents(req.request_body)
+        rescue StandardError
+          next
+        end
+
+        next unless bundle.is_a?(FHIR::Bundle)
+
+        resources << bundle
+        entry_resources = bundle.entry.map(&:resource)
+        resources.concat(entry_resources)
+      end
+
+      resources
+    end
+
+    def all_must_support_errors
+      @all_must_support_errors ||= []
+    end
+
+    def validate_must_support
+      assert all_must_support_errors.empty?, all_must_support_errors.join("\n")
+    end
+
+    def perform_must_support_test(resources)
+      assert resources.present?, "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?
+
+      return unless (missing_elements + missing_slices + missing_extensions).compact.reject(&:empty?).present?
+
+      pass if (missing_elements + missing_slices + missing_extensions).empty?
+      assert false, "Could not find #{missing_must_support_strings.join(', ')} in the #{resources.length} " \
+                    "provided #{resource_type} resource(s)"
+    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[:slice_id]) }
+        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[:slice_id] == slice_name } }
+        )
+    end
+
+    def missing_must_support_strings
+      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] }
+    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|
+            path = extension_definition[:path]
+            if extension_definition[:path] == 'extension'
+              resource.extension.any? { |extension| extension.url == extension_definition[:url] }
+            else
+              extension = find_a_value_at(resource, path) do |el|
+                el.url == extension_definition[:url]
+              end
+
+              extension&.url == extension_definition[:url]
+            end
+          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|
+          # PAS: The MS Claim.supportingInfo slices do not have timing[x]
+          next if resource_type == 'Claim' && element_definition[:path] == 'supportingInfo.timing[x]'
+
+          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.except('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.compact
+    end
+
+    def must_support_slices
+      metadata.must_supports[:slices]
+    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
+            res = element.try(:resource) || element
+            res.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? do |value_definition|
+              (value_definition[:value].present? && value_definition[:value] == el_found) ||
+                (value_definition[:value].blank? && el_found.present?)
+            end
+
+            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/davinci_pdex_test_kit/pdex_payer_client/client_member_match_tests/client_member_match_submit_test.rb

@@ -0,0 +1,24 @@
+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_member_match_tests/client_member_match_validation_test.rb

@@ -0,0 +1,23 @@
+require_relative '../client_validation_test.rb'
+
+module DaVinciPDexTestKit
+  class PDexInitialMemberMatchValidationTest < Inferno::Test
+    include DaVinciPDexTestKit::ClientValidationTest
+    include URLs
+
+    id :initial_member_match_validation_test
+    title 'Client provides a valid $member-match request'
+    description %(
+      This test will validate the received $member-match-request input, ensuring it corresponds to the [HRex member-match-in profile](http://hl7.org/fhir/us/davinci-hrex/StructureDefinition/hrex-parameters-member-match-in)
+    )
+    input :access_token
+
+    run do
+      skip_if !member_match_request.present?, "No previous $member-match request received"
+      
+      parameters = FHIR.from_contents(member_match_request.request_body)
+      assert_resource_type(:parameters, resource: parameters)
+      assert_valid_resource(resource: parameters, profile_url: 'http://hl7.org/fhir/us/davinci-hrex/StructureDefinition/hrex-parameters-member-match-in')
+    end
+  end
+end

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

@@ -0,0 +1,26 @@
+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

@@ -0,0 +1,32 @@
+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