davinci_pas_test_kit 0.15.1 → 0.16.0

data/lib/davinci_pas_test_kit/client/endpoints/claim_endpoint.rb

@@ -1,7 +1,9 @@
 require_relative '../user_input_response'
+require_relative 'endpoint_session_identification'
+require_relative 'expired_token'
 require_relative '../response_generator'
+require_relative '../subscription_notification_trigger'
 require_relative '../client_urls'
-require_relative '../jobs/send_pas_subscription_notification'
 require_relative '../../cross_suite/fhirpath_utils'
 require_relative '../../cross_suite/response_selection_utils'
 require 'subscriptions_test_kit'
@@ -11,24 +13,25 @@ module DaVinciPASTestKit
   class ClaimEndpoint < Inferno::DSL::SuiteEndpoint
     include SubscriptionsTestKit::SubscriptionsR5BackportR4Client::SubscriptionSimulationUtils
     include ResponseGenerator
+    include SubscriptionNotificationTrigger
     include ClientURLs
     include FhirpathUtils
     include ResponseSelectionUtils
+    include EndpointSessionIdentification
+    include ExpiredToken
 
     # override the one from URLs to make it version specific
     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
+    error_response_format :operation_outcome
 
     def tags
+      # Requests rejected for an expired token or a rejected $inquire are not treated as
+      # submissions of any workflow.
+      return [] if expired_token? || !operation_enabled?
+
       operation_tag = operation == 'submit' ? SUBMIT_TAG : INQUIRE_TAG
       workflow_tag = WORKFLOW_TAG_MAP[workflow]
 
@@ -52,6 +55,13 @@ module DaVinciPASTestKit
       test.config.options[:suppress_notifications] == true
     end
 
+    # Tests must opt in to each operation with the submit_enabled and inquire_enabled options. Inferno responds
+    # to every request for an operation that is not enabled with an OperationOutcome, without tagging the
+    # request or continuing the test.
+    def operation_enabled?
+      %w[inquire submit].include?(operation) && test.config.options[:"#{operation}_enabled"] == true
+    end
+
     def workflow
       case test.id
       when /.*pended.*/
@@ -70,7 +80,7 @@ module DaVinciPASTestKit
     end
 
     def must_support_workflow?
-      test.id =~ /.*must_support.*/ || test.id =~ /.*gather_must_support.*/
+      test.id =~ /.*must_support.*/
     end
 
     WORKFLOW_TAG_MAP = {
@@ -87,6 +97,11 @@ module DaVinciPASTestKit
 
       response.format = :json
 
+      unless operation_enabled?
+        make_rejected_operation_response
+        return
+      end
+
       # Handle the operation failure and processing error workflows, which require a user-provided response.
       if workflow == :operation_failure
         make_operation_failure_response
@@ -136,10 +151,11 @@ module DaVinciPASTestKit
     end
 
     def update_result
-      if UDAPSecurityTestKit::MockUDAPServer.request_has_expired_token?(request)
+      if expired_token?
         UDAPSecurityTestKit::MockUDAPServer.update_response_for_expired_token(response, 'Bearer token')
         return
       end
+      return unless operation_enabled? # keep waiting for the request that the test is looking for
 
       results_repo.update_result(result.id, 'pass') unless test.config.options[:accepts_multiple_requests]
     end
@@ -152,27 +168,39 @@ module DaVinciPASTestKit
     private
 
     # Resolves the user-provided response, using criteria-based selection for must support
-    # workflows or the single-response approach for other workflows.
+    # workflows or the single-response approach for other workflows
+    # and replaces {{fhirpath}} tokens with values from the request.
     def resolve_user_response(req_bundle)
-      if must_support_workflow?
-        select_must_support_response(req_bundle)
-      else
-        UserInputResponse.user_inputted_response(test, operation, result)
-      end
+      user_response = if must_support_workflow?
+                        select_must_support_response(req_bundle)
+                      else
+                        UserInputResponse.user_inputted_response(test, operation, result)
+                      end
+
+      return nil unless user_response.present?
+
+      replace_tokens(user_response, req_bundle)
+    rescue FhirpathUtils::FhirpathServiceError => e
+      add_result_warning(
+        'Unable to instantiate a tester-provided response, so Inferno will generate a default response: ' \
+        "#{e.message}"
+      )
+      nil
     end
 
     # Selects the first tester-provided response candidate whose selection criteria all
     # match the incoming request, extracts its response Bundle (unwrapping it when the
-    # candidate pairs the Bundle with criteria), and replaces {{fhirpath}} tokens with
-    # values from the request. Returns nil, causing Inferno to generate a default
-    # response, if no candidates are provided or none match.
+    # candidate pairs the Bundle with criteria). Returns nil, causing Inferno to generate a default
+    # response, if no candidates are provided or none match. Problems with the
+    # tester-provided input or the FHIRPath service also result in nil, with a warning
+    # on the waiting test so that the tester can see what went wrong.
     def select_must_support_response(req_bundle)
-      candidates = UserInputResponse.response_candidates(result, operation)
+      candidates = UserInputResponse.response_candidates(test, operation, result)
       return if candidates.blank?
 
       operation_url_suffix = "$#{operation}"
       request_number = count_previous_successful_requests(operation_url_suffix) + 1
-      selected_index = candidates.index { |candidate| include_entity?(candidate, req_bundle, operation_url_suffix) }
+      selected_index = candidates.index { |candidate| include_entity?(candidate, req_bundle, request_number) }
 
       if selected_index.nil?
         Inferno::Application['logger'].info(
@@ -186,17 +214,33 @@ module DaVinciPASTestKit
         "Selected tester-provided response bundle #{selected_index + 1} of #{candidates.length} " \
         "for #{operation_url_suffix} request ##{request_number}."
       )
-      replace_tokens(entity_bundle(candidates[selected_index]), req_bundle)
+      entity_response(candidates[selected_index])
+    rescue UserInputResponse::InvalidInputError, FhirpathUtils::FhirpathServiceError => e
+      add_result_warning(
+        'Unable to select a tester-provided response, so Inferno will generate a default response: ' \
+        "#{e.message}"
+      )
+      nil
     end
 
-    # Round-trips the selected bundle through the FHIR model to normalize it after
-    # token replacement. Falls back to the replaced string if it no longer parses,
-    # e.g., when a replaced value breaks the JSON structure.
+    # Replaces {{fhirpath}} tokens using values from the incoming request, round-tripping
+    # the result through the FHIR model to normalize it. The response may be a parsed hash
+    # (must support workflow) or the raw JSON string of a single input. If a replaced value
+    # breaks the JSON structure, the result cannot be returned as a FHIR response, so nil is
+    # returned with a warning on the waiting test and Inferno generates a default response.
     def replace_tokens(bundle_hash, req_bundle)
-      replaced = replace_tokens_in_string(bundle_hash.to_json, req_bundle)
+      bundle_json = bundle_hash.is_a?(String) ? bundle_hash : bundle_hash.to_json
+      replaced = replace_tokens_in_string(bundle_json, req_bundle)
+      return bundle_json if replaced.equal?(bundle_json)
+
       FHIR.from_contents(replaced)&.to_json || replaced
     rescue JSON::ParserError
-      replaced
+      add_result_warning(
+        'Unable to use the selected tester-provided response, so Inferno will generate a default response. ' \
+        'The response is not valid JSON after {{fhirpath}} token replacement, for example because a token ' \
+        'value contains a double quote.'
+      )
+      nil
     end
 
     def handle_missing_required_elements(claim_entry, response)
@@ -236,68 +280,80 @@ module DaVinciPASTestKit
     end
 
     def make_processing_error_response
-      user_provided_bundle = UserInputResponse.user_inputted_response(test, operation, result)
-      unless user_provided_bundle.present?
-        response.status = 400
-        response.body = FHIR::OperationOutcome.new(
-          issue: FHIR::OperationOutcome::Issue.new(
-            severity: 'fatal', code: 'required',
-            details: FHIR::CodeableConcept.new(
-              text: 'The processing_error_response input is required for this test and was not provided.'
-            )
-          )
-        ).to_json
+      unless UserInputResponse.user_inputted_response(test, operation, result).present?
+        error_outcome_response('The processing_error_response input is required for this test and was not provided.')
+        return
+      end
+
+      req_bundle = FHIR.from_contents(request.body.string)
+      if req_bundle.blank?
+        handle_missing_required_elements(nil, response)
+        return
+      end
+
+      # Unlike other workflows, there is no mocked response to fall back to when instantiation fails.
+      instantiated_response = resolve_user_response(req_bundle)
+      if instantiated_response.blank?
+        error_outcome_response('The processing_error_response input could not be instantiated. ' \
+                               'See the warnings on the waiting test for details.')
         return
       end
 
+      claim_entry = req_bundle.entry&.find { |e| e&.resource&.resourceType == 'Claim' }
       response.status = 200
-      response.body = user_provided_bundle
+      response.body = update_tester_provided_response(instantiated_response, claim_entry&.fullUrl, operation,
+                                                      ig_version)
+    end
+
+    def make_rejected_operation_response
+      response.status = 501
+      response.body = FHIR::OperationOutcome.new(
+        issue: FHIR::OperationOutcome::Issue.new(
+          severity: 'error', code: 'not-supported',
+          details: FHIR::CodeableConcept.new(
+            text: "Inferno does not support the $#{operation} operation during this test."
+          )
+        )
+      ).to_json
+    end
+
+    def error_outcome_response(text)
+      response.status = 400
+      response.body = FHIR::OperationOutcome.new(
+        issue: FHIR::OperationOutcome::Issue.new(
+          severity: 'fatal', code: 'required', details: FHIR::CodeableConcept.new(text:)
+        )
+      ).to_json
     end
 
     def operation
-      request.url&.split('$')&.last
+      request.path.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)
+    # Helper methods for SubscriptionNotificationTrigger
 
-      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,
-                            ig_version)
+    def notification_test_run_id
+      test_run.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']
+    def notification_test_session_id
+      test_run.test_session_id
+    end
 
-      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
+    def notification_result_id
+      result.id
     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, 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
+    def notification_bearer_token
+      client_access_token_input(result)
+    end
+
+    def tester_notification_bundle
+      notification_bundle_input(result)
     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')
+    def client_subscription_json
+      find_subscription(test_run.test_session_id, as_json: true)
     end
   end
 end

data/lib/davinci_pas_test_kit/client/endpoints/endpoint_session_identification.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+require 'udap_security_test_kit'
+
+module DaVinciPASTestKit
+  # Identifies the test session for the claim and Subscription endpoints, using either the session
+  # path or the client id embedded in the bearer token.
+  module EndpointSessionIdentification
+    # Where the session identifier is expected. Used in responses when no session is found.
+    LOCATION_DESCRIPTION = 'the path or embedded within the bearer token in the Authorization header'
+
+    def test_run_identifier_location_description
+      LOCATION_DESCRIPTION
+    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
+  end
+end

data/lib/davinci_pas_test_kit/client/endpoints/expired_token.rb

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+require 'udap_security_test_kit'
+
+module DaVinciPASTestKit
+  # Checks whether the request's bearer token has expired.
+  module ExpiredToken
+    private
+
+    # Memoized so the token is only decoded and parsed once per request, even though both
+    # #tags and the response handling need to check it.
+    def expired_token?
+      return @expired_token if defined?(@expired_token)
+
+      @expired_token = UDAPSecurityTestKit::MockUDAPServer.request_has_expired_token?(request)
+    end
+  end
+
+  # Prepended to endpoints that reject requests made with an expired bearer token before any other
+  # handling.
+  module ExpiredTokenRejection
+    include ExpiredToken
+
+    def make_response
+      if expired_token?
+        UDAPSecurityTestKit::MockUDAPServer.update_response_for_expired_token(response, 'Bearer token')
+        return
+      end
+
+      super
+    end
+
+    def tags
+      # Requests rejected for an expired token are not treated as submissions of any workflow.
+      return [] if expired_token?
+
+      super
+    end
+  end
+end

data/lib/davinci_pas_test_kit/client/endpoints/subscription_create_endpoint.rb

@@ -1,25 +1,18 @@
 require_relative '../../cross_suite/tags'
+require_relative 'endpoint_session_identification'
+require_relative 'expired_token'
 require_relative '../jobs/send_subscription_handshake'
 require 'subscriptions_test_kit'
 
 module DaVinciPASTestKit
   class SubscriptionCreateEndpoint < Inferno::DSL::SuiteEndpoint
     include SubscriptionsTestKit::SubscriptionsR5BackportR4Client::SubscriptionSimulationUtils
+    include EndpointSessionIdentification
+    prepend ExpiredTokenRejection
 
-    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
+    error_response_format :operation_outcome
 
     def make_response
-      if UDAPSecurityTestKit::MockUDAPServer.request_has_expired_token?(request)
-        UDAPSecurityTestKit::MockUDAPServer.update_response_for_expired_token(response, 'Bearer token')
-        return
-      end
-
       response.format = :json
       response.status = 400
 
@@ -73,6 +66,8 @@ module DaVinciPASTestKit
       [SUBSCRIPTION_CREATE_TAG]
     end
 
+    private
+
     def verify_subscription(subscription)
       unless subscription.is_a? FHIR::Subscription
         return operation_outcome('error', 'invalid', 'No recognized R4 Subscription in request body')

data/lib/davinci_pas_test_kit/client/endpoints/subscription_delete_endpoint.rb

@@ -0,0 +1,13 @@
+require_relative '../../cross_suite/tags'
+require_relative 'endpoint_session_identification'
+require_relative 'expired_token'
+require 'subscriptions_test_kit'
+
+module DaVinciPASTestKit
+  class SubscriptionDeleteEndpoint < SubscriptionsTestKit::SubscriptionDeleteEndpoint
+    include EndpointSessionIdentification
+    prepend ExpiredTokenRejection
+
+    error_response_format :operation_outcome
+  end
+end

data/lib/davinci_pas_test_kit/client/endpoints/subscription_read_endpoint.rb

@@ -0,0 +1,13 @@
+require_relative '../../cross_suite/tags'
+require_relative 'endpoint_session_identification'
+require_relative 'expired_token'
+require 'subscriptions_test_kit'
+
+module DaVinciPASTestKit
+  class SubscriptionReadEndpoint < SubscriptionsTestKit::SubscriptionReadEndpoint
+    include EndpointSessionIdentification
+    prepend ExpiredTokenRejection
+
+    error_response_format :operation_outcome
+  end
+end

data/lib/davinci_pas_test_kit/client/endpoints/subscription_status_endpoint.rb

@@ -1,34 +1,29 @@
 require_relative '../../cross_suite/tags'
+require_relative 'endpoint_session_identification'
+require_relative 'expired_token'
 require 'subscriptions_test_kit'
 
 module DaVinciPASTestKit
   class SubscriptionStatusEndpoint < Inferno::DSL::SuiteEndpoint
     include SubscriptionsTestKit::SubscriptionsR5BackportR4Client::SubscriptionSimulationUtils
     include ResponseGenerator
+    include EndpointSessionIdentification
+    prepend ExpiredTokenRejection
 
-    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
+    error_response_format :operation_outcome
 
     def make_response
-      if UDAPSecurityTestKit::MockUDAPServer.request_has_expired_token?(request)
-        UDAPSecurityTestKit::MockUDAPServer.update_response_for_expired_token(response)
-        return
-      end
-
       response.format = :json
-      subscription = find_subscription(test_run.test_session_id)
+      # Reflects any updates or deletion of the Subscription by the client
+      subscription = find_current_subscription(test_run.test_session_id)
 
-      unless subscription.present?
+      subscription_id = request.params[:id]
+      if subscription.blank? || (subscription_id.present? && subscription_id != subscription.id)
         not_found
         return
       end
 
-      subscription_id = request.params[:id]
+      status_code = current_subscription_status_code(subscription)
 
       # Handle resource-level status params
       unless subscription_id.present?
@@ -40,7 +35,7 @@ module DaVinciPASTestKit
           return
         end
 
-        unless subscription_params_match?(params, subscription)
+        unless subscription_params_match?(params, subscription, status_code)
           not_found
           return
         end
@@ -48,7 +43,6 @@ module DaVinciPASTestKit
 
       subscription_url = "#{base_subscription_url}/#{subscription.id}"
       subscription_topic = subscription.criteria
-      status_code = determine_subscription_status_code(subscription_id)
       event_count = determine_event_count(test_run.test_session_id)
 
       notification_json = notification_bundle_input(result)
@@ -69,20 +63,21 @@ module DaVinciPASTestKit
       response.status = 200
     end
 
-    def subscription_params_match?(params, subscription)
+    def subscription_params_match?(params, subscription, status_code)
       id_params = find_params(params, 'id')
 
       return false if id_params&.any? && id_params&.none? { |p| p.valueString == subscription.id }
 
       status_params = find_params(params, 'status')
-      subscription_status = determine_subscription_status_code(subscription.id)
-      status_params.blank? || status_params.any? { |p| p.valueString == subscription_status }
+      status_params.blank? || status_params.any? { |p| p.valueString == status_code }
     end
 
     def tags
       [SUBSCRIPTION_STATUS_TAG]
     end
 
+    private
+
     def not_found
       response.status = 404
       response.body = operation_outcome('error', 'not-found').to_json

data/lib/davinci_pas_test_kit/client/endpoints/subscription_update_endpoint.rb

@@ -0,0 +1,13 @@
+require_relative '../../cross_suite/tags'
+require_relative 'endpoint_session_identification'
+require_relative 'expired_token'
+require 'subscriptions_test_kit'
+
+module DaVinciPASTestKit
+  class SubscriptionUpdateEndpoint < SubscriptionsTestKit::SubscriptionUpdateEndpoint
+    include EndpointSessionIdentification
+    prepend ExpiredTokenRejection
+
+    error_response_format :operation_outcome
+  end
+end

data/lib/davinci_pas_test_kit/client/endpoints/token_endpoint.rb

@@ -12,6 +12,22 @@ module DaVinciPASTestKit
 
       def test_run_identifier
         UDAPSecurityTestKit::MockUDAPServer.client_id_from_client_assertion(request.params[:client_assertion])
+      rescue JWT::DecodeError
+        nil
+      end
+
+      def test_run_identifier_location_description
+        "the client assertion's 'iss' claim representing the client's id"
+      end
+
+      def no_session_response
+        response.status = 401
+        response.format = :json
+        response.body = {
+          error: 'invalid_client',
+          error_description: no_session_message
+
+        }.to_json
       end
 
       def make_response

data/lib/davinci_pas_test_kit/client/generated/v2.0.1/beneficiary/client_inquire_request_must_support_beneficiary_test.rb

@@ -7,11 +7,11 @@ module DaVinciPASTestKit
       title 'All must support elements for profile PAS Beneficiary Patient are observed on $inquire requests'
       description %(
         
-        PAS client systems are required to be able to populate all
-        must support elements on instances of all profiles included in 
+        PAS clients are required to be able to populate all
+        must support elements on instances of all profiles included in `$inquire`
         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
+        Profile on requests sent by the PAS client to ensure that the following
         must support elements are observed: 
 
         * Patient.address

data/lib/davinci_pas_test_kit/client/generated/v2.0.1/beneficiary/client_inquire_response_must_support_beneficiary_test.rb

@@ -7,11 +7,11 @@ module DaVinciPASTestKit
       title 'All must support elements for profile PAS Beneficiary Patient are observed on $inquire responses'
       description %(
         
-        PAS client systems are required to be able to receive all
-        must support elements on instances of all profiles included in 
+        PAS clients are required to be able to receive all
+        must support elements on instances of all profiles included in `$inquire`
         responses, including instances of the PAS Beneficiary Patient Profile.
         This test checks all identified instances of the PAS Beneficiary Patient
-        Profile on responses sent to the client to ensure that the following
+        Profile on responses sent to the PAS client to ensure that the following
         must support elements are observed:
 
         * Patient.address

data/lib/davinci_pas_test_kit/client/generated/v2.0.1/beneficiary/client_submit_request_must_support_beneficiary_test.rb

@@ -7,11 +7,11 @@ module DaVinciPASTestKit
       title 'All must support elements for profile PAS Beneficiary Patient are observed on $submit requests'
       description %(
         
-        PAS client systems are required to be able to populate all
-        must support elements on instances of all profiles included in 
+        PAS clients are required to be able to populate all
+        must support elements on instances of all profiles included in `$submit`
         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
+        Profile on requests sent by the PAS client to ensure that the following
         must support elements are observed: 
 
         * Patient.address

data/lib/davinci_pas_test_kit/client/generated/v2.0.1/beneficiary/client_submit_response_must_support_beneficiary_test.rb

@@ -7,11 +7,11 @@ module DaVinciPASTestKit
       title 'All must support elements for profile PAS Beneficiary Patient are observed on $submit responses'
       description %(
         
-        PAS client systems are required to be able to receive all
-        must support elements on instances of all profiles included in 
+        PAS clients are required to be able to receive all
+        must support elements on instances of all profiles included in `$submit`
         responses, including instances of the PAS Beneficiary Patient Profile.
         This test checks all identified instances of the PAS Beneficiary Patient
-        Profile on responses sent to the client to ensure that the following
+        Profile on responses sent to the PAS client to ensure that the following
         must support elements are observed:
 
         * Patient.address

data/lib/davinci_pas_test_kit/client/generated/v2.0.1/claim_inquiry/client_inquire_request_must_support_claim_inquiry_test.rb

@@ -7,11 +7,11 @@ module DaVinciPASTestKit
       title 'All must support elements for profile PAS Claim Inquiry are observed on $inquire requests'
       description %(
         
-        PAS client systems are required to be able to populate all
-        must support elements on instances of all profiles included in 
+        PAS clients are required to be able to populate all
+        must support elements on instances of all profiles included in `$inquire`
         requests, including instances of the PAS Claim Inquiry Profile.
         This test checks all identified instances of the PAS Claim Inquiry
-        Profile on requests sent by the client to ensure that the following
+        Profile on requests sent by the PAS client to ensure that the following
         must support elements are observed: 
 
         * Claim.accident