davinci_pas_test_kit 0.15.2 → 0.16.0

data/lib/davinci_pas_test_kit/client/request_count_gating.rb

@@ -0,0 +1,14 @@
+module DaVinciPASTestKit
+  # Shared predicates for the no_requests_ok/multiple_requests_ok config options, used to gate
+  # on how many tagged requests were found by AbstractResponseAttest's run block and by
+  # ClientBundleValidationHelper#check_request_count.
+  module RequestCountGating
+    def no_requests_ok?
+      config.options[:no_requests_ok]
+    end
+
+    def multiple_requests_ok?
+      config.options[:multiple_requests_ok]
+    end
+  end
+end

data/lib/davinci_pas_test_kit/client/response_generator.rb

@@ -4,6 +4,11 @@ module DaVinciPASTestKit
   module ResponseGenerator
     include ParametersHelper
 
+    # Extensions on elements of the request Claim that Inferno copies into the ClaimResponse it generates
+    # are kept only if they are published by HL7 (e.g., the PAS identifier extensions), since Inferno,
+    # acting as the payer, doesn't send custom extensions - see NO_CUSTOM_EXTENSIONS_VALIDATOR.
+    HL7_EXTENSION_URL_PREFIX = 'http://hl7.org/fhir/'.freeze
+
     def mock_id_only_notification_bundle(submit_response, subscription_reference, subscription_topic,
                                          ig_version = 'v2.0.1')
       notification_timestamp = Time.now.utc
@@ -240,14 +245,14 @@ module DaVinciPASTestKit
                                       else
                                         "http://hl7.org/fhir/us/davinci-pas/StructureDefinition/profile-claiminquiryresponse|#{ig_version.delete('v')}"
                                       end),
-        identifier: claim.identifier,
-        type: claim.type,
+        identifier: copy_without_custom_extensions(claim.identifier),
+        type: copy_without_custom_extensions(claim.type),
         status: claim.status,
         use: claim.use,
-        patient: absolute_reference(claim.patient, request_bundle.entry, root_url),
+        patient: copy_without_custom_extensions(absolute_reference(claim.patient, request_bundle.entry, root_url)),
         created: timestamp.iso8601,
-        insurer: absolute_reference(claim.insurer, request_bundle.entry, root_url),
-        requestor: absolute_reference(claim.provider, request_bundle.entry, root_url),
+        insurer: copy_without_custom_extensions(absolute_reference(claim.insurer, request_bundle.entry, root_url)),
+        requestor: copy_without_custom_extensions(absolute_reference(claim.provider, request_bundle.entry, root_url)),
         request: claim_full_url.present? ? FHIR::Reference.new(reference: claim_full_url) : nil,
         # v2.2.1 removed 'queued' from ClaimResponseOutcome ValueSet; pended status is
         # conveyed via item.extension:reviewActionCode instead.
@@ -303,13 +308,41 @@ module DaVinciPASTestKit
       claim_response
     end
 
+    # @param element [FHIR::Model, Array<FHIR::Model>, nil] an element of the request Claim.
+    # @return a copy of the element without extensions (at any depth) that aren't published by HL7.
+    def copy_without_custom_extensions(element)
+      return element.map { |child| copy_without_custom_extensions(child) } if element.is_a?(Array)
+      return element if element.nil?
+
+      element.class.new(without_custom_extensions(element.to_hash))
+    end
+
+    # Kept extensions are left whole, since complex extensions' sub-extensions use relative urls.
+    def without_custom_extensions(value)
+      case value
+      when Hash
+        value.each_with_object({}) do |(key, child), result|
+          if %w[extension modifierExtension].include?(key)
+            kept = child.select { |extension| extension['url'].to_s.start_with?(HL7_EXTENSION_URL_PREFIX) }
+            result[key] = kept if kept.present?
+          else
+            result[key] = without_custom_extensions(child)
+          end
+        end
+      when Array
+        value.map { |child| without_custom_extensions(child) }
+      else
+        value
+      end
+    end
+
     # Pairs each modified item (already marked A6 above) with a ClaimResponse.addItem, referenced by
     # the same itemSequence, conveying what the payer authorized (marked A1, 'Certified in total').
     def add_modified_items(claim_response, claim)
       claim_response.addItem = claim.item.map do |item|
         FHIR::ClaimResponse::AddItem.new(
           itemSequence: [item.sequence],
-          productOrService: item.productOrService,
+          productOrService: copy_without_custom_extensions(item.productOrService),
           adjudication: [
             FHIR::ClaimResponse::Item::Adjudication.new(
               extension: [
@@ -466,6 +499,8 @@ module DaVinciPASTestKit
         if attr.to_s == 'request' && resource.respond_to?(:resourceType) && resource.resourceType == 'ClaimResponse'
           next
         end
+        # JSON keys without a matching attribute, e.g., the `_gender` holding a primitive's extensions
+        next unless resource.respond_to?(attr.to_sym)
 
         value = resource.send(attr.to_sym)
         if value.is_a?(FHIR::Reference) && value.reference.present?
@@ -502,10 +537,16 @@ module DaVinciPASTestKit
       url.sub(%r{/[^/]*/[^/]*(/)?\z}, '')
     end
 
-    def claim_response_full_url_from_submit_response_bundle(submit_response_bundle)
-      submit_response_bundle = submit_response_bundle.parameter[0] if submit_response_bundle.is_a?(FHIR::Parameters)
+    # Finds the Bundle.entry for the ClaimResponse in a $submit response, which may be wrapped in a
+    # FHIR::Parameters resource (v2.2.1). Returns nil if there is no response bundle or no such entry.
+    def claim_response_entry_from_response_bundle(response_bundle)
+      response_bundle = response_bundle.parameter[0]&.resource if response_bundle.is_a?(FHIR::Parameters)
 
-      claim_response_entry = submit_response_bundle&.entry&.find { |e| e&.resource&.resourceType == 'ClaimResponse' }
+      response_bundle&.entry&.find { |e| e&.resource&.resourceType == 'ClaimResponse' }
+    end
+
+    def claim_response_full_url_from_submit_response_bundle(submit_response_bundle)
+      claim_response_entry = claim_response_entry_from_response_bundle(submit_response_bundle)
 
       if claim_response_entry.present?
         return claim_response_entry.fullUrl unless claim_response_entry.fullUrl.blank?

data/lib/davinci_pas_test_kit/client/session_identification.rb

@@ -1,7 +1,14 @@
 require 'udap_security_test_kit'
+require_relative 'pas_client_options'
 
 module DaVinciPASTestKit
   module SessionIdentification
+    # Wait identifiers:
+    # - A wait during which the client sends requests to Inferno (including waits that also offer a
+    #   "click here when done" link) must use session_wait_identifier, since Inferno's endpoints find
+    #   the waiting test from the client id or session URL path on the request.
+    # - A wait that only the tester (e.g., an attestation) or an Inferno job continues must use a fresh
+    #   SecureRandom.uuid, so that a stale link from an earlier wait in the session can't resume it.
     def session_wait_identifier(client_id, session_url_path)
       # look at test config and determine the wait identifier to use
       # at somepoint this would be an inferno type, for now, just two options
@@ -31,14 +38,26 @@ module DaVinciPASTestKit
       end
     end
 
-    # interpret the bearer token structure to determine the wait identifer
-    # - if structured like a token returned by the simulated Auth server, return the client URI
-    # - otherwise, use the raw token (provided token)
-    def bearer_token_to_wait_identifier(token)
-      client_id = UDAPSecurityTestKit::MockUDAPServer.issued_token_to_client_id(token)
-      return client_id if client_id.present?
+    def auth_description_for_wait(client_id)
+      case suite_options[:client_type]
+      when PASClientOptions::OTHER_AUTH
+        'No authentication with Inferno is required. Requests will be associated ' \
+        'with this session based on the endpoint alone.'
+      when PASClientOptions::SMART_BACKEND_SERVICES_CONFIDENTIAL_ASYMMETRIC
+        authenticated_auth_description_for_wait(client_id, 'SMART Backend Services')
+      when PASClientOptions::UDAP_CLIENT_CREDENTIALS
+        authenticated_auth_description_for_wait(client_id, 'UDAP B2B Client Credentials')
+      end
+    end
 
-      token
+    def authenticated_auth_description_for_wait(client_id, type)
+      "Requests must be authenticated by first obtaining a #{type} " \
+        'access token using' \
+        "\n\n- Token endpoint: `#{token_url}`" \
+        "\n- Client Id: `#{client_id}`\n\n" \
+        'Only requests that include an obtained access token as a bearer token ' \
+        'in the Authorization header of the HTTP request will be recognized as ' \
+        'associated with this session and return successful responses.'
     end
   end
 end

data/lib/davinci_pas_test_kit/client/subscription_notification_trigger.rb

@@ -0,0 +1,80 @@
+require_relative 'response_generator'
+require_relative 'jobs/send_pas_subscription_notification'
+
+module DaVinciPASTestKit
+  # Starts the job that sends a Subscription notification to the client after a pended $submit response.
+  # The notification is the tester-provided one (updated to be current) when there is one, or a mocked
+  # notification based on the response and the client's Subscription otherwise.
+  #
+  # The module does not know how to reach the tester's inputs or the requests made earlier in the session,
+  # because that differs between the classes that use it (suite endpoints and Inferno tests). Including
+  # classes provide them through the helper methods below, which raise NotImplementedError here.
+  #
+  # Helper methods the including class must provide:
+  # - notification_test_run_id, notification_test_session_id, notification_result_id: identify the test run,
+  #   session and the waiting result that the job checks on and records the notification request on. The test
+  #   run and result ids may be nil when the including class cannot know them yet (an Inferno test that has
+  #   not started waiting), in which case the job looks them up.
+  # - notification_bearer_token: the access token to send with the notification, from the tester's inputs
+  # - tester_notification_bundle: the tester-provided notification Bundle JSON, or nil
+  # - client_subscription_json: the Subscription the client created, as parsed JSON (so that primitive
+  #   extensions are kept), from the earlier successful Subscription create request. nil if there is none.
+  # - test_run_identifier: the token that identifies the waiting test to resume
+  # - suite_id and ig_version: the suite that the job should send the notification for, and its IG version
+  # - fhir_subscription_url: the base URL of the Subscription endpoint (provided by ClientURLs)
+  module SubscriptionNotificationTrigger
+    include ResponseGenerator
+
+    HELPERS = %i[notification_test_run_id notification_test_session_id notification_result_id
+                 notification_bearer_token tester_notification_bundle client_subscription_json].freeze
+    HELPERS.each do |helper|
+      define_method(helper) do
+        raise NotImplementedError, "#{self.class} must implement ##{helper} to use SubscriptionNotificationTrigger"
+      end
+    end
+
+    # With resume_test true, the job ends the wait identified by test_run_identifier once it has sent the
+    # notification, for use by an Inferno test that waits for the notification to be sent.
+    def start_notification_job(response_bundle_json, decision, generated_claim_response_uuid, resume_test: false)
+      notification_contents = notification_json(response_bundle_json, decision, generated_claim_response_uuid)
+
+      Inferno::Jobs.perform(Jobs::SendPASSubscriptionNotification, notification_test_run_id,
+                            notification_test_session_id, notification_result_id, notification_bearer_token,
+                            notification_contents, test_run_identifier, suite_id, ig_version, resume_test)
+    end
+
+    private
+
+    def notification_json(response_bundle_json, decision, generated_claim_response_uuid)
+      user_inputted_notification_json = tester_notification_bundle
+
+      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 = client_subscription_json
+      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, ig_version)
+      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,
+                                         ig_version)
+      end
+    end
+
+    def find_subscription_content_type(subscription)
+      content_ext = subscription.dig('channel', '_payload', 'extension')
+        &.find do |ext|
+          ext['url'] == 'http://hl7.org/fhir/uv/subscriptions-backport/StructureDefinition/backport-payload-content'
+        end
+      content_ext&.dig('valueCode')
+    end
+  end
+end

data/lib/davinci_pas_test_kit/client/subscription_setup_requirement.rb

@@ -0,0 +1,59 @@
+module DaVinciPASTestKit
+  # Shared guard for client tests that need the client's Subscription Setup to have completed
+  # before they can proceed - either because they need the created Subscription itself (e.g. to
+  # generate a notification against it, or to update or delete it) or just need to know one exists
+  # before continuing with the pended scenario.
+  module SubscriptionSetupRequirement
+    PENDED_SCENARIO_SKIP_MESSAGE = %(
+      This test cannot proceed because no Subscription exists to receive notifications
+      for pended claims. Run the _Subscription Setup_ tests to provide a Subscription
+      for use in delivering notifications before re-running the pended scenario tests.
+    ).freeze
+
+    PENDED_SCENARIO_MODIFIED_SUBSCRIPTION_SKIP_MESSAGE = %(
+      This test cannot proceed because the PAS client submitted update or delete requests for its
+      Subscription during the _Subscription Update and Deletion_ tests. Re-run the _Subscription Setup_
+      tests to create a new Subscription for use in delivering notifications before re-running the
+      pended scenario tests.
+    ).freeze
+
+    UPDATE_DELETE_SKIP_MESSAGE = %(
+      This test cannot proceed because no Subscription exists to update or delete. Run the
+      _Subscription Setup_ tests to create a Subscription before re-running this test.
+    ).freeze
+
+    # Skips the test unless a successful (201) Subscription-create request was made during this
+    # session.
+    # @param skip_message [String] explanation shown when the test is skipped.
+    # @return [Hash] the created Subscription as returned to the client, parsed from the response body.
+    def require_created_subscription(skip_message: PENDED_SCENARIO_SKIP_MESSAGE)
+      subscription_request = load_tagged_requests(SUBSCRIPTION_CREATE_TAG).find { |req| req.status == 201 }
+      skip_if subscription_request.blank?, skip_message
+      JSON.parse(subscription_request.response_body)
+    end
+
+    # Like require_created_subscription, but also skips if the client has successfully updated or
+    # deleted the created Subscription. Notifications are generated from the Subscription as created,
+    # so the pended scenario must not run against one the client has since changed or removed.
+    # Rejected update and delete requests leave the Subscription unchanged and so are ignored.
+    # @return [Hash] the created Subscription as returned to the client, parsed from the response body.
+    def require_unmodified_subscription
+      subscription = require_created_subscription
+      # Only update and delete requests are tagged with the Subscription id, which is new for each create
+      skip_if load_tagged_requests(subscription['id']).any? { |req| subscription_change_succeeded?(req) },
+              PENDED_SCENARIO_MODIFIED_SUBSCRIPTION_SKIP_MESSAGE
+      subscription
+    end
+
+    private
+
+    # Successful updates respond with 200 and successful deletes with a 2xx status
+    def subscription_change_succeeded?(request)
+      if request.tags.include?(SUBSCRIPTION_DELETE_TAG)
+        request.status.between?(200, 299)
+      else
+        request.status == 200
+      end
+    end
+  end
+end

data/lib/davinci_pas_test_kit/client/user_input_response.rb

@@ -1,3 +1,5 @@
+require_relative '../cross_suite/response_selection_utils'
+
 module DaVinciPASTestKit
   module UserInputResponse
     # Raised when a tester-provided response input is present but cannot be used. The
@@ -25,9 +27,9 @@ module DaVinciPASTestKit
 
     # Returns the tester-provided response candidates for the must support workflow
     # as a list of parsed JSON hashes. The input value may be a single entry or a
-    # JSON array of entries, where each entry is either a bare FHIR Bundle or a
-    # wrapper object holding the response Bundle under "bundle" alongside optional
-    # selection "criteria".
+    # JSON array of entries, where each entry is either a bare FHIR Bundle or Parameters
+    # or a wrapper object holding the response resource under "bundle" alongside optional
+    # selection "criteria" - see ResponseSelectionUtils.
     # Returns nil if the input has no value and raises InvalidInputError if the value
     # is present but unusable. The configurable (the waiting test) supplies the input
     # title so that the error names the input as the tester sees it.
@@ -41,8 +43,8 @@ module DaVinciPASTestKit
       invalid_index = candidates.index { |candidate| !valid_candidate?(candidate) }
       if invalid_index.present?
         raise InvalidInputError,
-              "Entry #{invalid_index + 1} of the '#{input_title(configurable, input_name)}' input is neither " \
-              'a FHIR Bundle nor a wrapper object with a FHIR Bundle in the "bundle" key.'
+              "Entry #{invalid_index + 1} of the '#{input_title(configurable, input_name)}' input is not " \
+              'a FHIR Bundle or Parameters resource, or a wrapper object with one in the "bundle" key.'
       end
 
       candidates
@@ -59,7 +61,8 @@ module DaVinciPASTestKit
     def self.valid_candidate?(candidate)
       return false unless candidate.is_a?(Hash)
 
-      candidate['resourceType'] == 'Bundle' || candidate['bundle'].is_a?(Hash)
+      ResponseSelectionUtils::RESPONSE_RESOURCE_TYPES.include?(candidate['resourceType']) ||
+        candidate[ResponseSelectionUtils::BUNDLE_KEY].is_a?(Hash)
     end
 
     def user_inputted_response?(input_key)
@@ -70,6 +73,24 @@ module DaVinciPASTestKit
       UserInputResponse.input_title(self, input_key)
     end
 
+    def response_description_for_wait(user_input, user_input_title, operation)
+      if user_input
+        <<~DESCRIPTION.strip
+          Inferno will respond to `#{operation}` requests with the content provided in the
+          '**#{user_input_title}**' input, with `{{...}}` fhirpath expressions replaced with
+          their value when evaluated against the request and timestamps and resources references
+          updated to be current and consistent. See the ["Response Instantiation" section](https://github.com/inferno-framework/davinci-pas-test-kit/wiki/Controlling-Simulated-Responses#response-instantiation)
+          of the Da Vinci PAS Test Kit wiki for details on these updates.
+        DESCRIPTION
+      else
+        <<~DESCRIPTION.strip
+          Inferno will respond to `#{operation}` requests with a mocked response based on the request.
+          See the ["Mocked Responses" section](https://github.com/inferno-framework/davinci-pas-test-kit/wiki/Controlling-Simulated-Responses#mocked-responses)
+          of the Da Vinci PAS Test Kit wiki for details on the mocked response.
+        DESCRIPTION
+      end
+    end
+
     module ClassMethods
       def submit_respond_with(key)
         config options: { submit_respond_with: key }

data/lib/davinci_pas_test_kit/client/v2.0.1/client_suite.rb

@@ -1,11 +1,13 @@
 require 'subscriptions_test_kit'
 require 'udap_security_test_kit'
 require 'smart_app_launch_test_kit'
+require_relative '../../cross_suite/validator_configuration'
 require_relative '../../cross_suite/validator_suppressions'
 require_relative '../../cross_suite/tags'
 require_relative '../endpoints/claim_endpoint'
 require_relative '../endpoints/token_endpoint'
 require_relative '../endpoints/subscription_create_endpoint'
+require_relative '../endpoints/subscription_read_endpoint'
 require_relative '../endpoints/subscription_status_endpoint'
 require_relative '../pas_client_options'
 require_relative 'pas_client_workflows_group'
@@ -22,33 +24,33 @@ module DaVinciPASTestKit
       id :davinci_pas_client_suite_v201
       title 'Da Vinci PAS Client Suite v2.0.1'
       description %(
-        The Da Vinci PAS Test Kit Client Suite validates the conformance of client
-        systems to the STU 2 version of the HL7® FHIR®
+        The Da Vinci PAS Test Kit Client Suite validates the conformance of PAS clients
+        to the STU 2 version of the HL7® FHIR®
         [Da Vinci Prior Authorization Support Implementation Guide](https://hl7.org/fhir/us/davinci-pas/STU2/).
 
         These tests are a **DRAFT** intended to allow PAS client implementers to perform
-        preliminary checks of their clients against PAS IG requirements and [provide
+        preliminary checks of their PAS clients against PAS IG requirements and [provide
         feedback](https://github.com/inferno-framework/davinci-pas-test-kit/issues)
         on the tests. Future versions of these tests may validate other
         requirements and may change the test validation logic.
 
         The best place to get started is the [Client Testing
         Walkthrough](https://github.com/inferno-framework/davinci-pas-test-kit/wiki/Client-Instructions-v2.0.1),
-        which provides a step-by-step guide for running the tests against a client and provides
+        which provides a step-by-step guide for running the tests against a PAS client and provides
         an example client implemented in Postman.  Visit the [Client Testing
         Details](https://github.com/inferno-framework/davinci-pas-test-kit/wiki/Client-Details)
         documentation for information about technical implementation and known limitations of these tests.
 
-        In this test suite, Inferno simulates a PAS server for the client under test to
-        interact with. The client will be expected to initiate requests to the server
+        In this test suite, Inferno simulates a PAS server for the PAS client to
+        interact with. The PAS client will be expected to initiate requests to the server
         and demonstrate its ability to react to the returned responses. Over the course
         of these interactions, Inferno will seek to observe conformant handling of PAS
         requirements, including:
-        - The ability of the client to initiate a prior authorization submission and react to
+        - The ability of the PAS client to initiate a prior authorization submission and react to
             - The approval of the request
             - The denial of the request
             - The pending of the request and a subsequent notification that a final decision was made
-        - The ability of the client to provide data covering the full scope of required by PAS, including
+        - The ability of the PAS client to provide data covering the full scope of required by PAS, including
             - The ability to send prior auth requests and inquiries with all PAS
               profiles and all must support elements on those profiles
             - The ability to handle responses that contain all PAS profiles and all must support elements on those
@@ -93,16 +95,29 @@ module DaVinciPASTestKit
       )
 
       fhir_resource_validator do
-        igs 'hl7.fhir.us.davinci-pas#2.0.1'
+        igs(*V201_VALIDATOR_IGS)
 
         exclude_message do |message|
-          # Messages expected of the form `<ResourceType>: <FHIRPath>: <message>`
-          # We strip `<ResourceType>: <FHIRPath>: ` for the sake of matching
-          V201_SUPPRESSED_MESSAGES.match?(message.message.sub(/\A\S+: \S+: /, ''))
+          V201_SUPPRESSED_MESSAGES.match?(message.message.sub(VALIDATOR_MESSAGE_LOCATION_PREFIX, ''))
         end
 
         validation_context do
-          snomedCT '731000124108'
+          snomedCT SNOMED_CT_US_EDITION
+        end
+      end
+
+      # Used to verify responses sent by Inferno, which may be tester-provided, to
+      # ensure they don't contain extensions not defined in the PAS IG or its dependencies.
+      fhir_resource_validator NO_CUSTOM_EXTENSIONS_VALIDATOR do
+        igs(*V201_VALIDATOR_IGS)
+
+        exclude_message do |message|
+          V201_SUPPRESSED_MESSAGES.match?(message.message.sub(VALIDATOR_MESSAGE_LOCATION_PREFIX, ''))
+        end
+
+        validation_context do
+          snomedCT SNOMED_CT_US_EDITION
+          extensions [] # no extensions not in the spec
         end
       end
 
@@ -140,8 +155,8 @@ module DaVinciPASTestKit
       suite_endpoint :post, SESSION_INQUIRE_PATH, ClaimEndpoint
       suite_endpoint :post, FHIR_SUBSCRIPTION_PATH, SubscriptionCreateEndpoint
       suite_endpoint :post, SESSION_FHIR_SUBSCRIPTION_PATH, SubscriptionCreateEndpoint
-      suite_endpoint :get, FHIR_SUBSCRIPTION_INSTANCE_PATH, SubscriptionsTestKit::SubscriptionReadEndpoint
-      suite_endpoint :get, SESSION_FHIR_SUBSCRIPTION_INSTANCE_PATH, SubscriptionsTestKit::SubscriptionReadEndpoint
+      suite_endpoint :get, FHIR_SUBSCRIPTION_INSTANCE_PATH, SubscriptionReadEndpoint
+      suite_endpoint :get, SESSION_FHIR_SUBSCRIPTION_INSTANCE_PATH, SubscriptionReadEndpoint
       suite_endpoint :post, FHIR_SUBSCRIPTION_INSTANCE_STATUS_PATH, SubscriptionStatusEndpoint
       suite_endpoint :post, SESSION_FHIR_SUBSCRIPTION_INSTANCE_STATUS_PATH, SubscriptionStatusEndpoint
       suite_endpoint :get, FHIR_SUBSCRIPTION_INSTANCE_STATUS_PATH, SubscriptionStatusEndpoint

data/lib/davinci_pas_test_kit/client/v2.0.1/must_support/pas_client_must_support_request_profiles_test.rb

@@ -18,7 +18,7 @@ module DaVinciPASTestKit
         * PAS Device Request
         * PAS Nutrition Order
 
-        System are allowed to support only the request profiles that fit their use cases. However,
+        PAS clients are allowed to support only the request profiles that fit their use cases. However,
         they must support at least one of them (because `Claim.item.extension:requestedService` is a
         must support element) and for any request profiles they support, they must be able to
         populate all of the defined must support elements.
@@ -27,7 +27,7 @@ module DaVinciPASTestKit
         profile listed above. Then for each profile observed, it checks for the presence of
         each must support element defined in that profile.
 
-        The test will look through the instances included in submissions made by the client
+        The test will look through the instances included in submissions made by the PAS client
         for the following must support elements:
 
         ### PAS Medication Request

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

@@ -8,10 +8,10 @@ module DaVinciPASTestKit
   module DaVinciPASV201
     class PASClientApprovalGroup < Inferno::TestGroup
       id :pas_client_v201_approval_group
-      title 'Approval Workflow'
+      title 'Approval Response'
       description %(
-        During these tests, the client will initiate a prior authorization
-        request and show it can respond appropriately to an 'approved' decision.
+        During these tests, the PAS client will initiate a prior authorization
+        request and show it can react appropriately to an 'approved' decision.
       )
       run_as_group
 
@@ -24,16 +24,17 @@ module DaVinciPASTestKit
       test from: :pas_client_v201_response_bundle_validation_test,
            config: { options: { workflow_tag: APPROVAL_WORKFLOW_TAG } }
       test from: :pas_client_v201_response_attest,
-           title: 'Check that the client registers the request as approved (Attestation)',
+           title: 'Check that the PAS client registers the request as approved',
            description: %(
-             This test provides the tester an opportunity to observe their client following
+             During this test, the tester will observe the PAS client following
              the receipt of the approved response and attest that users are able to determine
              that the response has been approved.
            ),
            config: { options: {
              workflow_tag: APPROVAL_WORKFLOW_TAG,
-             attest_message: "I attest that the client system displays the submitted claim as 'approved' meaning " \
-                             'that the user can proceed with ordering or providing the requested service.'
+             attest_message: 'I attest that the PAS client did not error when handling the `$submit` ' \
+                             "response and displays the submitted claim as 'approved' meaning that the " \
+                             'user can proceed with ordering or providing the requested service.'
            } }
     end
   end

data/lib/davinci_pas_test_kit/client/v2.0.1/pas_client_auth_smart_group.rb

@@ -7,13 +7,13 @@ module DaVinciPASTestKit
       id :pas_client_v201_auth_smart
       title 'Review Authentication Interactions'
       description %(
-        During these tests, Inferno will verify that the client interacted with Inferno's
+        During these tests, Inferno will verify that the PAS client interacted with Inferno's
         simulated SMART authorization server in a conformant manner when requesting access tokens
-        and that the client under test was able to use provided access tokens to make PAS
+        and that the PAS client was able to use provided access tokens to make PAS
         requests.
 
-        Before running these tests, execute the tests for at least one "PAS workflows" sub-group
-        so that the client will request an access token and use it on a PAS request.
+        Before running these tests, execute the tests for at least one "PAS Scenarios" sub-group
+        so that the PAS client will request an access token and use it on a PAS request.
       )
       run_as_group
 

data/lib/davinci_pas_test_kit/client/v2.0.1/pas_client_auth_udap_group.rb

@@ -7,13 +7,13 @@ module DaVinciPASTestKit
       id :pas_client_v201_auth_udap
       title 'Review UDAP Authentication Interactions'
       description %(
-        During these tests, Inferno will verify that the client interacted with Inferno's
+        During these tests, Inferno will verify that the PAS client interacted with Inferno's
         simulated UDAP authorization server in a conformant manner when requesting access tokens
-        and that the client under test was able to use provided access tokens to make PAS
+        and that the PAS client was able to use provided access tokens to make PAS
         requests.
 
-        Before running these tests, execute the tests for at least one "PAS workflows" sub-group
-        so that the client will request an access token and use it on a PAS request.
+        Before running these tests, execute the tests for at least one "PAS Scenarios" sub-group
+        so that the PAS client will request an access token and use it on a PAS request.
       )
       run_as_group
 

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

@@ -11,10 +11,10 @@ module DaVinciPASTestKit
       include UserInputResponse
 
       id :pas_client_v201_denial_group
-      title 'Denial Workflow'
+      title 'Denial Response'
       description %(
-        During these tests, the client will initiate a prior authorization
-        request and show it can respond appropriately to a 'denied' decision.
+        During these tests, the PAS client will initiate a prior authorization
+        request and show it can react appropriately to a 'denied' decision.
       )
       run_as_group
 
@@ -30,17 +30,18 @@ module DaVinciPASTestKit
       test from: :pas_client_v201_response_bundle_validation_test,
            config: { options: { workflow_tag: DENIAL_WORKFLOW_TAG } }
       test from: :pas_client_v201_response_attest,
-           title: 'Check that the client registers the request as denied (Attestation)',
+           title: 'Check that the PAS client registers the request as denied',
            description: %(
-             This test provides the tester an opportunity to observe their client following
+             During this test, the tester will observe the PAS client following
              the receipt of the denied response and attest that users are able to determine
              that the response has been denied.
            ),
            config: { options: {
              workflow_tag: DENIAL_WORKFLOW_TAG,
-             attest_message: "I attest that the client system displays the submitted claim as 'denied', meaning " \
+             attest_message: 'I attest that the PAS client did not error when handling the `$submit` ' \
+                             "response and displays the submitted claim as 'denied', meaning " \
                              'that the user cannot proceed with ordering or providing the requested service without ' \
-                             'making adjustments and submitting for further approval.'
+                             'making adjustments and submitting for further review.'
            } }
     end
   end