davinci_pas_test_kit 0.15.2 → 0.16.0

data/lib/davinci_pas_test_kit/client/v2.2.1/error_handling/pas_client_processing_error_response_validation_test.rb

@@ -11,16 +11,20 @@ module DaVinciPASTestKit
       id :pas_client_v221_processing_error_response_validation_test
       title '$submit response Bundle has the correct structure and contains error entries'
       description %(
-        This test verifies input provided by the tester instead of the system under test.
+        This test verifies input provided by the tester instead of the PAS client.
         Errors encountered will be treated as a skip instead of a failure.
 
         This test verifies the conformity of the PAS Response Bundle returned by Inferno during the
-        Processing Error workflow. The bundle is validated against the
+        Processing Error scenario. The bundle is validated against the
         [PAS Response Bundle](https://hl7.org/fhir/us/davinci-pas/2.2.1/StructureDefinition-profile-pas-response-bundle.html)
         profile. Additionally, it checks that the ClaimResponse contains at least one error entry,
         as required by the processing error scenario.
 
-        Per IG §7.2.5, business errors that are a part of processing the 278 payload are
+        To ensure that the PAS client is driving its behavior only based on standard
+        PAS information, custom extensions are not allowed within the response.
+
+        The PAS IG [requires](https://hl7.org/fhir/us/davinci-pas/2.2.1/en/specification.html#prior-authorization-transaction-error-handling)
+        that business errors that are a part of processing the 278 payload are
         represented in the mapping to the response bundle via the ClaimResponse error capability.
       )
       simulation_verification
@@ -33,17 +37,22 @@ module DaVinciPASTestKit
         response_body = request.response_body
         skip_if response_body.blank?, 'The Processing Error response body is empty.'
 
-        validate_pas_bundle_json(
-          response_body,
-          'http://hl7.org/fhir/us/davinci-pas/StructureDefinition/profile-pas-response-bundle',
-          '2.2.1',
-          'submit',
-          'response_bundle',
-          skips: true,
-          message: "Invalid processing error response bundle provided in 'Processing Error Response Bundle JSON' input:"
-        )
+        message = "Invalid processing error response bundle provided in 'Processing Error Response Bundle JSON' input:"
+        begin
+          JSON.parse(response_body)
+        rescue JSON::ParserError, TypeError
+          skip "#{message} Invalid JSON.".strip
+        end
 
         bundle = FHIR.from_contents(response_body)
+        skip_if !bundle.is_a?(FHIR::Bundle),
+                "#{message} Unexpected resource type: expected Bundle, but received #{bundle&.resourceType}.".strip
+
+        messages.concat(perform_no_custom_extensions_validation(bundle, 'submit', 'response', '2.2.1',
+                                                                echoed_from: request.request_body))
+        skip_if error_messages?,
+                "#{message} Bundle and/or entry resources are not conformant. Check messages for issues found.".strip
+
         claim_response = bundle&.entry&.find { |e| e&.resource&.resourceType == 'ClaimResponse' }&.resource
         skip_if claim_response&.error.blank?,
                 'The ClaimResponse in the Processing Error response bundle contains no error entries. ' \

data/lib/davinci_pas_test_kit/client/v2.2.1/error_handling/pas_client_processing_error_submit_test.rb

@@ -14,7 +14,7 @@ module DaVinciPASTestKit
       id :pas_client_v221_processing_error_submit_test
       title 'PAS client submits a claim and receives a response containing processing errors'
       description %(
-        Inferno will wait for a prior authorization submission request from the client.
+        During this test, Inferno will wait for a prior authorization submission request from the PAS client.
         Upon receipt, Inferno will return the provided response bundle containing one or
         more ClaimResponse.error entries.
       )
@@ -23,8 +23,10 @@ module DaVinciPASTestKit
             title: 'Processing Error Response Bundle JSON',
             type: 'textarea',
             description: %(
-              Inferno will return this PAS Response Bundle JSON in response to the $submit request
-              during this test. The bundle must contain at least one ClaimResponse.error entry.
+              Inferno will [instantiate](https://github.com/inferno-framework/davinci-pas-test-kit/wiki/Controlling-Simulated-Responses#response-instantiation)
+              this PAS Response Bundle JSON and return it as the response
+              to the `$submit` request received during the *Processing Errors* group.
+              The bundle must contain at least one ClaimResponse.error entry.
             )
       input :client_id,
             title: 'Client Id',
@@ -40,6 +42,7 @@ module DaVinciPASTestKit
             description: INPUT_SESSION_URL_PATH_LOCKED
 
       submit_respond_with :processing_error_response
+      config options: { submit_enabled: true }
 
       run do
         assert_valid_json processing_error_response,
@@ -50,16 +53,24 @@ module DaVinciPASTestKit
 
         wait(
           identifier: wait_identifier,
-          message: %(
-            **Processing Error Workflow Test**:
+          message: <<~MESSAGE
+            **Processing Error Scenario Test**:
+
+            Inferno will wait while the tester uses the PAS client to submit a PAS request to
+            Inferno. Inferno will [instantiate](https://github.com/inferno-framework/davinci-pas-test-kit/wiki/Controlling-Simulated-Responses#response-instantiation)
+            the provided Processing Error Response Bundle and respond with it.
+            The tests will automatically continue once a request has been received.
+
+            ### Endpoints
 
             Submit a PAS request to
 
             `#{submit_endpoint}`
 
-            Inferno will respond with the provided PAS Response Bundle containing
-            ClaimResponse.error entries.
-          )
+            ### Authentication and Identification
+
+            #{auth_description_for_wait(client_id)}
+          MESSAGE
         )
       end
     end

data/lib/davinci_pas_test_kit/client/v2.2.1/must_support/must_support_with_attestation_option.rb

@@ -5,10 +5,10 @@ module DaVinciPASTestKit
   module DaVinciPASV221
     # Aggregates the must support assessment across a list of profiles. Each must support element
     # that was not observed is logged as an info message, and when at least one was not observed the
-    # tester is given the opportunity to attest that the client system does not collect that data
-    # (and is not required to under the PAS implementation guide). A true attestation passes the
-    # test; a false attestation fails it. When every must support element was observed, the test
-    # passes without requiring any further input.
+    # tester is asked to attest that the PAS client does not collect that data. A true attestation
+    # passes the test; a false attestation fails it. The attestation option can be disabled
+    # using a config entry. When every must support element was observed, the
+    # test passes without requiring any further input.
     #
     # The must support assessment - including the shared X12 / DataAbsentReason false-positive
     # handling (remove_must_support_false_positives) is leveraged from the cross_suite must support
@@ -17,22 +17,27 @@ module DaVinciPASTestKit
       include URLs
 
       id :pas_client_v221_must_support_with_attestation_option
+
+      # Recorded in place of a profile's unobserved elements when none of its instances were observed
+      # - see gather_unobserved_elements.
+      NO_INSTANCES_OBSERVED = :no_instances_observed
       title 'Must support elements are observed across requests'
       description %(
-        This test reviews the must support elements observed across the listed profiles in the
-        requests made by the client. If any were not observed, the tester has the opportunity to
-        attest that the client system does not collect that data (and is not required to under the
-        PAS implementation guide).
+        During this test, Inferno will check that all must support elements defined in the listed
+        profiles were observed in the requests made by the PAS client.
       )
 
       # config.options:
-      #   profiles:        Array of { resource_type:, profile_key:, title: } describing the profiles
-      #                    to assess.
-      #   require_one_of:  Boolean. When true, at least one of the listed resource types must be
-      #                    present (a hard requirement) and only the profiles that are actually
-      #                    present are assessed - used for the "at least one request profile" case.
-      #                    When false, every listed profile is assessed.
-      #   ig_version:, type: ('request'), operation: ('submit' / 'inquire')
+      #   profiles:             Array of { resource_type:, profile_key:, title: } describing the profiles
+      #                         to assess.
+      #   require_one_of:       Boolean. When true, at least one of the listed resource types must be
+      #                         present (a hard requirement) and only the profiles that are actually
+      #                         present are assessed - used for the "at least one request profile" case.
+      #                         When false, every listed profile is assessed.
+      #   ig_version:           version of the id
+      #   type:                 'request', or 'response'
+      #   operation:            'submit', or 'inquire'
+      #   disable_attestation:  boolean indicating whether the attestation option is disabled (default: false)
       def profiles
         config.options[:profiles]
       end
@@ -53,6 +58,10 @@ module DaVinciPASTestKit
         config.options[:operation]
       end
 
+      def attestation_disabled?
+        config.options[:disable_attestation]
+      end
+
       def target_resource_types
         @target_resource_types ||= profiles.map { |profile| profile[:resource_type] }.uniq
       end
@@ -89,37 +98,44 @@ module DaVinciPASTestKit
         unobserved_by_profile = gather_unobserved_elements
 
         unobserved_by_profile.each do |profile_title, elements|
+          if elements == NO_INSTANCES_OBSERVED
+            add_message('info', "No instances of profile #{profile_title} were observed.")
+            next
+          end
+
           elements.each do |element|
             add_message('info', "Unobserved must support element for profile #{profile_title}: #{element}")
           end
         end
 
         # If nothing was unobserved, the test passes immediately without requiring any attestation.
-        # Otherwise, the tester is given the opportunity to attest that the client system does not collect
-        pass 'All must support elements were observed in the requests made by the client.' if
-          unobserved_by_profile.empty?
+        # Otherwise, the tester can attest that the client system does not collect, unless disabled
+        pass all_observed_message if unobserved_by_profile.empty?
+        assert !attestation_disabled?, missing_elements_error_string(unobserved_by_profile)
 
-        identifier = test_session_id
+        # only the tester continues this wait, so use a fresh random identifier - see SessionIdentification
+        identifier = SecureRandom.uuid
         output attest_true_url: "#{resume_pass_url}?token=#{identifier}",
                attest_false_url: "#{resume_fail_url}?token=#{identifier}"
 
         wait(identifier:, message: attestation_message(unobserved_by_profile))
       end
 
-      # @return unobserved must support elements keyed by profile title
+      # @return [Hash{String => Array<String>, Symbol}] unobserved must support elements keyed by profile
+      #   title, or NO_INSTANCES_OBSERVED for a profile with no instances at all.
       def gather_unobserved_elements
         profiles.each_with_object({}) do |profile, result|
-          profile_title = profile[:title] || profile[:resource_type]
+          profile_title = profile_title(profile)
           resources = grouped_resources[profile[:resource_type]] || []
 
           if resources.blank?
             # In require_one_of mode the tester only needs to demonstrate one of the alternatives,
             # so a profile with no instances is not flagged. Otherwise, the absence of any instance
             # means the profile's must support elements could not be observed at all - flag the
-            # resource type itself rather than enumerating every element.
+            # profile itself rather than enumerating every element.
             next if require_one_of
 
-            result[profile_title] = ["(no #{profile[:resource_type]} instances were observed)"]
+            result[profile_title] = NO_INSTANCES_OBSERVED
             next
           end
 
@@ -131,23 +147,51 @@ module DaVinciPASTestKit
         end
       end
 
+      def profile_title(profile)
+        profile[:title] || profile[:resource_type]
+      end
+
+      # Titles of the configured profiles whose resource type has instances in the requests.
+      def observed_profile_titles
+        profiles.select { |profile| grouped_resources[profile[:resource_type]].present? }
+          .map { |profile| profile_title(profile) }
+      end
+
+      def missing_elements_error_string(unobserved_by_profile)
+        unobserved_by_profile.map do |profile_title, elements|
+          if elements == NO_INSTANCES_OBSERVED
+            "No #{profile_title} resources were observed."
+          else
+            "Could not find #{elements.join(', ')} in the provided #{profile_title} resource(s)."
+          end
+        end.join(' ')
+      end
+
+      # Names the profiles with instances in the requests so testers can tell which were assessed.
+      def all_observed_message
+        'All must support elements for the following profiles were observed ' \
+          "in the requests made by the PAS client: #{observed_profile_titles.join(', ')}."
+      end
+
       def attestation_message(unobserved_by_profile)
         unobserved_list = unobserved_by_profile.flat_map do |profile_title, elements|
+          next ["- #{profile_title}: no instances were observed"] if elements == NO_INSTANCES_OBSERVED
+
           elements.map { |element| "- #{profile_title}: #{element}" }
         end.join("\n")
 
         <<~MESSAGE
           The following #{operation} request must support elements were not observed in the
-          requests made by the client:
+          requests made by the PAS client:
 
           #{unobserved_list}
 
-          Attest that the client system does **not** collect the data for these unobserved
+          Attest that the PAS client does **not** collect the data for these unobserved
           must support elements (and is not required to under the PAS implementation guide).
 
-          [Click here](#{attest_true_url}) if the above statement is **true**. The test will **pass**.
+          [Click here](#{attest_true_url}) if the above statement is **true**.
 
-          [Click here](#{attest_false_url}) if the above statement is **false**. The test will **fail**.
+          [Click here](#{attest_false_url}) if the above statement is **false**.
         MESSAGE
       end
 
@@ -162,13 +206,19 @@ module DaVinciPASTestKit
           "### #{profile[:title] || profile[:resource_type]}\n#{metadata.must_support_list_string(indent: 0)}"
         end.join("\n\n")
 
-        "#{description_intro(require_one_of: options[:require_one_of])}\n\n#{sections}"
+        intro = description_intro(require_one_of: options[:require_one_of],
+                                  attestation_allowed: !options[:disable_attestation])
+        "#{intro}\n\n#{sections}"
       end
 
       # The require_one_of intro reproduces the original PasClientMustSupportRequestProfilesTest
-      # description, tweaked only to describe the attestation option.
-      def self.description_intro(require_one_of:)
+      # description, tweaked only to describe the attestation option when attestation is allowed.
+      def self.description_intro(require_one_of:, attestation_allowed: true)
         if require_one_of
+          attestation_note = if attestation_allowed
+                               ' For must support elements not observed on an included request profile, ' \
+                                 'testers can attest that they are not supported by the PAS client.'
+                             end
           <<~INTRO.chomp
             The PAS IG includes four profiles for providing the specifics of the service or product requested
             in the prior authorization request. Any one of these profiles can be referenced in
@@ -179,28 +229,28 @@ 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 as long as that data is collected within
-            and displayed by the system.
+            populate all of the defined must support elements.
 
             This test ensures that the submitted request bundles include at least one instance of a
             profile listed above. Then for each profile observed, it checks for the presence of
-            each must support element defined in that profile. For must support elements not observed
-            on an included request profile, testers can attest that they are not supported by the
-            client system.
+            each must support element defined in that profile.#{attestation_note}
 
-            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:
           INTRO
         else
+          attestation_note = if attestation_allowed
+                               ' For those not observed, testers can attest that they are not supported ' \
+                                 'by the PAS client.'
+                             end
           <<~INTRO.chomp
-            PAS client systems are required to be able to populate must support elements representing
+            PAS clients are required to be able to populate must support elements representing
             data collected and displayed to users on instances of all profiles included in requests.
             This test checks all identified instances of the profiles listed below within requests sent
-            by the client to ensure that the must support elements are observed. For those not observed,
-            testers can attest that they are not supported by the client system.
+            by the PAS client to ensure that the must support elements are observed.#{attestation_note}
           INTRO
         end
       end

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

@@ -8,33 +8,34 @@ module DaVinciPASTestKit
   module DaVinciPASV221
     class PASClientApprovalGroup < Inferno::TestGroup
       id :pas_client_v221_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
 
       input :approval_json_response, optional: true
 
       test from: :pas_client_v221_approval_submit_test
-      test from: :pas_client_v221_request_bundle_validation_test,
-           config: { options: { workflow_tag: APPROVAL_WORKFLOW_TAG } }
-
-      test from: :pas_client_v221_response_bundle_validation_test,
-           config: { options: { workflow_tag: APPROVAL_WORKFLOW_TAG } }
       test from: :pas_client_v221_response_attest,
            title: 'PAS client displays 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.'
+             operation_tag: SUBMIT_TAG,
+             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.'
            } }
+      test from: :pas_client_v221_request_bundle_validation_test,
+           config: { options: { workflow_tag: APPROVAL_WORKFLOW_TAG } }
+      test from: :pas_client_v221_response_bundle_validation_test,
+           config: { options: { workflow_tag: APPROVAL_WORKFLOW_TAG } }
     end
   end
 end

data/lib/davinci_pas_test_kit/client/v2.2.1/pas_client_attestations_group.rb

@@ -0,0 +1,32 @@
+require_relative 'attestations/attestation_instructions'
+require_relative 'attestations/client_security_attestation_test'
+require_relative 'attestations/client_data_element_expectations_attestation_test'
+require_relative 'attestations/client_provider_review_attestation_test'
+require_relative 'attestations/client_subscription_error_recovery_attestation_test'
+
+module DaVinciPASTestKit
+  module DaVinciPASV221
+    class PASClientAttestationsGroup < Inferno::TestGroup
+      id :pas_client_v221_attestations
+      title 'Visual Inspection and Attestation'
+      description %(
+        Each test in this group asks the tester to confirm system conformance to one or more
+        requirements from the [PAS v2.2.1 Implementation Guide](https://hl7.org/fhir/us/davinci-pas/2.2.1).
+        The tester attests that the PAS client meets the statement by selecting "Yes",
+        and may record supporting details in the accompanying notes field. Selecting "No" fails the
+        test. Notes provided are recorded in the test result.
+
+        Testers are responsible for confirming that their PAS client meets all requirements associated with a test
+        before selecting "Yes" on the attestation input with the same name as the test. The text of the
+        attested requirement(s) for each input can be reviewed by clicking the "View Specification Requirements" link
+        in the "About" tab of the test with the same name.
+      )
+      input_instructions ATTESTATION_INPUT_INSTRUCTIONS
+
+      test from: :pas_client_v221_security_attestation
+      test from: :pas_client_v221_data_element_expectations_attestation
+      test from: :pas_client_v221_provider_review_attestation
+      test from: :pas_client_v221_subscription_error_recovery_attestation
+    end
+  end
+end

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

@@ -7,13 +7,13 @@ module DaVinciPASTestKit
       id :pas_client_v221_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.2.1/pas_client_auth_udap_group.rb

@@ -7,13 +7,13 @@ module DaVinciPASTestKit
       id :pas_client_v221_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.2.1/pas_client_claim_updates_group.rb

@@ -17,12 +17,12 @@ module DaVinciPASTestKit
       id :pas_client_v221_claim_updates_group
       title 'Claim Updates'
       description %(
-        During these tests, the client will demonstrate that it can update a previously submitted
+        During these tests, the PAS client will demonstrate that it can update a previously submitted
         prior authorization request by submitting a sequence of `$submit` requests: an initial
         request, an update that adds an item, an update that modifies one item and cancels another,
         and an update that cancels the entire request.
 
-        Inferno waits for each submission in turn, automatically continuing once it receives the
+        Inferno will wait for each submission in turn, automatically continuing once it receives the
         request. Inferno never sends a Subscription notification during these interactions, even if
         the configured response indicates the request was pended.
 
@@ -61,17 +61,35 @@ module DaVinciPASTestKit
       group do
         title 'Interaction'
         description %(
-          Inferno waits for each prior authorization submission from the client in turn. Each wait test
-          auto-continues when its request is received; no Subscription notifications are triggered.
+          During each test in this group, Inferno will wait for a prior authorization submission
+          from the PAS client. Each test will continue automatically when a request is received.
+          No Subscription notifications are triggered even if the tester provides pended responses.
         )
 
         claim_update_submit_steps.each { |step| test from: step[:submit] }
+        test from: :pas_client_v221_response_attest,
+             id: :pas_client_v221_response_attest_updates,
+             title: 'PAS client handled the $submit responses without erroring',
+             description: %(
+               During this test, the tester will verify that the PAS client handled
+               the `$submit` operation responses received during the update
+               sequence, making the result available to the user without failing
+               or erroring.
+             ),
+             config: { options: {
+               workflow_tag: [CLAIM_UPDATE_INITIAL_TAG, CLAIM_UPDATE_ADD_ITEM_TAG,
+                              CLAIM_UPDATE_MODIFY_CANCEL_TAG, CLAIM_UPDATE_CANCEL_ALL_TAG],
+               multiple_requests_ok: true,
+               attest_message: 'I attest that the PAS client correctly handled the `$submit` ' \
+                               'operation responses received from Inferno during this test, making the details ' \
+                               'available to users without errors.'
+             } }
       end
 
       group do
         title 'Update Details'
         description %(
-          These tests check that the sequence of requests made follow the
+          The tests in this group check that the sequence of requests made follow the
           update approach required.
         )
 
@@ -89,7 +107,7 @@ module DaVinciPASTestKit
         title '$submit Conformance'
         description %(
           For each submission received above, these tests validate the conformance of the request Bundle
-          the client submitted and of the response Bundle Inferno returned against the PAS Request and
+          the PAS client submitted and of the response Bundle Inferno returned against the PAS Request and
           Response Bundle profiles.
         )
 

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

@@ -11,10 +11,10 @@ module DaVinciPASTestKit
       include UserInputResponse
 
       id :pas_client_v221_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
 
@@ -25,23 +25,25 @@ module DaVinciPASTestKit
                   :session_url_path
 
       test from: :pas_client_v221_denial_submit_test
-      test from: :pas_client_v221_request_bundle_validation_test,
-           config: { options: { workflow_tag: DENIAL_WORKFLOW_TAG } }
-      test from: :pas_client_v221_response_bundle_validation_test,
-           config: { options: { workflow_tag: DENIAL_WORKFLOW_TAG } }
       test from: :pas_client_v221_response_attest,
            title: 'PAS client displays 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 " \
+             operation_tag: SUBMIT_TAG,
+             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.'
            } }
+      test from: :pas_client_v221_request_bundle_validation_test,
+           config: { options: { workflow_tag: DENIAL_WORKFLOW_TAG } }
+      test from: :pas_client_v221_response_bundle_validation_test,
+           config: { options: { workflow_tag: DENIAL_WORKFLOW_TAG } }
     end
   end
 end

data/lib/davinci_pas_test_kit/client/v2.2.1/pas_client_modification_group.rb

@@ -11,15 +11,15 @@ module DaVinciPASTestKit
       id :pas_client_v221_modification_group
       title 'Payer Modifications'
       description %(
-        During these tests, the client will initiate a prior authorization request and show it can
-        respond appropriately to a response in which the payer authorizes items that differ from those
+        During these tests, the PAS client will initiate a prior authorization request and show it can
+        react appropriately to a response in which the payer authorizes items that differ from those
         that were requested.
 
         In PAS v2.2.1, payers are permitted to
         [return items that are different from what was requested](https://hl7.org/fhir/us/davinci-pas/2.2.1/en/specification.html#returning-authorized-items-that-are-different-from-what-was-requested).
         When this happens, each requested item is returned in the `ClaimResponse.item` with an adjudication
         status of A6 ('Modified') and the details of what was actually authorized are returned in a
-        corresponding `ClaimResponse.addItem`. Clients must be able to process these responses and make the
+        corresponding `ClaimResponse.addItem`. PAS clients must be able to process these responses and make the
         details of the authorized items available to their users.
       )
       run_as_group
@@ -27,26 +27,25 @@ module DaVinciPASTestKit
       input :modification_json_response, optional: true
 
       test from: :pas_client_v221_modification_submit_test
-      test from: :pas_client_v221_request_bundle_validation_test,
-           config: { options: { workflow_tag: MODIFICATION_WORKFLOW_TAG } }
-
-      test from: :pas_client_v221_response_bundle_validation_test,
-           config: { options: { workflow_tag: MODIFICATION_WORKFLOW_TAG } }
-      test from: :pas_client_v221_modification_verification_test
-
       test from: :pas_client_v221_response_attest,
            title: 'PAS client makes the details of the payer-authorized items available',
            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 payer modification response and attest that users are able to
              determine the details of what was actually authorized by the payer.
            ),
            config: { options: {
              workflow_tag: MODIFICATION_WORKFLOW_TAG,
-             attest_message: 'I attest that the details of what the payer actually authorized, including any ' \
-                             'modifications made to the requested items, were made available to users in the ' \
-                             'client system.'
+             operation_tag: SUBMIT_TAG,
+             attest_message: 'I attest that the PAS client did not error when handling the `$submit` ' \
+                             'response and displays the details of what the payer actually authorized, including any ' \
+                             'modifications made to the requested items.'
            } }
+      test from: :pas_client_v221_request_bundle_validation_test,
+           config: { options: { workflow_tag: MODIFICATION_WORKFLOW_TAG } }
+      test from: :pas_client_v221_response_bundle_validation_test,
+           config: { options: { workflow_tag: MODIFICATION_WORKFLOW_TAG } }
+      test from: :pas_client_v221_modification_verification_test
     end
   end
 end