davinci_pas_test_kit 0.9.0

data/lib/davinci_pas_test_kit/custom_groups/v2.0.1/pas_client_approval_group.rb

@@ -0,0 +1,26 @@
+require_relative 'client_tests/pas_client_approval_submit_test'
+require_relative 'client_tests/pas_client_approval_submit_response_attest'
+require_relative '../../generated/v2.0.1/client_tests/client_pas_request_bundle_validation_test'
+
+module DaVinciPASTestKit
+  module DaVinciPASV201
+    class PASClientApprovalGroup < Inferno::TestGroup
+      id :pas_client_v201_approval_group
+      title 'Demonstrate Approval Workflow'
+      description %(
+        Demonstrate the ability of the client to initiate a prior authorization
+        request and respond appropriately to an 'approved' decision.
+      )
+      run_as_group
+
+      test from: :pas_client_v201_approval_submit_test,
+           receives_request: :approval_claim
+
+      test from: :pas_client_v201_pas_request_bundle_validation_test,
+           uses_request: :approval_claim
+
+      test from: :pas_client_v201_approval_submit_response_attest,
+           uses_request: :approval_claim
+    end
+  end
+end

data/lib/davinci_pas_test_kit/custom_groups/v2.0.1/pas_client_authentication_group.rb

@@ -0,0 +1,49 @@
+require_relative 'client_tests/pas_client_token_request_test'
+require_relative 'client_tests/pas_client_token_validation_test'
+
+module DaVinciPASTestKit
+  module DaVinciPASV201
+    class PASClientAuthenticationGroup < Inferno::TestGroup
+      id :pas_client_v201_authentication_group
+      title 'Demonstrate Authorization'
+      description %(
+        This group of tests allows Inferno to act as a OAuth server
+        and provide access tokens for the client under test to use
+        when making further requests.
+
+        The tests assume that the authentication workflow starts
+        after client registration. Upon clicking the "Run Tests" button
+        in the upper right, Inferno will ask for an input for the `client_id`
+        that was used for client registration, or manually configured in the
+        client.
+
+        Before submitting a token request, click the "Submit" button at the
+        bottom of the dialog to confirm the `client_id` that Inferno will
+        watch for.
+
+        Finally, make a valid token request that includes the specified `client_id`
+        to indicated token endpoint. This should be a POST of an `x-www-form-encoded`
+        body containing keys for `grant_type` with a value of `client_crendials` and
+        `client_id` with a value of the configured `client_id` value. For example, if
+        the `client_id` value was `123`, then the body of the request would be:
+
+        ```grant_type=client_credentials&client_id=123```
+
+        The response json object will include an `access_token` key, for example:
+
+        ```{"access_token":"97e792038d922bc3cf388b608e45c318","token_type":"bearer","expires_in":300}```
+
+        The value of the `access_token` key (`97e792038d922bc3cf388b608e45c318` in the example)
+        must be sent with every subsequent request to Inferno during this session in
+        the "Authorization" HTTP header with prefix "Bearer: ". In this example, the
+        Authorization HTTP header would have value:
+
+        ```Bearer: 97e792038d922bc3cf388b608e45c318```
+      )
+      run_as_group
+
+      test from: :pas_client_v201_token_request_test
+      test from: :pas_client_v201_token_validation_test
+    end
+  end
+end

data/lib/davinci_pas_test_kit/custom_groups/v2.0.1/pas_client_denial_group.rb

@@ -0,0 +1,41 @@
+require_relative 'client_tests/pas_client_denial_submit_test'
+require_relative 'client_tests/pas_client_denial_submit_response_attest'
+require_relative '../../generated/v2.0.1/client_tests/client_denial_pas_response_bundle_validation_test'
+require_relative '../../generated/v2.0.1/client_tests/client_pas_request_bundle_validation_test'
+require_relative '../../user_input_response'
+
+module DaVinciPASTestKit
+  module DaVinciPASV201
+    class PASClientDenialGroup < Inferno::TestGroup
+      include UserInputResponse
+      id :pas_client_v201_denial_group
+      title 'Demonstrate Denial Workflow'
+      description %(
+        Demonstrate the ability of the client to initiate a prior authorization
+        request and respond appropriately to a 'denied' decision.
+      )
+      run_as_group
+
+      input :denial_json_response,
+            title: 'Claim denied response JSON',
+            type: 'textarea',
+            optional: true,
+            description: %(
+              The response provided will be validated against the PAS Response Bundle profile. If determined to be
+              invalid, a validation message will be returned, and the test group will be skipped.
+            )
+
+      test from: :pas_client_v201_denial_submit_test,
+           receives_request: :denial_claim,
+           respond_with: :denial_json_response
+
+      test from: :pas_client_v201_denial_pas_response_bundle_validation_test
+
+      test from: :pas_client_v201_pas_request_bundle_validation_test,
+           uses_request: :denial_claim
+
+      test from: :pas_client_v201_denial_submit_response_attest,
+           uses_request: :denial_claim
+    end
+  end
+end

data/lib/davinci_pas_test_kit/custom_groups/v2.0.1/pas_client_pended_group.rb

@@ -0,0 +1,56 @@
+require_relative 'client_tests/pas_client_pended_submit_test'
+require_relative 'client_tests/pas_client_pended_submit_response_attest'
+require_relative 'client_tests/pas_client_pended_inquire_test'
+require_relative 'client_tests/pas_client_pended_inquire_response_attest'
+require_relative '../../generated/v2.0.1/client_tests/client_pended_pas_response_bundle_validation_test'
+require_relative '../../generated/v2.0.1/client_tests/client_pas_request_bundle_validation_test'
+require_relative '../../generated/v2.0.1/client_tests/client_pended_pas_inquiry_request_bundle_validation_test'
+require_relative '../../user_input_response'
+
+module DaVinciPASTestKit
+  module DaVinciPASV201
+    class PASClientPendedGroup < Inferno::TestGroup
+      include UserInputResponse
+      id :pas_client_v201_pended_group
+      title 'Demonstrate Pended Workflow'
+      description %(
+        Demonstrate the ability of the client to initiate a prior authorization
+        request and respond appropriately to a 'pended' decision, including
+        waiting for a notification that an update has been made (not currently
+        implemented) and making an inquiry request to retrieve the final result.
+      )
+      run_as_group
+
+      input :pended_json_response,
+            title: 'Claim pended response JSON',
+            type: 'textarea',
+            optional: true,
+            description: %(
+              The response provided will be validated against the PAS Response Bundle profile. If determined to be
+              invalid, a validation message will be returned, and the test group will be skipped.
+            )
+
+      test from: :pas_client_v201_pended_submit_test,
+           receives_request: :pended_claim,
+           respond_with: :pended_json_response
+
+      test from: :pas_client_v201_pended_pas_response_bundle_validation_test
+
+      test from: :pas_client_v201_pas_request_bundle_validation_test,
+           uses_request: :pended_claim
+
+      test from: :pas_client_v201_pended_submit_response_attest,
+           uses_request: :pended_claim
+
+      test from: :pas_client_v201_pended_inquire_test,
+           uses_request: :pended_claim,
+           receives_request: :pended_inquiry
+
+      test from: :pas_client_v201_pended_pas_inquiry_request_bundle_validation_test,
+           uses_request: :pended_inquiry
+
+      test from: :pas_client_v201_pended_inquire_response_attest,
+           uses_request: :pended_inquiry
+    end
+  end
+end

data/lib/davinci_pas_test_kit/custom_groups/v2.0.1/pas_error_group.rb

@@ -0,0 +1,20 @@
+require_relative 'error_tests/pas_submission_error_test'
+require_relative 'error_tests/pas_inquiry_error_test'
+
+module DaVinciPASTestKit
+  module DaVinciPASV201
+    class PASErrorGroup < Inferno::TestGroup
+      title 'Demonstrate Error Handling'
+      description %(
+        Validates Prior Authorization transaction error handling for malformed
+        request bundles.
+      )
+
+      id :pas_v201_error_group
+      run_as_group
+
+      test from: :prior_auth_submission_error
+      test from: :prior_auth_inquiry_error
+    end
+  end
+end

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

@@ -0,0 +1,98 @@
+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_pas_test_kit/ext/inferno_core/request.rb

@@ -0,0 +1,19 @@
+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_pas_test_kit/ext/inferno_core/runnable.rb

@@ -0,0 +1,18 @@
+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_pas_test_kit/fhir_resource_navigation.rb

@@ -0,0 +1,72 @@
+# frozen_string_literal: true
+
+require 'json'
+
+module DaVinciPASTestKit
+  module FHIRResourceNavigation
+    DAR_EXTENSION_URL = 'http://hl7.org/fhir/StructureDefinition/data-absent-reason'
+
+    def resolve_path(elements, path)
+      elements = Array.wrap(elements)
+      return elements if path.blank?
+
+      paths = path.split('.')
+      segment = paths.first
+      remaining_path = paths.drop(1).join('.')
+
+      elements.flat_map do |element|
+        child = get_next_value(element, segment)
+        resolve_path(child, remaining_path)
+      end.compact
+    end
+
+    def find_a_value_at(element, path, include_dar: false, &block)
+      return nil if element.nil?
+
+      elements = Array.wrap(element)
+
+      if path.blank?
+        unless include_dar
+          elements = elements.reject do |el|
+            el.respond_to?(:extension) && el.extension.any? { |ext| ext.url == DAR_EXTENSION_URL }
+          end
+        end
+
+        return elements.find(&block) if block_given?
+
+        return elements.first
+      end
+
+      path_segments = path.split('.')
+      segment = path_segments.shift.delete_suffix('[x]').to_sym
+
+      no_elements_present =
+        elements.none? do |elmt|
+          child = get_next_value(elmt, segment)
+          child.present? || child == false
+        end
+
+      return nil if no_elements_present
+
+      remaining_path = path_segments.join('.')
+      elements.each do |elmt|
+        child = get_next_value(elmt, segment)
+        element_found = if block_given?
+                          find_a_value_at(child, remaining_path, include_dar:, &block)
+                        else
+                          find_a_value_at(child, remaining_path, include_dar:)
+                        end
+
+        return element_found if element_found.present? || element_found == false
+      end
+
+      nil
+    end
+
+    def get_next_value(element, property)
+      element.send(property)
+    rescue NoMethodError
+      nil
+    end
+  end
+end

data/lib/davinci_pas_test_kit/generated/v2.0.1/beneficiary/client_inquiry_request_beneficiary_must_support_test.rb

@@ -0,0 +1,75 @@
+require_relative '../../../must_support_test'
+require_relative '../../../generator/group_metadata'
+require_relative '../../../tags'
+
+module DaVinciPASTestKit
+  module DaVinciPASV201
+    class ClientInquiryRequestBeneficiaryMustSupportTest < Inferno::Test
+      include DaVinciPASTestKit::MustSupportTest
+
+      title 'All must support elements for Profile PAS Beneficiary Patient are observed across all instances submitted'
+      description %(
+        
+        PAS client systems are required to be able to populate all
+        must support elements on instances of all profiles included in 
+        requests, including instances of the PAS Beneficiary Patient Profile.
+        This test checks all identified instances of the PAS Beneficiary Patient
+        Profile on requests sent by the client to ensure that the following 
+        must support elements are observed: 
+
+        * Patient.address
+        * Patient.address.city
+        * Patient.address.country
+        * Patient.address.district
+        * Patient.address.line
+        * Patient.address.period
+        * Patient.address.postalCode
+        * Patient.address.state
+        * Patient.birthDate
+        * Patient.communication
+        * Patient.communication.language
+        * Patient.extension:birthsex
+        * Patient.extension:ethnicity
+        * Patient.extension:race
+        * Patient.gender
+        * Patient.identifier
+        * Patient.identifier.system
+        * Patient.identifier.value
+        * Patient.multipleBirth[x]:multipleBirthInteger
+        * Patient.name
+        * Patient.name.family
+        * Patient.name.given
+        * Patient.name.prefix
+        * Patient.name.suffix
+        * Patient.telecom
+        * Patient.telecom.system
+        * Patient.telecom.use
+        * Patient.telecom.value
+      )
+
+      id :pas_client_inquiry_request_v201_beneficiary_must_support_test
+
+      def resource_type
+        'Patient'
+      end
+
+      def self.metadata
+        @metadata ||= Generator::GroupMetadata.new(YAML.load_file(File.join(__dir__, 'metadata.yml'), aliases: true))
+      end
+
+      def scratch_resources
+        scratch[:inquiry_request_resources] ||= {}
+      end
+
+      def resources_of_interest
+        collection = tagged_resources(INQUIRE_TAG).presence || all_scratch_resources
+        collection.select { |res| res.resourceType == resource_type }
+      end
+
+      run do
+        perform_must_support_test(resources_of_interest)
+        validate_must_support
+      end
+    end
+  end
+end

data/lib/davinci_pas_test_kit/generated/v2.0.1/beneficiary/client_submit_request_beneficiary_must_support_test.rb

@@ -0,0 +1,75 @@
+require_relative '../../../must_support_test'
+require_relative '../../../generator/group_metadata'
+require_relative '../../../tags'
+
+module DaVinciPASTestKit
+  module DaVinciPASV201
+    class ClientSubmitRequestBeneficiaryMustSupportTest < Inferno::Test
+      include DaVinciPASTestKit::MustSupportTest
+
+      title 'All must support elements for Profile PAS Beneficiary Patient are observed across all instances submitted'
+      description %(
+        
+        PAS client systems are required to be able to populate all
+        must support elements on instances of all profiles included in 
+        requests, including instances of the PAS Beneficiary Patient Profile.
+        This test checks all identified instances of the PAS Beneficiary Patient
+        Profile on requests sent by the client to ensure that the following 
+        must support elements are observed: 
+
+        * Patient.address
+        * Patient.address.city
+        * Patient.address.country
+        * Patient.address.district
+        * Patient.address.line
+        * Patient.address.period
+        * Patient.address.postalCode
+        * Patient.address.state
+        * Patient.birthDate
+        * Patient.communication
+        * Patient.communication.language
+        * Patient.extension:birthsex
+        * Patient.extension:ethnicity
+        * Patient.extension:race
+        * Patient.gender
+        * Patient.identifier
+        * Patient.identifier.system
+        * Patient.identifier.value
+        * Patient.multipleBirth[x]:multipleBirthInteger
+        * Patient.name
+        * Patient.name.family
+        * Patient.name.given
+        * Patient.name.prefix
+        * Patient.name.suffix
+        * Patient.telecom
+        * Patient.telecom.system
+        * Patient.telecom.use
+        * Patient.telecom.value
+      )
+
+      id :pas_client_submit_request_v201_beneficiary_must_support_test
+
+      def resource_type
+        'Patient'
+      end
+
+      def self.metadata
+        @metadata ||= Generator::GroupMetadata.new(YAML.load_file(File.join(__dir__, 'metadata.yml'), aliases: true))
+      end
+
+      def scratch_resources
+        scratch[:submit_request_resources] ||= {}
+      end
+
+      def resources_of_interest
+        collection = tagged_resources(SUBMIT_TAG).presence || all_scratch_resources
+        collection.select { |res| res.resourceType == resource_type }
+      end
+
+      run do
+        perform_must_support_test(resources_of_interest)
+        validate_must_support
+      end
+    end
+  end
+end