davinci_pas_test_kit 0.14.0 → 0.15.0

data/lib/davinci_pas_test_kit/client/v2.2.1/workflows/pas_client_claim_update_validation_utils.rb

@@ -0,0 +1,183 @@
+require_relative '../../../cross_suite/tags'
+
+module DaVinciPASTestKit
+  module DaVinciPASV221
+    # Shared helpers for the Claim Update verification tests. These tests reload the
+    # requests received during the Claim Update wait tests (by their unique tags) and
+    # inspect the submitted PAS Claim Update Bundles against the relevant conformance
+    # requirements. No live state is used - everything is reloaded from the tagged,
+    # persisted requests.
+    module ClaimUpdateValidationUtils
+      CERTIFICATION_TYPE_EXTENSION_URL =
+        'http://hl7.org/fhir/us/davinci-pas/StructureDefinition/extension-certificationType'.freeze
+      INFO_CHANGED_EXTENSION_URL =
+        'http://hl7.org/fhir/us/davinci-pas/StructureDefinition/extension-infoChanged'.freeze
+      INFO_CANCELLED_EXTENSION_URL =
+        'http://hl7.org/fhir/us/davinci-pas/StructureDefinition/modifierextension-infoCancelled'.freeze
+      CERTIFICATION_TYPE_CANCEL_CODE = '3'.freeze
+      # The PAS Information Change Mode value set (CodeSystem PASTempCodes) defines exactly
+      # these two codes: 'added' (new information) and 'changed' (previously sent info changed).
+      INFO_CHANGE_MODE_CODES = %w[added changed].freeze
+
+      # The ordered Claim Update submissions, paired with the unique tag each was stored under.
+      def claim_update_steps
+        [
+          { label: 'initial submission', tag: CLAIM_UPDATE_INITIAL_TAG },
+          { label: 'add-item update', tag: CLAIM_UPDATE_ADD_ITEM_TAG },
+          { label: 'modify-and-cancel update', tag: CLAIM_UPDATE_MODIFY_CANCEL_TAG },
+          { label: 'cancel-entire-request update', tag: CLAIM_UPDATE_CANCEL_ALL_TAG }
+        ]
+      end
+
+      # The submissions that are updates to a previously submitted Claim (everything except
+      # the initial submission).
+      def claim_update_updates
+        claim_update_steps.drop(1)
+      end
+
+      # The submissions that carry item/supportingInfo detail and can be compared against the
+      # immediately prior version. The cancel-entire-request update is excluded because it needs
+      # no items.
+      def claim_update_detail_chain
+        claim_update_steps.take(3)
+      end
+
+      # Reloads the most recent request stored under `tag` and parses it as a FHIR::Bundle.
+      # Returns nil if no such request was received or it does not parse to a Bundle.
+      def claim_update_bundle(tag)
+        request = load_tagged_requests(tag).last
+        return nil if request.nil? || request.request_body.blank?
+
+        resource = FHIR.from_contents(request.request_body)
+        resource.is_a?(FHIR::Bundle) ? resource : nil
+      rescue StandardError
+        nil
+      end
+
+      # The Claim being submitted is the first Claim entry in a PAS Request Bundle.
+      def first_claim(bundle)
+        return nil if bundle.nil?
+
+        bundle.entry.map(&:resource).find { |resource| resource.is_a?(FHIR::Claim) }
+      end
+
+      # Builds ordered prior/current Claim comparisons across the detail chain, skipping any
+      # link where a request was not received.
+      def claim_update_detail_comparisons
+        claims = claim_update_detail_chain.map do |step|
+          bundle = claim_update_bundle(step[:tag])
+          { label: step[:label], claim: first_claim(bundle) }
+        end
+
+        claims.each_cons(2).filter_map do |prior, current|
+          next if prior[:claim].nil? || current[:claim].nil?
+
+          { prior: prior[:claim], current: current[:claim],
+            prior_label: prior[:label], current_label: current[:label] }
+        end
+      end
+
+      # Finds the bundle entry that a reference points to, accommodating absolute fullUrls,
+      # urn:uuid fullUrls, and relative "ResourceType/id" references.
+      # NOTE: purposefully more permissive than strict FHIR Bundle reference resolution logic
+      # to allow for evaluation. Other steps will catch issues like missing fullUrl values.
+      def bundle_entry_for_reference(bundle, reference)
+        return nil if bundle.nil? || reference.blank?
+
+        bundle.entry.find do |entry|
+          next false if entry.nil?
+
+          resource = entry.resource
+          full_url = entry.fullUrl.to_s
+          full_url == reference ||
+            (resource && "#{resource.resourceType}/#{resource.id}" == reference) ||
+            (full_url.present? && full_url.end_with?("/#{reference}"))
+        end
+      end
+
+      def related_claim_references(claim)
+        Array(claim&.related).filter_map { |related| related.claim&.reference }
+      end
+
+      def entry_sequences(entries)
+        Array(entries).map(&:sequence).compact
+      end
+
+      def index_by_sequence(entries)
+        Array(entries).to_h { |entry| [entry.sequence, entry] }
+      end
+
+      def entry_kind(entry)
+        entry.class.name.to_s.split('::').last == 'Item' ? 'item' : 'supportingInfo'
+      end
+
+      # Returns true if the element (an item or the Claim itself) carries a certificationType
+      # extension with code 3 (Cancel).
+      def certification_type_cancel?(element)
+        Array(element&.extension).any? do |extension|
+          extension.url == CERTIFICATION_TYPE_EXTENSION_URL &&
+            Array(extension.valueCodeableConcept&.coding).any? do |coding|
+              coding.code == CERTIFICATION_TYPE_CANCEL_CODE
+            end
+        end
+      end
+
+      def info_cancelled_extension(element)
+        Array(element&.modifierExtension).find { |extension| extension.url == INFO_CANCELLED_EXTENSION_URL }
+      end
+
+      def info_cancelled?(element)
+        info_cancelled_extension(element)&.valueBoolean == true
+      end
+
+      def info_changed_extension(element)
+        Array(element&.extension).find { |extension| extension.url == INFO_CHANGED_EXTENSION_URL }
+      end
+
+      # An entry is treated as "canceled" when it carries either change marker.
+      def cancellation_marked?(element)
+        certification_type_cancel?(element) || info_cancelled_extension(element).present?
+      end
+
+      def newly_cancelled?(current_entry, prior_entry)
+        info_cancelled?(current_entry) && !info_cancelled?(prior_entry)
+      end
+
+      # Compares an entry against its prior version, ignoring the change-tracking extensions
+      # (infoChanged, certificationType) and modifier extension (infoCancelled), to determine
+      # whether its substantive content was modified.
+      def entry_modified?(current_entry, prior_entry)
+        normalized_entry_hash(current_entry) != normalized_entry_hash(prior_entry)
+      end
+
+      def normalized_entry_hash(entry)
+        hash = entry.to_hash
+        if hash['extension'].is_a?(Array)
+          hash['extension'] = hash['extension'].reject do |extension|
+            [INFO_CHANGED_EXTENSION_URL, CERTIFICATION_TYPE_EXTENSION_URL].include?(extension['url'])
+          end
+          hash.delete('extension') if hash['extension'].empty?
+        end
+        if hash['modifierExtension'].is_a?(Array)
+          hash['modifierExtension'] = hash['modifierExtension'].reject do |extension|
+            extension['url'] == INFO_CANCELLED_EXTENSION_URL
+          end
+          hash.delete('modifierExtension') if hash['modifierExtension'].empty?
+        end
+        hash
+      end
+
+      # Collects the Claim Update steps for which a request was actually received, attaching the
+      # parsed Bundle and Claim. Used by tests that inspect each submission independently.
+      def received_claim_update_steps(steps = claim_update_steps)
+        steps.filter_map do |step|
+          bundle = claim_update_bundle(step[:tag])
+          claim = first_claim(bundle)
+          next if claim.nil?
+
+          step.merge(bundle:, claim:)
+        end
+      end
+    end
+  end
+end

data/lib/davinci_pas_test_kit/client/v2.2.1/workflows/pas_client_denial_submit_test.rb

@@ -0,0 +1,12 @@
+require_relative '../../abstract_denial_submit_test'
+require_relative '../urls'
+
+module DaVinciPASTestKit
+  module DaVinciPASV221
+    class PASClientDenialSubmitTest < AbstractDenialSubmitTest
+      include URLs
+
+      id :pas_client_v221_denial_submit_test
+    end
+  end
+end

data/lib/davinci_pas_test_kit/client/v2.2.1/workflows/pas_client_inquire_request_bundle_validation_test.rb

@@ -0,0 +1,55 @@
+require_relative '../../../cross_suite/pas_bundle_validation'
+
+module DaVinciPASTestKit
+  module DaVinciPASV221
+    class PasClientInquireRequestBundleValidationTest < Inferno::Test
+      include DaVinciPASTestKit::PasBundleValidation
+
+      id :pas_client_v221_inquire_request_bundle_validation_test
+      title '$inquire request Bundles have the correct structure and content'
+      description %(
+        This test verifies the conformity of the client's request body to the
+        [PAS Inquiry Request Bundle](http://hl7.org/fhir/us/davinci-pas/2.2.1/StructureDefinition-profile-pas-inquiry-request-bundle.html)
+        structure. It also checks that other conformance requirements defined in the [PAS Formal
+        Specification](https://hl7.org/fhir/us/davinci-pas/2.2.1/specification.html),
+        such as the presence of all referenced instances within the bundle and the
+        conformance of those instances to the appropriate profiles, are met.
+
+        It verifies the presence of mandatory elements and that elements with
+        required bindings contain appropriate values. CodeableConcept element
+        bindings will fail if none of their codings have a code/system belonging
+        to the bound ValueSet. Quantity, Coding, and code element bindings will
+        fail if their code/system are not found in the valueset.
+
+        Note that because X12 value sets are not public, elements bound to value
+        sets containing X12 codes are not validated.
+      )
+
+      def request_type_tag
+        INQUIRE_TAG
+      end
+
+      def workflow_tag
+        config.options[:workflow_tag]
+      end
+
+      run do
+        if workflow_tag.present?
+          load_tagged_requests(request_type_tag, workflow_tag)
+        else
+          load_tagged_requests(request_type_tag)
+        end
+        skip_if !request.present?, 'No inquire requests received.'
+
+        validate_pas_bundle_json(
+          request.request_body,
+          'http://hl7.org/fhir/us/davinci-pas/StructureDefinition/profile-pas-inquiry-request-bundle',
+          '2.2.1',
+          'inquire',
+          'request_bundle',
+          message: 'The Bundle provided for the Claim/$inquire operation is invalid:'
+        )
+      end
+    end
+  end
+end

data/lib/davinci_pas_test_kit/client/v2.2.1/workflows/pas_client_inquire_response_bundle_validation_test.rb

@@ -0,0 +1,78 @@
+require_relative '../../../cross_suite/pas_bundle_validation'
+require_relative '../../user_input_response'
+require_relative '../../response_generator'
+
+module DaVinciPASTestKit
+  module DaVinciPASV221
+    class PasClientInquireResponseBundleValidationTest < Inferno::Test
+      include DaVinciPASTestKit::PasBundleValidation
+      include UserInputResponse
+      include ResponseGenerator
+
+      id :pas_client_v221_inquire_response_bundle_validation_test
+      title '$inquire response Bundles have the correct structure and content'
+      description %(
+        This test verifies the conformity of the inquire response sent by Inferno, which will have been
+        either:
+        - the response body provided by the tester in the corresponding input, or
+        - created by Inferno from the $inquire Bundle.
+
+        In either case, this test verifies the conformity of the response body to the
+        [PAS Inquiry Response Bundle](https://hl7.org/fhir/us/davinci-pas/2.2.1/StructureDefinition-profile-pas-inquiry-response-bundle.html)
+        structure. It also checks that other conformance requirements defined in the [PAS Formal
+        Specification](https://hl7.org/fhir/us/davinci-pas/2.2.1/specification.html),
+        such as the presence of all referenced instances within the bundle and the
+        conformance of those instances to the appropriate profiles, are met.
+
+        It verifies the presence of mandatory elements and that elements with
+        required bindings contain appropriate values. CodeableConcept element
+        bindings will fail if none of their codings have a code/system belonging
+        to the bound ValueSet. Quantity, Coding, and code element bindings will
+        fail if their code/system are not found in the valueset.
+
+        Note that because X12 value sets are not public, elements bound to value
+        sets containing X12 codes are not validated.
+      )
+      simulation_verification
+
+      def request_type
+        'inquire'
+      end
+
+      def workflow_tag
+        config.options[:workflow_tag]
+      end
+
+      def target_user_input
+        case workflow_tag
+        when MUST_SUPPORT_WORKFLOW_TAG
+          :ms_inquire_responses
+        else
+          :inquire_json_response
+        end
+      end
+
+      run do
+        load_tagged_requests(workflow_tag, INQUIRE_TAG)
+        skip_if requests.empty?, 'No responses to verify because no inquire requests were made.'
+        message = if workflow_tag == MUST_SUPPORT_WORKFLOW_TAG
+                    'Invalid must support response bundle provided:'
+                  elsif user_inputted_response? target_user_input
+                    "Invalid response generated from provided input '#{input_title(target_user_input)}':"
+                  else
+                    'Invalid response generated from the submitted claim:'
+                  end
+
+        validate_pas_bundle_json(
+          request.response_body,
+          'http://hl7.org/fhir/us/davinci-pas/StructureDefinition/profile-pas-inquiry-response-bundle',
+          '2.2.1',
+          request_type,
+          'response_bundle',
+          skips: true,
+          message:
+        )
+      end
+    end
+  end
+end

data/lib/davinci_pas_test_kit/client/v2.2.1/workflows/pas_client_modification_submit_test.rb

@@ -0,0 +1,12 @@
+require_relative '../../abstract_modification_submit_test'
+require_relative '../urls'
+
+module DaVinciPASTestKit
+  module DaVinciPASV221
+    class PASClientModificationSubmitTest < AbstractModificationSubmitTest
+      include URLs
+
+      id :pas_client_v221_modification_submit_test
+    end
+  end
+end

data/lib/davinci_pas_test_kit/client/v2.2.1/workflows/pas_client_modification_verification_test.rb

@@ -0,0 +1,101 @@
+require_relative '../../../cross_suite/tags'
+
+module DaVinciPASTestKit
+  module DaVinciPASV221
+    class PasClientModificationVerificationTest < Inferno::Test
+      id :pas_client_v221_modification_verification_test
+      title '$submit response represents a payer modification'
+      description %(
+        In PAS v2.2.1, a payer may authorize items that differ from those that were requested. This test
+        verifies that the response returned for the $submit request represents such a payer modification by
+        checking that:
+
+        - at least one `ClaimResponse.item` entry has an adjudication review action code of A6 ('Modified'), and
+        - each modified item is paired with a `ClaimResponse.addItem` entry that references it via the same
+          `itemSequence` value, conveying the details of what was actually authorized.
+
+        The response checked here is either the response body provided by the tester in the corresponding
+        input or the one generated by Inferno from the $submit Bundle.
+      )
+      simulation_verification
+
+      REVIEW_ACTION_URL =
+        'http://hl7.org/fhir/us/davinci-pas/StructureDefinition/extension-reviewAction'.freeze
+      REVIEW_ACTION_CODE_URL =
+        'http://hl7.org/fhir/us/davinci-pas/StructureDefinition/extension-reviewActionCode'.freeze
+      MODIFIED_REVIEW_ACTION_CODE = 'A6'.freeze
+
+      run do
+        load_tagged_requests(MODIFICATION_WORKFLOW_TAG, SUBMIT_TAG)
+        skip_if requests.empty?, 'No responses to verify because no submit requests were made.'
+
+        # Log findings directly to the result rather than asserting inline so that every issue
+        # across all received responses is reported in a single run instead of halting on the first.
+        requests.each { |submit_request| check_modification_response(submit_request) }
+
+        assert_no_error_messages('The $submit response does not represent a payer modification. ' \
+                                 'See Messages for details.')
+      end
+
+      def check_modification_response(submit_request)
+        claim_response = claim_response_from_response_body(submit_request.response_body)
+        if claim_response.blank?
+          add_message('error', 'No ClaimResponse was found in the $submit response.')
+          return
+        end
+
+        modified_sequences = modified_item_sequences(claim_response)
+        if modified_sequences.blank?
+          add_message('error',
+                      'Expected at least one ClaimResponse.item entry with an adjudication review action code of ' \
+                      "'#{MODIFIED_REVIEW_ACTION_CODE}' (Modified), but none were found.")
+        end
+
+        add_item_sequences = Array(claim_response.addItem).flat_map { |add_item| Array(add_item.itemSequence) }
+        missing = modified_sequences.reject { |sequence| add_item_sequences.include?(sequence) }
+        return if missing.empty?
+
+        add_message('error',
+                    'Each modified item must be paired with a ClaimResponse.addItem entry that has the same ' \
+                    "itemSequence. No matching addItem was found for itemSequence(s): #{missing.join(', ')}.")
+      end
+
+      # Extracts the ClaimResponse from a $submit response body, unwrapping the Parameters resource
+      # that wraps the Bundle for v2.2.1 inquire responses if one is present.
+      def claim_response_from_response_body(response_body)
+        resource = FHIR.from_contents(response_body)
+        return if resource.blank?
+
+        bundle =
+          if resource.is_a?(FHIR::Parameters)
+            resource.parameter&.map(&:resource)&.find { |r| r.is_a?(FHIR::Bundle) }
+          else
+            resource
+          end
+        return unless bundle.is_a?(FHIR::Bundle)
+
+        bundle.entry&.map(&:resource)&.find { |r| r.is_a?(FHIR::ClaimResponse) }
+      end
+
+      def modified_item_sequences(claim_response)
+        Array(claim_response.item).select { |item| item_modified?(item) }.map(&:itemSequence).compact
+      end
+
+      def item_modified?(item)
+        Array(item.adjudication).any? { |adjudication| adjudication_modified?(adjudication) }
+      end
+
+      def adjudication_modified?(adjudication)
+        review_action = Array(adjudication.extension).find { |ext| ext.url == REVIEW_ACTION_URL }
+        return false if review_action.blank?
+
+        review_action_code = Array(review_action.extension).find { |ext| ext.url == REVIEW_ACTION_CODE_URL }
+        return false if review_action_code&.valueCodeableConcept.blank?
+
+        Array(review_action_code.valueCodeableConcept.coding).any? do |coding|
+          coding.code == MODIFIED_REVIEW_ACTION_CODE
+        end
+      end
+    end
+  end
+end

data/lib/davinci_pas_test_kit/client/v2.2.1/workflows/pas_client_pended_submit_test.rb

@@ -0,0 +1,148 @@
+require_relative '../urls'
+require_relative '../../client_input_descriptions'
+require_relative '../../user_input_response'
+require_relative '../../../cross_suite/pas_bundle_validation'
+require_relative '../../session_identification'
+
+module DaVinciPASTestKit
+  module DaVinciPASV221
+    class PASClientPendedSubmitTest < Inferno::Test
+      include URLs
+      include SessionIdentification
+      include UserInputResponse
+      include PasBundleValidation
+
+      id :pas_client_v221_pended_submit_test
+      title 'PAS Client submits a claim and receives a final decision via a notification'
+      description %(
+        Inferno will wait for a prior authorization submission request
+        from the client. Upon receipt, Inferno will respond with the
+        provided pended response. Subsequently, Inferno will send a
+        full-resource notification containing the final decision.
+        In v2.2.1, no follow-up `$inquire` request is needed as the
+        notification includes all details.
+      )
+
+      config options: { accepts_multiple_requests: true }
+      input :notification_bundle,
+            title: 'Claim updated notification JSON',
+            type: 'textarea',
+            optional: true,
+            description: %(
+              If provided, this JSON will be sent as the notification for the
+              PAS Subscription to tell the client that a decision has been made on the pended claim.
+              Before sending, Inferno will update the provided notification with details that the tester cannot
+              know ahead of time, including timestamps corresponding to the notification trigger time, and the id of
+              the triggering ClaimResponse if Inferno mocks that ClaimResponse because it is not provided by the
+              tester through the *Claim pended response JSON* input.
+              If not provided, a notification will be generated from the returned ClaimResponse.
+              In either case the response will be validated to ensure that the notification
+              is conformant. For v2.2.1, the notification will be a full-resource notification
+              containing the complete ClaimResponse.
+            )
+      input :pended_json_response,
+            title: 'Claim pended response JSON',
+            type: 'textarea',
+            optional: true,
+            description: %(
+              If provided, this JSON will be sent in response to $submit requests during this test
+              to indicate that the request has been pended awaiting a final decision.
+              It will be updated to make creation timestamps current.
+              If not provided, a pended response will be generated from the submitted Claim.
+              In either case the response will be validated against the PAS Response Bundle profile.
+            )
+      input :client_endpoint_access_token,
+            optional: true,
+            title: 'Client Notification Access Token',
+            description: %(
+              The bearer token that Inferno will send on requests to the client under test's rest-hook notification
+              endpoint. Not needed if the client under test will create a Subscription with an appropriate header value
+              in the `channel.header` element. If a value for the `authorization` header is provided in
+              `channel.header`, this value will override it.
+            )
+      input :client_id,
+            title: 'Client Id',
+            type: 'text',
+            optional: true,
+            locked: true,
+            description: INPUT_CLIENT_ID_LOCKED
+      input :session_url_path,
+            title: 'Session-specific URL path extension',
+            type: 'text',
+            optional: true,
+            locked: true,
+            description: INPUT_SESSION_URL_PATH_LOCKED
+
+      submit_respond_with :pended_json_response
+      output :confirmation_url
+
+      run do
+        load_tagged_requests(SUBSCRIPTION_CREATE_TAG)
+        skip_if requests.empty?, # NOTE: subscription needed ahead of time to support notification generation
+                %(
+                  Pended workflow tests cannot proceed because no Subscription exists to receive notifications
+                  for pended claims. Run the _PAS Subscription Setup_ tests to provide a Subscription for use
+                  in delivering notifications before re-running the pended workflow tests.
+                )
+
+        if user_inputted_response? :pended_json_response
+          assert_valid_json pended_json_response,
+                            "Input '#{input_title(:pended_json_response)}' must be valid JSON"
+        else
+          add_message('info', %(
+            No pended response provided in input '#{input_title(:pended_json_response)}'. Any responses to $submit
+            requests will be generated by Inferno from the submitted Claim.
+          ))
+        end
+
+        if notification_bundle.present?
+          assert_valid_json notification_bundle,
+                            "Input '#{input_title(:notification_bundle)}' must be valid JSON"
+        else
+          add_message('info', %(
+            No notification body provided in input '#{input_title(:notification_bundle)}'. When sending a
+            notification finalizing a pended $submit response, the notification body will be generated by Inferno
+            from the submitted Claim.
+          ))
+        end
+
+        wait_identifier = session_wait_identifier(client_id, session_url_path)
+        submit_endpoint = session_endpoint_url(:submit, client_id, session_url_path)
+        confirmation_url = "#{resume_pass_url}?token=#{wait_identifier}"
+        output(confirmation_url:)
+
+        wait(
+          identifier: wait_identifier,
+          timeout: 600,
+          message: %(
+            **Pended Workflow Test**:
+
+            1. Submit a PAS request to
+
+            `#{submit_endpoint}`
+
+            If the optional '**#{input_title(:pended_json_response)}**' input is populated, it will
+            be returned, updated with current timestamps. Otherwise, a pended response will
+            be generated by Inferno using the received Claim.
+
+            2. Within 5-10 seconds, Inferno will send a full-resource notification indicating that the
+               ClaimResponse has been finalized. The notification will contain the complete updated
+               ClaimResponse. If the optional '**#{input_title(:notification_bundle)}**' input is populated
+                Inferno will send it as a notification. Otherwise, a notification will be generated
+                from Inferno. In either case, the notification will be delivered to the endpoint provided on the
+                Subscription during the _PAS Subscription Setup_ tests.
+
+            Note that Inferno will ask testers to attest to correct behavior of the system between these steps,
+            i.e., that the system marked the pended prior auth request appropriately after step 1 (submit) but
+            before step 2 (notification). Thus testers should check their system state as appropriate in order
+            to be able to faithfully answer the attestations.
+
+            Once the client has completed these steps,
+            [click here to complete the test](#{confirmation_url})
+            and continue Inferno's evaluation of the interaction.
+          )
+        )
+      end
+    end
+  end
+end

data/lib/davinci_pas_test_kit/client/v2.2.1/workflows/pas_client_request_bundle_validation_test.rb

@@ -0,0 +1,56 @@
+require_relative '../../../cross_suite/pas_bundle_validation'
+
+module DaVinciPASTestKit
+  module DaVinciPASV221
+    class PasClientRequestBundleValidationTest < Inferno::Test
+      include DaVinciPASTestKit::PasBundleValidation
+
+      id :pas_client_v221_request_bundle_validation_test
+      title '$submit request Bundles have the correct structure and content'
+      description %(
+        This test verifies the conformity of the client's submit request body to the
+        [PAS Request Bundle](http://hl7.org/fhir/us/davinci-pas/2.2.1/StructureDefinition-profile-pas-request-bundle.html)
+        structure. It also checks that other conformance requirements defined in the [PAS Formal
+        Specification](https://hl7.org/fhir/us/davinci-pas/2.2.1/specification.html),
+        such as the presence of all referenced instances within the bundle and the
+        conformance of those instances to the appropriate profiles, are met.
+
+        It verifies the presence of mandatory elements and that elements with
+        required bindings contain appropriate values. CodeableConcept element
+        bindings will fail if none of their codings have a code/system belonging
+        to the bound ValueSet. Quantity, Coding, and code element bindings will
+        fail if their code/system are not found in the valueset.
+
+        Note that because X12 value sets are not public, elements bound to value
+        sets containing X12 codes are not validated.
+      )
+      verifies_requirements 'hl7.fhir.us.davinci-pas_2.2.1@spec-1'
+
+      def workflow_tag
+        config.options[:workflow_tag]
+      end
+
+      def request_type_tag
+        SUBMIT_TAG
+      end
+
+      run do
+        if workflow_tag.present?
+          load_tagged_requests(request_type_tag, workflow_tag)
+        else
+          load_tagged_requests(request_type_tag)
+        end
+        skip_if !request.present?, 'No submit requests received.'
+
+        validate_pas_bundle_json(
+          request.request_body,
+          'http://hl7.org/fhir/us/davinci-pas/StructureDefinition/profile-pas-request-bundle',
+          '2.2.1',
+          'submit',
+          'request_bundle',
+          message: 'The Bundle provided for the Claim/$submit operation is invalid:'
+        )
+      end
+    end
+  end
+end

data/lib/davinci_pas_test_kit/client/v2.2.1/workflows/pas_client_response_attest.rb

@@ -0,0 +1,12 @@
+require_relative '../../abstract_response_attest'
+require_relative '../urls'
+
+module DaVinciPASTestKit
+  module DaVinciPASV221
+    class PASClientResponseAttest < AbstractResponseAttest
+      include URLs
+
+      id :pas_client_v221_response_attest
+    end
+  end
+end