davinci_pas_test_kit 0.11.1 → 0.12.1

data/lib/davinci_pas_test_kit/generator/templates/operation.rb.erb

@@ -0,0 +1,62 @@
+module DaVinciPASTestKit
+  module <%= module_name %>
+    class <%= class_name %> < Inferno::Test
+
+      id :<%= test_id %>
+      title '<%= title %>'
+      description %(
+        <%=description.gsub("\n", "\n" + " "*8) %>
+      )
+
+      input :pa_<%= request_type %>_payload,
+            title: 'PAS <%= request_type.humanize.titleize%> Payload',
+            description: 'Insert Bundle to be sent for PAS <%= request_type.humanize.titleize%>',
+            type: 'textarea',
+            optional: true
+      input_order :server_endpoint, :smart_credentials
+      <% if operation == 'submit'%>output :response_time<% end %>
+      makes_request :pa_<%= operation %>
+
+      def scratch_resources
+        scratch[:<%= operation %>_request_response_pair] ||= {}
+      end
+
+      def request_bundles
+        parsed_payload = JSON.parse(pa_<%= request_type %>_payload)
+        [parsed_payload].flatten.compact.uniq
+      end
+
+      def perform_operation(request_payload)
+        <% if operation == 'submit'%>start_time = Time.now<% end %>
+        fhir_operation('/Claim/$<%= operation %>', body: request_payload, name: :pa_<%= operation %>)
+        <% if operation == '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
+        <% 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}
+        <% if operation == 'submit'%>output response_time:<% end %>
+      end
+
+      run do
+        skip_if pa_<%= request_type %>_payload.blank?, 'No bundle request provided to perform the <%= operation %> operation'
+        assert_valid_json(pa_<%= request_type %>_payload)
+
+        request_bundles.each do |bundle|
+          perform_operation(bundle)
+        end
+      end
+    end
+  end
+end

data/lib/davinci_pas_test_kit/generator/templates/resource_list.rb.erb

@@ -0,0 +1,13 @@
+module DaVinciPASTestKit
+    module <%= module_name %>
+      module ResourceList
+        RESOURCE_LIST = [
+    <%= resource_list_string.gsub("\n", "\n" + " "*4) %>
+        ].freeze
+
+        RESOURCE_SUPPORTED_PROFILES = {<% resource_supported_profiles.each do |resource, profile_list| %>
+          <%= resource %>: <%= profile_list %>,<% end %>
+        }.freeze
+      end
+    end
+end

data/lib/davinci_pas_test_kit/generator/templates/suite.rb.erb

@@ -0,0 +1,92 @@
+require 'subscriptions_test_kit'
+require_relative '../../validator_suppressions'
+require_relative '<%= error_group_file_name %>'
+<% group_file_list.each do |file_name| %>require_relative '<%= file_name %>'
+<% end %>
+module DaVinciPASTestKit
+  module <%= module_name %>
+    class <%= class_name %> < Inferno::TestSuite
+      id :<%= suite_id %>
+      title '<%= title %>'
+      description File.read(File.join(__dir__, '..', '..', 'docs', 'server_suite_description_<%= ig_metadata.reformatted_version %>.md'))
+
+      links [
+        {
+          label: 'Report Issue',
+          url: 'https://github.com/inferno-framework/davinci-pas-test-kit/issues/'
+        },
+        {
+          label: 'Open Source',
+          url: 'https://github.com/inferno-framework/davinci-pas-test-kit/'
+        },
+        {
+          label: 'Download',
+          url: 'https://github.com/inferno-framework/davinci-pas-test-kit/releases'
+        },
+        {
+          label: 'Implementation Guide',
+          url: '<%= ig_link %>'
+        }
+      ]
+
+      resume_test_route :get, '/resume_after_notification' do |request|
+        request.query_parameters['token']
+      end
+
+      fhir_resource_validator do
+        igs '<%= ig_identifier %>'
+
+        exclude_message do |message|
+          # Messages expected of the form `<ResourceType>: <FHIRPath>: <message>`
+          # We strip `<ResourceType>: <FHIRPath>: ` for the sake of matching
+          SUPPRESSED_MESSAGES.match?(message.message.sub(/\A\S+: \S+: /, '')) ||
+            message.message.downcase.include?('x12')
+        end
+      end
+
+      input :server_endpoint,
+            title: 'FHIR Server Endpoint URL',
+            description: 'Insert the FHIR server endpoint URL for PAS'
+
+      input :smart_credentials,
+            title: 'OAuth Credentials',
+            type: :auth_info,
+            options: {
+              mode: 'access',
+              components: [
+                {
+                  name: :auth_type,
+                  default: 'backend_services'
+                }
+              ]
+            },
+            optional: true
+
+      fhir_client do
+        url :server_endpoint
+        auth_info :smart_credentials
+      end
+
+      # Used for attestation experiment - see pas_claim_response_decision_test.rb
+      # resume_test_route :get, RESUME_PASS_PATH do |request|
+      #   request.query_parameters['token']
+      # end
+      #
+      # resume_test_route :get, RESUME_FAIL_PATH, result: 'fail' do |request|
+      #   request.query_parameters['token']
+      # end
+
+      group 'Demonstrate Workflow Support' do
+        description %(
+          The workflow tests validate that the server can participate in complete
+          end-to-end prior authorization interactions, returning responses that are
+          conformant and also contain the correct codes.
+        )
+        <% group_id_list.each do |id| %>
+        group from: :<%= id %><% end %>
+      end
+      group from: :<%= must_support_group_id %>
+      group from: :<%= error_group_id %>
+    end
+  end
+end

data/lib/davinci_pas_test_kit/generator/templates/validation.rb.erb

@@ -0,0 +1,98 @@
+require_relative '../../../pas_bundle_validation'
+
+module DaVinciPASTestKit
+  module <%= module_name %>
+    class <%= class_name %> < Inferno::Test
+      include DaVinciPASTestKit::PasBundleValidation
+
+      id :<%= test_id %>
+      title '<%= title %>'
+      description %(
+        <%=description.strip.gsub("\n", "\n" + " "*8) %>
+      )
+      <% if request_type.include?('request') %>
+      input :pa_<%= request_type %>_payload,
+            title: 'PAS <%= request_type.humanize.titleize%> Payload',
+            description: 'Insert Bundle to be sent for PAS <%= request_type.humanize.titleize%>',
+            type: 'textarea',
+            optional: true
+
+      input_order :server_endpoint, :smart_credentials<% end %>
+      output :dar_code_found, :dar_extension_found
+
+      def resource_type
+        '<%= resource_type %>'
+      end
+
+      def scratch_resources
+        scratch[:<%= request_type %>_resources] ||= {}
+      end
+
+      def request_type
+        '<%= request_type.split('_').first %>'
+      end
+      <%if request_type.include?('response')%>
+      def target_request_response_pairs<% operation = request_type.split('_').first %>
+        scratch[:<%= operation %>_request_response_pair] ||= {}
+        scratch[:<%= operation %>_request_response_pair][:all] ||= []
+      end<% end %>
+
+      <%if request_type.include?('request')%>
+      def request_bundles
+        parsed_payload = JSON.parse(pa_<%= request_type %>_payload)
+        fhir_resources = [parsed_payload].flatten.compact.uniq.map { |payload| FHIR.from_contents(payload.to_json)}.compact
+        fhir_resources.select { |res| res.resourceType == 'Bundle'}
+      end<% end %>
+
+      run do<% if request_type.include?('request') %>
+        skip_if pa_<%= request_type %>_payload.blank?, 'No bundle request input provided.'
+        assert_valid_json(pa_<%= request_type %>_payload)
+        assert request_bundles.present?, 'Provided input is not a bundle or list of bundles'
+
+        save_bundles_and_entries_to_scratch(request_bundles)
+
+        request_bundles.each do |bundle|
+          perform_request_validation(
+            bundle,
+            '<%= profile_url %>',
+            '<%= profile_version %>',
+            request_type
+          )
+        end
+
+        validation_error_messages.each do |msg|
+          messages << { type: 'error', message: msg }
+        end
+        msg = 'Bundle(s) provided and/or entry resources are not conformant. Check messages for issues found.'
+        skip_if validation_error_messages.present?, msg
+      <% else %>
+        skip_if target_request_response_pairs.blank?, 'No <%= request_type.split('_').first%> response to validate. Either no <%= request_type.split('_').first%> request was made in a previous test or it resulted in a server error.'
+        target_pairs = target_request_response_pairs
+        # Clean request/response pair after validatation
+        scratch[:<%= operation %>_request_response_pair][:all] = []
+
+        response_bundles = target_pairs.map { |pair| pair[:response_bundle] }
+        save_bundles_and_entries_to_scratch(response_bundles)
+
+        target_pairs.each do |pair|
+          pair => {request_bundle:, response_bundle:}
+          assert_resource_type(:bundle, resource: response_bundle)
+
+          perform_response_validation(
+            response_bundle,
+            '<%= profile_url %>',
+            '<%= profile_version %>',
+            request_type,
+            request_bundle
+          )
+        end
+
+        validation_error_messages.each do |msg|
+          messages << { type: 'error', message: msg }
+        end
+        msg = 'Bundle response returned and/or entry resources are not conformant. Check messages for issues found.'
+        assert validation_error_messages.blank?, msg<% end %>
+      end
+    end
+  end
+end

data/lib/davinci_pas_test_kit/generator/validation_test_generator.rb

@@ -6,42 +6,23 @@ module DaVinciPASTestKit
     class ValidationTestGenerator
       class << self
         def generate(ig_metadata, base_output_dir)
-          ['server', 'client'].each do |system|
-            if system == 'server'
-              ig_metadata.bundle_groups.each do |group|
-                new(group, system, base_output_dir:).generate
-              end
-            else
-              ig_metadata.bundle_groups.each do |group|
-                case group.profile_name
-                when 'PAS Request Bundle'
-                  new(group, system, base_output_dir:).generate
-                when 'PAS Inquiry Request Bundle'
-                  new(group, system, 'pended_inquiry', base_output_dir:).generate
-                when 'PAS Response Bundle'
-                  ['denial', 'pended'].each do |workflow|
-                    new(group, system, workflow, base_output_dir:).generate
-                  end
-                end
-              end
-            end
+          ig_metadata.bundle_groups.each do |group|
+            new(group, base_output_dir:).generate
           end
         end
       end
 
-      attr_accessor :group_metadata, :medication_request_metadata, :base_output_dir, :system, :workflow
+      attr_accessor :group_metadata, :medication_request_metadata, :base_output_dir, :workflow
 
-      def initialize(group_metadata, system, workflow = nil, medication_request_metadata = nil, base_output_dir:)
+      def initialize(group_metadata, workflow = nil, medication_request_metadata = nil, base_output_dir:)
         self.group_metadata = group_metadata
-        self.system = system
         self.workflow = workflow
         self.medication_request_metadata = medication_request_metadata
         self.base_output_dir = base_output_dir
       end
 
       def template
-        temp = system == 'server' ? 'validation.rb.erb' : 'validation_client.rb.erb'
-        @template ||= File.read(File.join(__dir__, 'templates', temp))
+        @template ||= File.read(File.join(__dir__, 'templates', 'validation.rb.erb'))
       end
 
       def output
@@ -61,8 +42,6 @@ module DaVinciPASTestKit
       end
 
       def directory_name
-        return 'client_tests' if system == 'client'
-
         Naming.snake_case_for_profile(medication_request_metadata || group_metadata)
       end
 
@@ -87,12 +66,12 @@ module DaVinciPASTestKit
       end
 
       def test_id
-        pref = "pas_#{system}_#{group_metadata.reformatted_version}_#{formatted_workflow}".delete_suffix('_')
+        pref = "pas_server_#{group_metadata.reformatted_version}_#{formatted_workflow}".delete_suffix('_')
         "#{pref}_#{profile_identifier}_validation_test"
       end
 
       def class_name
-        pref = "#{system.capitalize}#{formatted_workflow.camelize}"
+        pref = "Server#{formatted_workflow.camelize}"
         "#{pref}#{Naming.upper_camel_case_for_profile(group_metadata)}ValidationTest"
       end
 
@@ -135,14 +114,23 @@ module DaVinciPASTestKit
       end
 
       def user_input?
-        (system == 'server' && request_type.include?('request')) ||
-          (system == 'client' && request_type.include?('response'))
+        request_type.include?('request')
       end
 
       def description
         <<~DESCRIPTION
           #{description_user_input_validation if user_input?}
-          #{system == 'server' ? description_intro_server : description_intro_client}
+
+          This test validates the conformity of the
+          #{request_type.include?('request') ? 'user input' : "server's response"} to the
+          [#{profile_name}](#{profile_url})#{' '}
+          structure#{request_type.include?('request') ? ', ensuring subsequent tests can accurately simulate content.' : '.'}
+
+          It also checks that other conformance requirements defined in the [PAS Formal
+          Specification](https://hl7.org/fhir/us/davinci-pas/STU2/specification.html),
+          such as the presence of all referenced instances within the bundle and the
+          conformance of those instances to the appropriate profiles, are met.
+
           It verifies the presence of mandatory elements and that elements with
           required bindings contain appropriate values. CodeableConcept element
           bindings will fail if none of their codings have a code/system belonging
@@ -162,31 +150,6 @@ module DaVinciPASTestKit
         DESCRIPTION
       end
 
-      def description_intro_server
-        <<~GENERIC_INTRO
-          This test validates the conformity of the
-          #{request_type.include?('request') ? 'user input' : "server's response"} to the
-          [#{profile_name}](#{profile_url}) structure#{request_type.include?('request') ? ', ensuring subsequent tests can accurately simulate content.' : '.'}
-
-          It also checks that other conformance requirements defined in the [PAS Formal
-          Specification](https://hl7.org/fhir/us/davinci-pas/STU2/specification.html),
-          such as the presence of all referenced instances within the bundle and the
-          conformance of those instances to the appropriate profiles, are met.
-        GENERIC_INTRO
-      end
-
-      def description_intro_client
-        <<~GENERIC_INTRO
-          This test validates the conformity of the
-          #{request_type.include?('response') ? 'user input' : "client's request"} to the
-          [#{profile_name}](#{profile_url}) structure.
-          It also checks that other conformance requirements defined in the [PAS Formal
-          Specification](https://hl7.org/fhir/us/davinci-pas/STU2/specification.html),
-          such as the presence of all referenced instances within the bundle and the
-          conformance of those instances to the appropriate profiles, are met.
-        GENERIC_INTRO
-      end
-
       def description_user_input_validation
         <<~USER_INPUT_INTRO
           **USER INPUT VALIDATION**: This test validates input provided by the user instead of the system under test.

data/lib/davinci_pas_test_kit/generator/value_extractor.rb

@@ -17,7 +17,10 @@ module DaVinciPASTestKit
       end
 
       def bound_systems(the_element)
-        value_set(the_element)&.compose&.include&.reject { |code| code.concept.nil? }
+        vs = value_set(the_element)
+        return unless vs.present?
+
+        vs.compose&.include&.reject { |code| code.concept.nil? }
       end
 
       def values_from_value_set_binding(the_element)

data/lib/davinci_pas_test_kit/generator.rb

@@ -38,7 +38,7 @@ module DaVinciPASTestKit
     end
 
     def load_ig_package
-      FHIR.logger = Logger.new('/dev/null')
+      FHIR.logger = Logger.new(File::NULL)
       self.ig_resources = IGLoader.new(ig_file_name).load
     end
 

data/lib/davinci_pas_test_kit/jobs/send_pas_subscription_notification.rb

@@ -0,0 +1,136 @@
+# frozen_string_literal: true
+
+require_relative '../tags'
+require_relative '../urls'
+require 'subscriptions_test_kit'
+
+module DaVinciPASTestKit
+  module Jobs
+    class SendPASSubscriptionNotification
+      include Sidekiq::Job
+      include SubscriptionsTestKit::SubscriptionsR5BackportR4Client::SubscriptionSimulationUtils
+      include URLs
+
+      # override the one from URLs
+      def suite_id
+        @notification_suite_id
+      end
+
+      sidekiq_options retry: false
+
+      def perform(test_run_id, test_session_id, result_id, notification_bearer_token, notification_json, resume_token,
+                  notification_suite_id)
+        @test_run_id = test_run_id
+        @test_session_id = test_session_id
+        @result_id = result_id
+        @notification_bearer_token = notification_bearer_token
+        @notification_json = notification_json
+        @resume_token = resume_token
+        @notification_suite_id = notification_suite_id
+
+        await_subscription_creation # NOTE: currently must exist - see PASClientPendedSubmitTest
+        sleep 1
+        return unless test_still_waiting?
+
+        sleep rand(5..10)
+        return unless test_still_waiting?
+
+        send_event_notification
+      end
+
+      def requests_repo
+        @requests_repo ||= Inferno::Repositories::Requests.new
+      end
+
+      def results_repo
+        @results_repo ||= Inferno::Repositories::Results.new
+      end
+
+      def subscription
+        @subscription ||= find_subscription(@test_session_id)
+      end
+
+      def subscription_notification_endpoint
+        subscription&.channel&.endpoint
+      end
+
+      def headers
+        @headers ||= subscription_headers.merge(content_type_header).merge(authorization_header)
+      end
+
+      def rest_hook_connection
+        @rest_hook_connection ||= Faraday.new(url: subscription_notification_endpoint, request: { open_timeout: 30 },
+                                              headers:)
+      end
+
+      def test_suite_connection
+        @test_suite_connection ||= Faraday.new(base_url)
+      end
+
+      def content_type_header
+        @content_type_header ||= { 'Content-Type' => actual_mime_type(subscription) }
+      end
+
+      def subscription_headers
+        @subscription_headers ||= subscription.channel&.header&.each_with_object({}) do |header, hash|
+          header_name, header_value = header.split(': ', 2)
+          hash[header_name] = header_value
+        end || {}
+      end
+
+      def authorization_header
+        @authorization_header ||=
+          @notification_bearer_token.present? ? { 'Authorization' => "Bearer #{@notification_bearer_token}" } : {}
+      end
+
+      def subscription_topic
+        @subscription_topic ||= subscription&.criteria
+      end
+
+      def subscription_full_url
+        @subscription_full_url ||= "#{fhir_subscription_url}/#{subscription.id}"
+      end
+
+      def test_still_waiting?
+        results_repo.find_waiting_result(test_run_id: @test_run_id)
+      end
+
+      def await_subscription_creation
+        sleep 0.5 until subscription.present? || !test_still_waiting?
+      end
+
+      def send_event_notification
+        event_json = derive_event_notification(@notification_json, subscription_full_url, subscription_topic, 1).to_json
+        response = send_notification(event_json)
+        persist_notification_request(response, [REST_HOOK_EVENT_NOTIFICATION_TAG])
+      end
+
+      def send_notification(request_body)
+        rest_hook_connection.post('', request_body)
+      rescue Faraday::Error => e
+        # Warning: This is a hack. If there is an error with the request such that we never get a response, we have
+        #          no clean way to persist that information for the Inferno test to check later. The solution here
+        #          is to persist the request anyway with a status of nil, using the error message as response body
+        Faraday::Response.new(response_body: e.message, url: rest_hook_connection.url_prefix.to_s)
+      end
+
+      def persist_notification_request(response, tags)
+        inferno_request_headers = headers.map { |name, value| { name:, value: } }
+        inferno_response_headers = response.headers&.map { |name, value| { name:, value: } }
+        requests_repo.create(
+          verb: 'POST',
+          url: response.env.url.to_s,
+          direction: 'outgoing',
+          status: response.status,
+          request_body: response.env.request_body,
+          response_body: response.env.response_body,
+          test_session_id: @test_session_id,
+          result_id: @result_id,
+          request_headers: inferno_request_headers,
+          response_headers: inferno_response_headers,
+          tags:
+        )
+      end
+    end
+  end
+end