davinci_pas_test_kit 0.14.0 → 0.15.0

data/lib/davinci_pas_test_kit/custom_groups/v2.0.1/client_tests/pas_client_subscription_pas_conformance_test.rb

@@ -1,30 +0,0 @@
-# frozen_string_literal: true
-
-require_relative '../../../pas_subscription_verification'
-
-module DaVinciPASTestKit
-  module DaVinciPASV201
-    class SubscriptionPASConformanceTest < Inferno::Test
-      include PASSubscriptionVerification
-
-      id :pas_client_v201_subscription_pas_conformance_test
-      title 'Client Subscription PAS Conformance Verification'
-      description %(
-        This test verifies that the Subscription created by the client under test
-        is conformant to PAS requirements on the Subscription, including
-        - The use of the [PAS-defined Subscription
-          Topic](https://hl7.org/fhir/us/davinci-pas/STU2/SubscriptionTopic-PASSubscriptionTopic.html), and
-        - Inclusion of filter criteria for the client's organization.
-      )
-      verifies_requirements 'hl7.fhir.us.davinci-pas_2.0.1@143'
-
-      run do
-        load_tagged_requests(SUBSCRIPTION_CREATE_TAG)
-        skip_if(requests.none?, 'Inferno did not receive a Subscription creation request')
-        subscription_resource = request.request_body
-
-        verify_pas_subscription(subscription_resource)
-      end
-    end
-  end
-end

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

@@ -1,29 +0,0 @@
-require_relative '../../generated/v2.0.1/pas_client_submit_must_support_use_case_group'
-require_relative '../../generated/v2.0.1/pas_client_inquiry_must_support_use_case_group'
-
-module DaVinciPASTestKit
-  module DaVinciPASV201
-    class PASClientMustSupportGroup < Inferno::TestGroup
-      id :pas_client_v201_must_support
-      title 'Must Support Elements'
-      description %(
-        During these tests, the client will show that it supports all PAS-defined profiles and the must support
-        elements defined in them. This includes
-
-        - The ability to make prior authorization submission and inquiry requests that contain all
-          PAS-defined profiles and their must support elements.
-        - The ability to receive in responses to those requests all PAS-defined profiles and their
-          must support elements and continue the prior authorization workflow as appropriate (not currently
-          implemented in these tests).
-
-        Clients under test will be asked to make additional requests to Inferno demonstrating coverage
-        of all must support items in the requests. Note that Inferno will consider requests made during
-        the workflow group of tests, so only profiles and must support elements not demonstrated during
-        those tests need to be submitted as a part of these.
-      )
-
-      group from: :pas_client_v201_submit_must_support_use_case
-      group from: :pas_client_v201_inquiry_must_support_use_case
-    end
-  end
-end

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

@@ -1,25 +0,0 @@
-# frozen_string_literal: true
-
-require 'smart_app_launch_test_kit'
-require 'udap_security_test_kit'
-require_relative '../../tags'
-
-module DaVinciPASTestKit
-  module DaVinciPASV201
-    module PASClientOptions
-      module_function
-
-      SMART_BACKEND_SERVICES_CONFIDENTIAL_ASYMMETRIC =
-        SMARTAppLaunch::SMARTClientOptions::SMART_BACKEND_SERVICES_CONFIDENTIAL_ASYMMETRIC
-      UDAP_CLIENT_CREDENTIALS =
-        UDAPSecurityTestKit::UDAPClientOptions::UDAP_CLIENT_CREDENTIALS
-      OTHER_AUTH = OTHER_AUTH_TAG
-
-      def recursive_remove_input(runnable, input)
-        runnable.inputs.delete(input)
-        runnable.input_order.delete(input)
-        runnable.children.each { |child_runnable| recursive_remove_input(child_runnable, input) }
-      end
-    end
-  end
-end

data/lib/davinci_pas_test_kit/endpoints/claim_endpoint.rb

@@ -1,157 +0,0 @@
-require_relative '../user_input_response'
-require_relative '../response_generator'
-require_relative '../urls'
-require_relative '../jobs/send_pas_subscription_notification'
-require 'subscriptions_test_kit'
-require 'udap_security_test_kit'
-
-module DaVinciPASTestKit
-  class ClaimEndpoint < Inferno::DSL::SuiteEndpoint
-    include SubscriptionsTestKit::SubscriptionsR5BackportR4Client::SubscriptionSimulationUtils
-    include ResponseGenerator
-    include URLs
-
-    # override the one from URLs
-    def suite_id
-      request.path.split('/custom/')[1].split('/')[0] # request.path = {base inferno path}/custom/{suite_id}/...
-    end
-
-    def test_run_identifier
-      return request.params[:session_path] if request.params[:session_path].present?
-
-      UDAPSecurityTestKit::MockUDAPServer.issued_token_to_client_id(
-        request.headers['authorization']&.delete_prefix('Bearer ')
-      )
-    end
-
-    def tags
-      operation_tag = operation == 'submit' ? SUBMIT_TAG : INQUIRE_TAG
-      workflow_tag = WORKFLOW_TAG_MAP[workflow]
-
-      return [operation_tag, workflow_tag] if workflow_tag.present?
-
-      [operation_tag]
-    end
-
-    def workflow
-      case test.id
-      when /.*pended.*/
-        :pended
-      when /.*denial.*/
-        :denial
-      when /.*approval.*/
-        :approval
-      end
-    end
-
-    WORKFLOW_TAG_MAP = {
-      pended: PENDED_WORKFLOW_TAG,
-      denial: DENIAL_WORKFLOW_TAG,
-      approval: APPROVAL_WORKFLOW_TAG
-    }.freeze
-
-    def make_response
-      return if response.status == 401 # set in update_result (expired token handling there)
-
-      response.status = 200
-      response.format = :json
-
-      req_bundle = FHIR.from_contents(request.body.string)
-      claim_entry = req_bundle&.entry&.find { |e| e&.resource&.resourceType == 'Claim' }
-      claim_full_url = claim_entry&.fullUrl
-      if claim_entry.blank? || claim_full_url.blank?
-        handle_missing_required_elements(claim_entry, response)
-        return
-      end
-
-      user_inputted_response = UserInputResponse.user_inputted_response(test, operation, result)
-      if user_inputted_response.present?
-        generated_claim_response_uuid = nil
-        response_bundle_json = update_tester_provided_response(user_inputted_response, claim_full_url)
-      else
-        decision = # always use the workflow, except for pended when the inquire will get approved
-          if operation == 'inquire' && workflow == :pended
-            :approval
-          else
-            workflow
-          end
-        generated_claim_response_uuid = SecureRandom.uuid
-        response_bundle_json = mock_response_bundle(req_bundle, operation, decision, generated_claim_response_uuid)
-      end
-
-      response.body = response_bundle_json
-
-      return unless workflow == :pended && operation == 'submit'
-
-      start_notification_job(response_bundle_json, :approval, generated_claim_response_uuid)
-    end
-
-    def update_result
-      if UDAPSecurityTestKit::MockUDAPServer.request_has_expired_token?(request)
-        UDAPSecurityTestKit::MockUDAPServer.update_response_for_expired_token(response, 'Bearer token')
-        return
-      end
-
-      results_repo.update_result(result.id, 'pass') unless test.config.options[:accepts_multiple_requests]
-    end
-
-    private
-
-    def handle_missing_required_elements(claim_entry, response)
-      response.status = 400
-      details = if claim_entry.blank?
-                  'Required Claim entry missing from bundle'
-                else
-                  'Required element fullUrl missing from Claim entry'
-                end
-      response.body = FHIR::OperationOutcome.new(
-        issue: FHIR::OperationOutcome::Issue.new(severity: 'fatal', code: 'required',
-                                                 details: FHIR::CodeableConcept.new(text: details))
-      ).to_json
-    end
-
-    def operation
-      request.url&.split('$')&.last
-    end
-
-    def start_notification_job(response_bundle_json, decision, generated_claim_response_uuid)
-      notification_bearer_token = client_access_token_input(result)
-      notification_contents = notification_json(response_bundle_json, decision, generated_claim_response_uuid)
-
-      Inferno::Jobs.perform(Jobs::SendPASSubscriptionNotification, test_run.id, test_run.test_session_id, result.id,
-                            notification_bearer_token, notification_contents, test_run_identifier, suite_id)
-    end
-
-    def notification_json(response_bundle_json, decision, generated_claim_response_uuid)
-      user_inputted_notification_json =
-        JSON.parse(result.input_json).find { |i| i['name'] == 'notification_bundle' }['value']
-
-      if user_inputted_notification_json.present?
-        update_tester_provided_notification(user_inputted_notification_json, generated_claim_response_uuid)
-      else
-        generate_notification(response_bundle_json, decision)
-      end
-    end
-
-    def generate_notification(response_bundle_json, decision)
-      subscription = find_subscription(test_run.test_session_id, as_json: true)
-      subscription_reference = "#{fhir_subscription_url}/#{subscription['id']}"
-      subscription_topic = subscription['criteria']
-
-      if find_subscription_content_type(subscription) == 'full-resource'
-        mock_full_resource_notification_bundle(response_bundle_json, subscription_reference, subscription_topic,
-                                               decision)
-      else # assume id-only since empty not allowed - if asked for empty, other failures will occur
-        mock_id_only_notification_bundle(response_bundle_json, subscription_reference, subscription_topic)
-      end
-    end
-
-    def find_subscription_content_type(subscription)
-      content_ext = subscription['channel']['_payload']['extension']
-        .find do |ext|
-          ext['url'] == 'http://hl7.org/fhir/uv/subscriptions-backport/StructureDefinition/backport-payload-content'
-        end
-      content_ext['valueCode'] if content_ext.present?
-    end
-  end
-end

data/lib/davinci_pas_test_kit/fhir_resource_navigation.rb

@@ -1,72 +0,0 @@
-# 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, &)
-      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(&) 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:, &)
-                        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/claim/claim_operation_test.rb

@@ -1,67 +0,0 @@
-module DaVinciPASTestKit
-  module DaVinciPASV201
-    class ClaimOperationTest < Inferno::Test
-
-      id :pas_v201_claim_operation_test
-      title 'Submission of a claim to the $submit operation succeeds'
-      description %(
-        Server SHALL support PAS Submit requests: a POST interaction to
-        the /Claim/$submit endpoint.
-        This test submits a Prior Authorization Submit request to the server and verifies that a
-        response is returned with HTTP status 2XX.
-        The server SHOULD respond within 15 seconds.
-      )
-      verifies_requirements 'hl7.fhir.us.davinci-pas_2.0.1@5', 'hl7.fhir.us.davinci-pas_2.0.1@66', 'hl7.fhir.us.davinci-pas_2.0.1@111', 'hl7.fhir.us.davinci-pas_2.0.1@136', 'hl7.fhir.us.davinci-pas_2.0.1@207'
-
-      input :pa_submit_request_payload,
-            title: 'PAS Submit Request Payload',
-            description: 'Insert Bundle to be sent for PAS Submit Request',
-            type: 'textarea',
-            optional: true
-      input_order :server_endpoint, :smart_credentials
-      output :response_time
-      makes_request :pa_submit
-
-      def scratch_resources
-        scratch[:submit_request_response_pair] ||= {}
-      end
-
-      def request_bundles
-        parsed_payload = JSON.parse(pa_submit_request_payload)
-        [parsed_payload].flatten.compact.uniq
-      end
-
-      def perform_operation(request_payload)
-        start_time = Time.now
-        fhir_operation('/Claim/$submit', body: request_payload, name: :pa_submit)
-        response_time = Time.now - start_time
-
-        if response_time > 15
-          warning %(
-              The server took more that 15 seconds to respond to the Prior Authorization
-              request.
-
-              Response Time: #{response_time}
-            )
-        end
-        
-        assert_response_status([200, 201])
-        assert_valid_json(request.response_body)
-
-        # Save request/response pair
-        scratch_resources[:all] ||= []
-        scratch_resources[:all] << {request_bundle: request.request_body, response_bundle: resource}
-        output response_time:
-      end
-
-      run do
-        skip_if pa_submit_request_payload.blank?, 'No bundle request provided to perform the submit operation'
-        assert_valid_json(pa_submit_request_payload)
-
-        request_bundles.each do |bundle|
-          perform_operation(bundle)
-        end
-      end
-    end
-  end
-end

data/lib/davinci_pas_test_kit/generated/v2.0.1/claim_inquiry/claim_inquiry_operation_test.rb

@@ -1,56 +0,0 @@
-module DaVinciPASTestKit
-  module DaVinciPASV201
-    class ClaimInquiryOperationTest < Inferno::Test
-
-      id :pas_v201_claim_inquiry_operation_test
-      title 'Submission of a claim to the $inquire operation succeeds'
-      description %(
-        Server SHALL support PAS Inquiry requests: a POST interaction to
-        the /Claim/$inquire endpoint.
-        This test submits a Prior Authorization Inquiry request to the server and verifies that a
-        response is returned with HTTP status 2XX.
-      )
-      verifies_requirements 'hl7.fhir.us.davinci-pas_2.0.1@5', 'hl7.fhir.us.davinci-pas_2.0.1@111', 'hl7.fhir.us.davinci-pas_2.0.1@208'
-
-      input :pa_inquire_request_payload,
-            title: 'PAS Inquire Request Payload',
-            description: 'Insert Bundle to be sent for PAS Inquire Request',
-            type: 'textarea',
-            optional: true
-      input_order :server_endpoint, :smart_credentials
-      
-      makes_request :pa_inquire
-
-      def scratch_resources
-        scratch[:inquire_request_response_pair] ||= {}
-      end
-
-      def request_bundles
-        parsed_payload = JSON.parse(pa_inquire_request_payload)
-        [parsed_payload].flatten.compact.uniq
-      end
-
-      def perform_operation(request_payload)
-        
-        fhir_operation('/Claim/$inquire', body: request_payload, name: :pa_inquire)
-        
-        assert_response_status([200, 201])
-        assert_valid_json(request.response_body)
-
-        # Save request/response pair
-        scratch_resources[:all] ||= []
-        scratch_resources[:all] << {request_bundle: request.request_body, response_bundle: resource}
-        
-      end
-
-      run do
-        skip_if pa_inquire_request_payload.blank?, 'No bundle request provided to perform the inquire operation'
-        assert_valid_json(pa_inquire_request_payload)
-
-        request_bundles.each do |bundle|
-          perform_operation(bundle)
-        end
-      end
-    end
-  end
-end

data/lib/davinci_pas_test_kit/generated/v2.0.1/communication_request/server_submit_response_communication_request_must_support_test.rb

@@ -1,63 +0,0 @@
-require_relative '../../../must_support_test'
-require_relative '../../../generator/group_metadata'
-require_relative '../../../tags'
-
-module DaVinciPASTestKit
-  module DaVinciPASV201
-    class ServerSubmitResponseCommunicationRequestMustSupportTest < Inferno::Test
-      include DaVinciPASTestKit::MustSupportTest
-
-      title 'All must support elements for Profile PAS CommunicationRequest are observed across all instances returned'
-      description %(
-        
-        PAS server systems are required to be able to populate all
-        must support elements on instances of all profiles included in 
-        responses, including instances of the PAS CommunicationRequest Profile.
-        This test checks all identified instances of the PAS CommunicationRequest
-        Profile on responses returned by the server to ensure that the following
-        must support elements are observed:
-
-        * CommunicationRequest.category
-        * CommunicationRequest.identifier
-        * CommunicationRequest.medium
-        * CommunicationRequest.payload
-        * CommunicationRequest.payload.content[x]
-        * CommunicationRequest.payload.extension:communicatedDiagnosis
-        * CommunicationRequest.payload.extension:contentModifier
-        * CommunicationRequest.payload.extension:serviceLineNumber
-        * CommunicationRequest.recipient
-        * CommunicationRequest.requester
-        * CommunicationRequest.sender
-      )
-
-      id :pas_server_submit_response_v201_communication_request_must_support_test
-
-      def resource_type
-        'CommunicationRequest'
-      end
-
-      def user_input_validation
-        false
-      end
-
-      def self.metadata
-        @metadata ||= Generator::GroupMetadata.new(YAML.load_file(File.join(__dir__, 'metadata.yml'), aliases: true))
-      end
-
-      def scratch_resources
-        # The scratch key in MS test should be the same as the scratch key in the validation test for a given profile.
-        scratch[:submit_response_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(user_input_validation)
-      end
-    end
-  end
-end

data/lib/davinci_pas_test_kit/generated/v2.0.1/coverage/client_inquire_request_coverage_must_support_test.rb

@@ -1,60 +0,0 @@
-require_relative '../../../must_support_test'
-require_relative '../../../generator/group_metadata'
-require_relative '../../../tags'
-
-module DaVinciPASTestKit
-  module DaVinciPASV201
-    class ClientInquireRequestCoverageMustSupportTest < Inferno::Test
-      include DaVinciPASTestKit::MustSupportTest
-
-      title 'All must support elements for Profile PAS Coverage 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 Coverage Profile.
-        This test checks all identified instances of the PAS Coverage
-        Profile on requests sent by the client to ensure that the following
-        must support elements are observed: 
-
-        * Coverage.beneficiary
-        * Coverage.identifier
-        * Coverage.payor
-        * Coverage.relationship
-        * Coverage.relationship.coding:X12Code
-        * Coverage.status
-        * Coverage.subscriber
-        * Coverage.subscriberId
-      )
-
-      id :pas_client_inquire_request_v201_coverage_must_support_test
-
-      def resource_type
-        'Coverage'
-      end
-
-      def user_input_validation
-        false
-      end
-
-      def self.metadata
-        @metadata ||= Generator::GroupMetadata.new(YAML.load_file(File.join(__dir__, 'metadata.yml'), aliases: true))
-      end
-
-      def scratch_resources
-        # The scratch key in MS test should be the same as the scratch key in the validation test for a given profile.
-        scratch[:inquire_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(user_input_validation)
-      end
-    end
-  end
-end

data/lib/davinci_pas_test_kit/generated/v2.0.1/coverage/client_submit_request_coverage_must_support_test.rb

@@ -1,60 +0,0 @@
-require_relative '../../../must_support_test'
-require_relative '../../../generator/group_metadata'
-require_relative '../../../tags'
-
-module DaVinciPASTestKit
-  module DaVinciPASV201
-    class ClientSubmitRequestCoverageMustSupportTest < Inferno::Test
-      include DaVinciPASTestKit::MustSupportTest
-
-      title 'All must support elements for Profile PAS Coverage 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 Coverage Profile.
-        This test checks all identified instances of the PAS Coverage
-        Profile on requests sent by the client to ensure that the following
-        must support elements are observed: 
-
-        * Coverage.beneficiary
-        * Coverage.identifier
-        * Coverage.payor
-        * Coverage.relationship
-        * Coverage.relationship.coding:X12Code
-        * Coverage.status
-        * Coverage.subscriber
-        * Coverage.subscriberId
-      )
-
-      id :pas_client_submit_request_v201_coverage_must_support_test
-
-      def resource_type
-        'Coverage'
-      end
-
-      def user_input_validation
-        false
-      end
-
-      def self.metadata
-        @metadata ||= Generator::GroupMetadata.new(YAML.load_file(File.join(__dir__, 'metadata.yml'), aliases: true))
-      end
-
-      def scratch_resources
-        # The scratch key in MS test should be the same as the scratch key in the validation test for a given profile.
-        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(user_input_validation)
-      end
-    end
-  end
-end

data/lib/davinci_pas_test_kit/generated/v2.0.1/coverage/server_inquire_request_coverage_must_support_test.rb

@@ -1,62 +0,0 @@
-require_relative '../../../must_support_test'
-require_relative '../../../generator/group_metadata'
-require_relative '../../../tags'
-
-module DaVinciPASTestKit
-  module DaVinciPASV201
-    class ServerInquireRequestCoverageMustSupportTest < Inferno::Test
-      include DaVinciPASTestKit::MustSupportTest
-
-      title 'All must support elements for Profile PAS Coverage are observed across all instances submitted'
-      description %(
-        
-        **USER INPUT VALIDATION**: This test validates input provided by the user instead of the system under test. Errors encountered will be treated as a skip instead of a failure.
-
-        PAS server systems are required to be able to receive all
-        must support elements on instances of all profiles included in 
-        requests, including instances of the PAS Coverage Profile.
-        This test checks all identified instances of the PAS Coverage
-        Profile on requests sent to the server to ensure that the following
-        must support elements are observed:
-
-        * Coverage.beneficiary
-        * Coverage.identifier
-        * Coverage.payor
-        * Coverage.relationship
-        * Coverage.relationship.coding:X12Code
-        * Coverage.status
-        * Coverage.subscriber
-        * Coverage.subscriberId
-      )
-
-      id :pas_server_inquire_request_v201_coverage_must_support_test
-
-      def resource_type
-        'Coverage'
-      end
-
-      def user_input_validation
-        true
-      end
-
-      def self.metadata
-        @metadata ||= Generator::GroupMetadata.new(YAML.load_file(File.join(__dir__, 'metadata.yml'), aliases: true))
-      end
-
-      def scratch_resources
-        # The scratch key in MS test should be the same as the scratch key in the validation test for a given profile.
-        scratch[:inquire_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(user_input_validation)
-      end
-    end
-  end
-end