davinci_pdex_test_kit 0.10.6 → 0.11.0

data/lib/davinci_pdex_test_kit/pdex_payer_client/mock_server/member_match_endpoint.rb

@@ -0,0 +1,51 @@
+require_relative '../tags'
+require_relative 'proxy_endpoint'
+
+module DaVinciPDexTestKit
+  module PDexPayerClient
+    module MockServer
+      # Although this enpoint is not actually proxying, inherit from ProxyEndpoint to keep
+      # #test_run_identifier and #update_result
+      class MemberMatchEndpoint < ProxyEndpoint    
+        def make_response
+          #remove token from request as well
+          #original_request_as_hash = JSON.parse(request.body.string).to_h
+          #request.body.string = original_request_as_hash.to_json
+  
+          #TODO: Change from static response
+          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
+  
+          response.status = 200
+          response.format = 'application/fhir+json'
+        end
+    
+        def tags
+          [MEMBER_MATCH_TAG]
+        end
+    
+      end
+    end
+  end
+end

data/lib/davinci_pdex_test_kit/pdex_payer_client/mock_server/next_page_endpoint.rb

@@ -0,0 +1,23 @@
+require_relative '../tags'
+require_relative 'proxy_endpoint'
+
+module DaVinciPDexTestKit
+  module PDexPayerClient
+    module MockServer
+      class NextPageEndpoint < ProxyEndpoint
+    
+        def make_response
+          server_response = server_proxy.get('', JSON.parse(request.params.to_json))
+          response.status = server_response.status
+          response.format = 'application/fhir+json'
+          response.body = replace_bundle_urls(FHIR.from_contents(server_response.body)).to_json
+        end
+    
+        def tags
+          [RESOURCE_REQUEST_TAG]
+        end
+    
+      end
+    end
+  end
+end

data/lib/davinci_pdex_test_kit/pdex_payer_client/mock_server/patient_endpoint.rb

@@ -0,0 +1,25 @@
+require_relative '../tags'
+require_relative '../urls'
+require_relative 'proxy_endpoint'
+
+module DaVinciPDexTestKit
+  module PDexPayerClient
+    module MockServer
+      class PatientEndpoint < ProxyEndpoint
+        include ::DaVinciPDexTestKit::PDexPayerClient::URLs
+
+        def make_response
+          super
+        end
+
+        def tags
+          tags = [RESOURCE_REQUEST_TAG]
+          tags << PATIENT_ID_REQUEST_TAG if request.url.include?('99999')
+          
+          tags
+        end
+    
+      end
+    end
+  end
+end

data/lib/davinci_pdex_test_kit/pdex_payer_client/mock_server/patient_everything_endpoint.rb

@@ -0,0 +1,34 @@
+require_relative '../tags'
+require_relative 'proxy_endpoint'
+
+module DaVinciPDexTestKit
+  module PDexPayerClient
+    module MockServer
+      class PatientEverythingEndpoint < ProxyEndpoint
+    
+        def make_response
+          # server_response = proxy_request(request, strict: false) # disable strict to allow $everything request without parameters
+          # response = proxy_response(server_response)
+          patient_id = request.url.match(/Patient\/([A-Za-z0-9\-\.]{1,64})\/\$everything/)&.to_a&.at(1)
+
+          if patient_id.nil?
+            response.status = 400
+            response.body = "Invalid patient id for Patient $everything request: #{request.url}"
+            response.format = :text
+          else
+            server_response = server_proxy.get("Patient/#{patient_id}/$everything")
+          
+            response.status = server_response.status
+            response.body = replace_bundle_urls(FHIR.from_contents(server_response.body)).to_json
+            response.format = 'application/fhir+json'
+          end
+        end
+    
+        def tags
+          [EVERYTHING_TAG]
+        end
+    
+      end
+    end
+  end
+end

data/lib/davinci_pdex_test_kit/pdex_payer_client/mock_server/proxy_endpoint.rb

@@ -0,0 +1,178 @@
+require 'faraday'
+require 'faraday_middleware'
+
+require_relative '../urls'
+
+module DaVinciPDexTestKit
+  module PDexPayerClient
+    module MockServer
+      # @abstract
+      # This class defines
+      # - a Faraday connection for proxying requests to ENV['FHIR_REFERENCE_SERVER']
+      # - common methods and conventions for PDex Client Testing endpoints
+      class ProxyEndpoint < Inferno::DSL::SuiteEndpoint
+
+        include ::DaVinciPDexTestKit::PDexPayerClient::URLs
+  
+        def test_run_identifier
+          request.headers['authorization']&.delete_prefix('Bearer ')
+        end
+  
+        def make_response
+          server_response = proxy_request(request)
+          proxy_response(server_response)
+        end
+
+        def update_result
+          results_repo.update(result.id, result: 'pass') unless test.config.options[:accepts_multiple_requests]
+        end
+    
+        # REST Client that proxies request to server at `ENV[FHIR_REFERENCE_SERVER]`
+        # @return [Faraday] - A Faraday 1.x REST Client
+        # @example
+        #   server_response = server_proxy.get('Patient/1')
+        #   server_response.body # => FHIR JSON String
+        def server_proxy
+          @server_proxy ||= Faraday.new(
+              url: fhir_reference_server,
+              params: {},
+              headers: {
+                'Accept' => 'application/fhir+json,application/json',
+                'Accept-Encoding' => 'identity',
+                'Authorization' => 'Bearer SAMPLE_TOKEN',
+                'Host' => ENV.fetch('HOST_HEADER')
+              }
+            ) do |proxy|
+              proxy.use Faraday::Response::Logger
+            end
+        end
+
+        protected
+
+        def fhir_reference_server
+          ENV.fetch('FHIR_REFERENCE_SERVER')
+        end
+
+        # Modify and send request to server proxy. Intended for use in {#make_response}.
+        # @param request [Hanami::Action::Request]
+        # @option strict [Boolean] if true will return 400 for any requests not allowed by PDex API.
+        #   The implementation of 'strict' is based on {#match_request_to_expectation} and collections.rb
+        # @return [Faraday::Response]
+        def proxy_request(request, strict: true)
+          fhir_endpoint = resource_endpoint(request.url)
+
+          server_params = request.params.to_hash
+          server_params = match_request_to_expectation(fhir_endpoint, server_params) unless request.url.include?('$') # exclude operations as hotfix
+
+          if strict && server_params.empty?
+            Faraday::Response.new(
+              status: 400,
+              response_body: File.read(File.expand_path('resources/mock_operation_outcome_resource.json', __dir__))
+            )
+          else
+            server_proxy.get(fhir_endpoint, server_params)
+          end
+        end
+
+        # Pull resource type from url
+        # @return [String | nil]
+        # @example
+        #   resource_endpoint('http://localhost:4567/custom/pdex_payer_client/fhir/Patient/1') # => 'Patient'
+        def resource_endpoint(url)
+          return unless url.start_with?('http://', 'https://')
+    
+          /custom\/pdex_payer_client\/fhir\/([a-zA-Z_-]+)([\/\?].*)?/.match(url)&.to_a&.at(1)
+        end
+
+        # Filter request parameters to only include those allowed by PDex API (hardcoded in collections.rb)
+        # @return [Hash]
+        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}
+    
+          if matched_search
+            params.select {|key, value| matched_search.include?(key.to_s) || key == "_revInclude" || key == "_include"}
+          else
+            {}
+          end
+        end
+
+        # Modify response to pretend that mock server generated it. Optionally pass a block to make more modifications.
+        # @param server_response [Faraday::Response]
+        # @yield [FHIR::Model] If response is FHIR yield the resource for modifications
+        # @yieldreturn [FHIR::Model]
+        # @return [Hanami::Action::Response] Inferno mock server response
+        # @example
+        #   def make_response
+        #     response = proxy_response(response, Faraday.get('https://example.com/fhir/Patient/1')) do |patient|
+        #       patient.meta.profile << "http://example.com/fhir/my-ig-profile"
+        #     end
+        #   end
+        def proxy_response(server_response, &block)
+          response.status = server_response.status
+
+          if server_response.headers.present?
+            headers = remove_transfer_encoding_header(server_response.headers) 
+            response.headers.merge!(headers)
+          end
+          response.headers.merge!({'Server' => self.class.name.deconstantize})
+
+          if is_fhir?(server_response.body)
+            response.format = 'application/fhir+json'
+            resource = FHIR.from_contents(server_response.body)
+            resource = replace_bundle_urls(resource) if resource.resourceType == 'Bundle'
+
+            resource = yield(resource) if block_given?
+
+            response.body = resource.to_json
+
+          elsif is_json?(server_response.body)
+            response.format = 'application/json'
+            # Uncomment to recklessly replace all proxy urls with our urls:
+            # response.body = server_response.body.gsub(fhir_reference_server, base_fhir_url)
+            response.body = server_response.body
+
+          else
+            # Uncomment to recklessly replace all proxy urls with our urls:
+            # response.body = server_response.body.gsub(fhir_reference_server, base_fhir_url)
+            response.body = server_response.body
+          end
+
+          response
+        end
+
+        def remove_transfer_encoding_header(headers)
+          if !headers["transfer-encoding"].nil?
+            headers.reject!{|key, value| key == "transfer-encoding"}
+          else
+            headers
+          end
+        end
+
+        def is_fhir?(str)
+          !!FHIR.from_contents(str)
+        rescue StandardError
+          false
+        end
+
+        def replace_bundle_urls(bundle)
+          bundle&.link.map! {|link| {relation: link.relation, url: link.url.gsub(fhir_reference_server, base_fhir_url)}}
+          bundle&.entry&.map! do |bundled_resource| 
+            {
+             fullUrl: bundled_resource.fullUrl.gsub(fhir_reference_server, base_fhir_url),
+             resource: bundled_resource.resource,
+             search: bundled_resource.search
+            }
+          end
+          bundle
+        end
+
+        def is_json?(str)
+          !!JSON.parse(str)
+        rescue StandardError
+          false
+        end
+
+      end
+    end
+  end
+end

data/lib/davinci_pdex_test_kit/pdex_payer_client/mock_server/resource_read_endpoint.rb

@@ -0,0 +1,21 @@
+require_relative '../tags'
+require_relative 'proxy_endpoint'
+
+module DaVinciPDexTestKit
+  module PDexPayerClient
+    module MockServer
+      class ResourceReadEndpoint < ProxyEndpoint
+
+        def proxy_request(request)
+          target_resource = request.url.split('/')[-2..-1].join('/')
+          server_proxy.get(target_resource)
+        end
+    
+        def tags
+          [RESOURCE_REQUEST_TAG]
+        end
+    
+      end
+    end
+  end
+end

data/lib/davinci_pdex_test_kit/pdex_payer_client/mock_server/resource_search_endpoint.rb

@@ -0,0 +1,22 @@
+require_relative '../tags'
+require_relative 'proxy_endpoint'
+
+module DaVinciPDexTestKit
+  module PDexPayerClient
+    module MockServer
+      # FIXME: this class is intercepting $export-poll-status requests for some reason
+      # however the $export workflow still works
+      class ResourceSearchEndpoint < ProxyEndpoint
+
+        def make_response
+          super
+        end
+    
+        def tags
+          [RESOURCE_REQUEST_TAG]
+        end
+    
+      end
+    end
+  end
+end

data/lib/davinci_pdex_test_kit/pdex_payer_client/mock_server/token_endpoint.rb

@@ -0,0 +1,27 @@
+require_relative '../tags'
+require_relative 'proxy_endpoint'
+
+module DaVinciPDexTestKit
+  module PDexPayerClient
+    module MockServer
+      # This endpoint is intended to help clients jumpstart the payer-to-payer workflow
+      # but Inferno requires a bearer token to recieve this endpoint anyways so
+      # this doesn't offer much utility.
+      # TODO: open this endpoint, or send auth to another service
+      class TokenEndpoint < ProxyEndpoint
+    
+        def make_response
+          response.status = 200
+          # TODO: derive access_token from suite inputs
+          response.body = { access_token: SecureRandom.hex, token_type: 'bearer', expires_in: 300 }.to_json
+          response.format = :json
+        end
+    
+        def tags
+          [AUTH_TAG]
+        end
+    
+      end
+    end
+  end
+end

data/lib/davinci_pdex_test_kit/pdex_payer_client/mock_server.rb

@@ -0,0 +1,53 @@
+require_relative 'mock_server/token_endpoint'
+require_relative 'mock_server/resource_search_endpoint'
+require_relative 'mock_server/resource_read_endpoint'
+require_relative 'mock_server/patient_endpoint'
+require_relative 'mock_server/binary_endpoint'
+require_relative 'mock_server/patient_everything_endpoint'
+require_relative 'mock_server/export_endpoint'
+require_relative 'mock_server/export_status_endpoint'
+require_relative 'mock_server/member_match_endpoint'
+require_relative 'mock_server/next_page_endpoint'
+
+require_relative '../user_input_response'
+require_relative 'urls'
+require_relative 'collection'
+require_relative 'client_validation_test'
+
+module DaVinciPDexTestKit
+  module PDexPayerClient
+    # FHIR Server for Client TestSuite
+    # Requires URLs and Inferno::DSL::Runnable modules to be included in Client TestSuite
+    module MockServer
+      include URLs
+  
+      # The `suite_endpoint` function is only available in a Runnable, so
+      # we define a hook where when this module is included into a class it's
+      # executed in the class' namespace.
+      def self.included(klass)
+        klass.class_eval do
+
+          # Add your routes/endpoints here, order matters!
+          route :get, METADATA_PATH, Proc.new {
+            [
+              200,
+              {'Content-Type' => 'application/fhir+json;charset=utf8'},
+              File.readlines(File.expand_path('mock_server/resources/mock_capability_statement.json', __dir__))
+            ]
+          }
+          suite_endpoint :post, TOKEN_PATH, TokenEndpoint
+          suite_endpoint :post, MEMBER_MATCH_PATH, MemberMatchEndpoint
+          suite_endpoint :get, EVERYTHING_PATH, PatientEverythingEndpoint
+          suite_endpoint :get, EXPORT_PATH, ExportEndpoint
+          suite_endpoint :get, EXPORT_STATUS_PATH, ExportStatusEndpoint
+          suite_endpoint :get, BINARY_PATH, BinaryEndpoint
+          suite_endpoint :get, PATIENT_PATH, PatientEndpoint # PDex Patient query needs its own endpoint
+          suite_endpoint :get, RESOURCE_PATH, ResourceSearchEndpoint
+          suite_endpoint :get, INSTANCE_PATH, ResourceReadEndpoint
+          suite_endpoint :get, BASE_FHIR_PATH, NextPageEndpoint # TODO: better pagination route?
+
+        end
+      end
+    end
+  end
+end

data/lib/davinci_pdex_test_kit/pdex_payer_client/tags.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+module DaVinciPDexTestKit
+  module PDexPayerClient
+    AUTH_TAG = 'pdex_auth'
+    RESOURCE_REQUEST_TAG = 'pdex_resource_request'
+    PATIENT_ID_REQUEST_TAG = 'pdex_patient_id_request'
+    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
+end

data/lib/davinci_pdex_test_kit/pdex_payer_client/urls.rb

@@ -0,0 +1,51 @@
+# frozen_string_literal: true
+
+module DaVinciPDexTestKit
+  module PDexPayerClient
+
+    module URLs
+      BASE_PATH = "#{Inferno::Application['base_url']}/custom/pdex_payer_client"
+      TOKEN_PATH = '/mock_auth/token'
+      PATIENT_PATH = '/fhir/Patient'
+      RESOURCE_PATH = '/fhir/:endpoint'
+      INSTANCE_PATH = '/fhir/:endpoint/:id'
+      SUBMIT_PATH = '/fhir/:endpoint'   # FIXME duplicate
+      BINARY_PATH = '/fhir/Binary/:id'
+      METADATA_PATH = '/fhir/metadata'
+      EVERYTHING_PATH = '/fhir/Patient/:patient/$everything'
+      MEMBER_MATCH_PATH = '/fhir/Patient/$member-match'
+      EXPORT_PATH = '/fhir/Patient/$export'
+      EXPORT_STATUS_PATH = '/fhir/$export-poll-status'
+      BASE_FHIR_PATH = '/fhir'
+      RESUME_PASS_PATH = '/resume_pass'
+      RESUME_CLINICAL_DATA_PATH = '/resume_clinical_data'
+      RESUME_FAIL_PATH = '/resume_fail'    
+
+      constants.each do |path_constant|
+        # For each constant X_PATH, define x_path()
+        define_method(path_constant.to_s.downcase.to_sym) do
+          URLs.const_get(path_constant)
+        end
+
+        # For each constant X_PATH, define x_url(), which includes base
+        define_method(path_constant.to_s.downcase.gsub(/_path$/, '_url')) do
+          File.join(BASE_PATH, URLs.const_get(path_constant))
+        end
+      end
+
+      # overwrite base_url which is irregular
+      def base_url
+        BASE_PATH
+      end
+
+      # overwrite base_fhir_url which is irregular
+      def base_fhir_url
+        File.join(BASE_PATH, BASE_FHIR_PATH)
+      end
+
+    end
+
+    # Add all constants and dynamically defined methods to PDexPayerClient namespace
+    include URLs
+  end
+end