davinci_pas_test_kit 0.14.0 → 0.15.0

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

@@ -0,0 +1,214 @@
+require_relative '../../../cross_suite/must_support/must_support_data_gathering'
+require_relative '../urls'
+
+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.
+    #
+    # 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
+    class MustSupportWithAttestationOption < Inferno::Test
+      include DaVinciPASTestKit::MustSupportDataGathering
+      include URLs
+
+      id :pas_client_v221_must_support_with_attestation_option
+      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).
+      )
+
+      # 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')
+      def profiles
+        config.options[:profiles]
+      end
+
+      def require_one_of
+        config.options[:require_one_of]
+      end
+
+      def ig_version
+        config.options[:ig_version]
+      end
+
+      def type
+        config.options[:type]
+      end
+
+      def operation
+        config.options[:operation]
+      end
+
+      def target_resource_types
+        @target_resource_types ||= profiles.map { |profile| profile[:resource_type] }.uniq
+      end
+
+      def type_of_interest?(resource_type)
+        target_resource_types.include?(resource_type)
+      end
+
+      def grouped_resources
+        @grouped_resources ||= (resources_of_interest || []).group_by(&:resourceType)
+      end
+
+      # Query the repository directly instead of the data gathering default (load_tagged_requests): these
+      # requests are owned by the gather test, so associating them here would duplicate that
+      # association onto each attestation test's result.
+      def must_support_requests
+        @must_support_requests ||= Inferno::Repositories::Requests.new.tagged_requests(test_session_id, [tag])
+      end
+
+      output :attest_true_url
+      output :attest_false_url
+
+      # Hard-fail if no requests were received at all, and (for require_one_of) if none of the
+      # target request profiles are present. These are the only failure paths that aren't attestations.
+      run do
+        assert must_support_requests.present?, "No #{operation} requests received."
+
+        if require_one_of
+          assert resources_of_interest.present?,
+                 "#{type.titleize} Bundle(s) must include at least one instance of one of these " \
+                 "resource types: #{target_resource_types.join(', ')}"
+        end
+
+        unobserved_by_profile = gather_unobserved_elements
+
+        unobserved_by_profile.each do |profile_title, elements|
+          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?
+
+        identifier = test_session_id
+        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
+      def gather_unobserved_elements
+        profiles.each_with_object({}) do |profile, result|
+          profile_title = profile[:title] || profile[:resource_type]
+          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.
+            next if require_one_of
+
+            result[profile_title] = ["(no #{profile[:resource_type]} instances were observed)"]
+            next
+          end
+
+          metadata = load_metadata_for_profile_version(profile[:profile_key], ig_version)
+          missing = missing_must_support_elements(resources, nil, metadata:)
+          missing = remove_must_support_false_positives(missing, resources, profile[:resource_type])
+
+          result[profile_title] = missing if missing.present?
+        end
+      end
+
+      def attestation_message(unobserved_by_profile)
+        unobserved_list = unobserved_by_profile.flat_map do |profile_title, elements|
+          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:
+
+          #{unobserved_list}
+
+          Attest that the client system 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_false_url}) if the above statement is **false**. The test will **fail**.
+        MESSAGE
+      end
+
+      # Builds the test's description from the configured profiles' metadata at load time, so the
+      # generated group files stay lean and the listed must support elements stay in sync with the
+      # IG metadata. Called from the generated groups: `description build_description(config.options)`.
+      def self.build_description(options)
+        profiles = options[:profiles] || []
+
+        sections = profiles.map do |profile|
+          metadata = load_profile_metadata(profile[:profile_key], options[:ig_version])
+          "### #{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}"
+      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:)
+        if require_one_of
+          <<~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
+            the must support element `Claim.item.extension:requestedService`:
+
+            * PAS Medication Request
+            * PAS Service Request
+            * PAS Device Request
+            * PAS Nutrition Order
+
+            System 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.
+
+            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.
+
+            The test will look through the instances included in submissions made by the client
+            for the following must support elements:
+          INTRO
+        else
+          <<~INTRO.chomp
+            PAS client systems 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.
+          INTRO
+        end
+      end
+
+      def self.load_profile_metadata(profile_key, version)
+        path = File.join(__dir__, '..', '..', '..', 'cross_suite', 'generated', version, profile_key, 'metadata.yml')
+        Generator::ProfileMetadata.new(YAML.load_file(path, aliases: true))
+      end
+    end
+  end
+end

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

@@ -0,0 +1,12 @@
+require_relative '../../abstract_gather_must_support_test'
+require_relative '../urls'
+
+module DaVinciPASTestKit
+  module DaVinciPASV221
+    class PASClientGatherMustSupportTest < AbstractGatherMustSupportTest
+      include URLs
+
+      id :pas_client_v221_gather_must_support
+    end
+  end
+end

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

@@ -0,0 +1,40 @@
+require_relative 'workflows/pas_client_approval_submit_test'
+require_relative 'workflows/pas_client_response_attest'
+require_relative 'workflows/pas_client_request_bundle_validation_test'
+require_relative 'workflows/pas_client_response_bundle_validation_test'
+require_relative '../../cross_suite/tags'
+
+module DaVinciPASTestKit
+  module DaVinciPASV221
+    class PASClientApprovalGroup < Inferno::TestGroup
+      id :pas_client_v221_approval_group
+      title 'Approval Workflow'
+      description %(
+        During these tests, the client will initiate a prior authorization
+        request and show it can respond 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
+             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.'
+           } }
+    end
+  end
+end

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

@@ -0,0 +1,31 @@
+require 'smart_app_launch_test_kit'
+require_relative '../../cross_suite/tags'
+
+module DaVinciPASTestKit
+  module DaVinciPASV221
+    class PASClientAuthSMARTGroup < Inferno::TestGroup
+      id :pas_client_v221_auth_smart
+      title 'Review Authentication Interactions'
+      description %(
+        During these tests, Inferno will verify that the 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
+        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.
+      )
+      run_as_group
+
+      # smart auth verification
+      test from: :smart_client_token_request_bsca_verification,
+           config: {
+             options: { endpoint_suite_id: :davinci_pas_client_suite_v221 }
+           }
+      test from: :smart_client_token_use_verification,
+           config: {
+             options: { access_request_tags: [SUBMIT_TAG, INQUIRE_TAG] }
+           }
+    end
+  end
+end

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

@@ -0,0 +1,30 @@
+require 'udap_security_test_kit'
+require_relative '../../cross_suite/tags'
+
+module DaVinciPASTestKit
+  module DaVinciPASV221
+    class PASClientAuthUDAPGroup < Inferno::TestGroup
+      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
+        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
+        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.
+      )
+      run_as_group
+
+      test from: :udap_client_token_request_cc_verification,
+           config: {
+             options: { endpoint_suite_id: :davinci_pas_client_suite_v221 }
+           }
+      test from: :udap_client_token_use_verification,
+           config: {
+             options: { access_request_tags: [SUBMIT_TAG, INQUIRE_TAG] }
+           }
+    end
+  end
+end

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

@@ -0,0 +1,112 @@
+require_relative 'workflows/pas_client_claim_update_submit_tests'
+require_relative 'workflows/pas_client_request_bundle_validation_test'
+require_relative 'workflows/pas_client_response_bundle_validation_test'
+require_relative 'workflows/pas_client_claim_update_referenced_claim_test'
+require_relative 'workflows/pas_client_claim_update_grandparent_excluded_test'
+require_relative 'workflows/pas_client_claim_update_referenced_resources_test'
+require_relative 'workflows/pas_client_claim_update_entries_preserved_test'
+require_relative 'workflows/pas_client_claim_update_cancelled_entries_test'
+require_relative 'workflows/pas_client_claim_update_cancelled_items_certtype_test'
+require_relative 'workflows/pas_client_claim_update_changed_entries_test'
+require_relative 'workflows/pas_client_claim_update_cancel_request_test'
+require_relative '../../cross_suite/tags'
+
+module DaVinciPASTestKit
+  module DaVinciPASV221
+    class PASClientClaimUpdatesGroup < Inferno::TestGroup
+      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
+        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
+        request. Inferno never sends a Subscription notification during these interactions, even if
+        the configured response indicates the request was pended.
+
+        Once all submissions have been received, Inferno validates the conformance of each submitted
+        request Bundle and of the response Bundle it returned against the PAS Request and Response
+        Bundle profiles, and the verification tests check each Claim Update made during this group for
+        conformance with the
+        [updating authorization requests](https://hl7.org/fhir/us/davinci-pas/2.2.1/en/specification.html#updating-authorization-requests)
+        requirements of the PAS IG.
+      )
+      run_as_group
+
+      input :claim_update_initial_response, optional: true
+      input :claim_update_add_item_response, optional: true
+      input :claim_update_modify_cancel_response, optional: true
+      input :claim_update_cancel_all_response, optional: true
+
+      input_order :claim_update_initial_response,
+                  :claim_update_add_item_response,
+                  :claim_update_modify_cancel_response,
+                  :claim_update_cancel_all_response,
+                  :client_id,
+                  :session_url_path
+
+      claim_update_submit_steps = [
+        { key: 'initial', title: 'Initial submission',
+          submit: :pas_client_v221_claim_update_initial_submit_test, tag: CLAIM_UPDATE_INITIAL_TAG },
+        { key: 'add_item', title: 'Update - add an item',
+          submit: :pas_client_v221_claim_update_add_item_submit_test, tag: CLAIM_UPDATE_ADD_ITEM_TAG },
+        { key: 'modify_cancel', title: 'Update - modify an item and cancel an item',
+          submit: :pas_client_v221_claim_update_modify_cancel_submit_test, tag: CLAIM_UPDATE_MODIFY_CANCEL_TAG },
+        { key: 'cancel_all', title: 'Update - cancel the entire request',
+          submit: :pas_client_v221_claim_update_cancel_all_submit_test, tag: CLAIM_UPDATE_CANCEL_ALL_TAG }
+      ]
+
+      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.
+        )
+
+        claim_update_submit_steps.each { |step| test from: step[:submit] }
+      end
+
+      group do
+        title 'Update Details'
+        description %(
+          These tests check that the sequence of requests made follow the
+          update approach required.
+        )
+
+        test from: :pas_client_v221_claim_update_referenced_claim_test
+        test from: :pas_client_v221_claim_update_grandparent_excluded_test
+        test from: :pas_client_v221_claim_update_referenced_resources_test
+        test from: :pas_client_v221_claim_update_entries_preserved_test
+        test from: :pas_client_v221_claim_update_cancelled_entries_test
+        test from: :pas_client_v221_claim_update_cancelled_items_certtype_test
+        test from: :pas_client_v221_claim_update_changed_entries_test
+        test from: :pas_client_v221_claim_update_cancel_request_test
+      end
+
+      group do
+        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
+          Response Bundle profiles.
+        )
+
+        claim_update_submit_steps.each do |step|
+          test from: :pas_client_v221_request_bundle_validation_test do
+            id :"pas_client_v221_claim_update_request_validation_#{step[:key]}"
+            title "#{step[:title]}: submit request Bundle has the correct structure and content"
+            config options: { workflow_tag: step[:tag] }
+          end
+
+          test from: :pas_client_v221_response_bundle_validation_test do
+            id :"pas_client_v221_claim_update_response_validation_#{step[:key]}"
+            title "#{step[:title]}: submit response Bundle has the correct structure and content"
+            config options: { workflow_tag: step[:tag] }
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,47 @@
+require_relative 'workflows/pas_client_denial_submit_test'
+require_relative 'workflows/pas_client_response_attest'
+require_relative 'workflows/pas_client_response_bundle_validation_test'
+require_relative 'workflows/pas_client_request_bundle_validation_test'
+require_relative '../user_input_response'
+require_relative '../../cross_suite/tags'
+
+module DaVinciPASTestKit
+  module DaVinciPASV221
+    class PASClientDenialGroup < Inferno::TestGroup
+      include UserInputResponse
+
+      id :pas_client_v221_denial_group
+      title 'Denial Workflow'
+      description %(
+        During these tests, the client will initiate a prior authorization
+        request and show it can respond appropriately to a 'denied' decision.
+      )
+      run_as_group
+
+      input :denial_json_response, optional: true
+
+      input_order :denial_json_response,
+                  :client_id,
+                  :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
+             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 " \
+                             'that the user cannot proceed with ordering or providing the requested service without ' \
+                             'making adjustments and submitting for further approval.'
+           } }
+    end
+  end
+end

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

@@ -0,0 +1,20 @@
+require_relative 'pas_client_operation_failure_group'
+require_relative 'pas_client_processing_error_group'
+
+module DaVinciPASTestKit
+  module DaVinciPASV221
+    class PASClientErrorHandlingGroup < Inferno::TestGroup
+      id :pas_client_v221_error_handling_group
+      title 'Error Handling'
+      description %(
+        The error handling tests verify that the client can appropriately handle
+        [prior authorization error responses](https://hl7.org/fhir/us/davinci-pas/2.2.1/en/specification.html#prior-authorization-transaction-error-handling)
+        from the server, including both HTTP-level operation failures and
+        business-level processing errors conveyed within a response bundle.
+      )
+
+      group from: :pas_client_v221_operation_failure_group
+      group from: :pas_client_v221_processing_error_group
+    end
+  end
+end

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

@@ -0,0 +1,52 @@
+require_relative 'workflows/pas_client_modification_submit_test'
+require_relative 'workflows/pas_client_modification_verification_test'
+require_relative 'workflows/pas_client_response_attest'
+require_relative 'workflows/pas_client_request_bundle_validation_test'
+require_relative 'workflows/pas_client_response_bundle_validation_test'
+require_relative '../../cross_suite/tags'
+
+module DaVinciPASTestKit
+  module DaVinciPASV221
+    class PASClientModificationGroup < Inferno::TestGroup
+      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
+        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
+        details of the authorized items available to their users.
+      )
+      run_as_group
+
+      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
+             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.'
+           } }
+    end
+  end
+end

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

@@ -0,0 +1,96 @@
+require_relative '../generated/v2.2.1/pas_client_submit_must_support_group'
+require_relative '../generated/v2.2.1/pas_client_inquire_must_support_group'
+require_relative '../generated/v2.2.1/pas_client_submit_response_must_support_group'
+require_relative '../generated/v2.2.1/pas_client_inquire_response_must_support_group'
+require_relative 'must_support/pas_client_gather_must_support_test'
+require_relative 'workflows/pas_client_request_bundle_validation_test'
+require_relative 'workflows/pas_client_response_bundle_validation_test'
+require_relative 'workflows/pas_client_inquire_request_bundle_validation_test'
+require_relative 'workflows/pas_client_inquire_response_bundle_validation_test'
+
+module DaVinciPASTestKit
+  module DaVinciPASV221
+    class PASClientMustSupportGroup < Inferno::TestGroup
+      id :pas_client_v221_must_support
+      title 'Must Support Elements'
+      run_as_group
+      description %(
+        During these tests, the client will show that it supports all PAS-defined profiles and the must support
+        elements defined in them. This includes
+
+        - The ability to make prior authorization submission and inquiry requests that contain all
+          PAS-defined profiles and their must support elements.
+        - The ability to receive in responses to those requests all PAS-defined profiles and their
+          must support elements.
+
+        Clients under test will be asked to make additional requests to Inferno demonstrating coverage
+        of all must support items in the requests. Clients must also demonstrate that they can handle
+        all response must support elements. Because Inferno's mocked responses do not include all must
+        support elements, testers will need to provide responses that include examples of all must
+        support elements for Inferno to respond with.
+
+        Note that Inferno will consider requests made during the workflow group of tests, so only
+        profiles and must support elements not demonstrated during those tests need to be submitted
+        as a part of these.
+      )
+
+      # Combined receive group - single wait test for both submit and inquire
+      group do
+        id :pas_client_v221_must_support_receive
+        title 'Demonstrate Must Support Coverage'
+        description %(
+          Submit $submit and $inquire requests demonstrating coverage of must support elements.
+          Optionally, provide response bundles for Inferno to use when responding. Inferno will
+          verify both the requests received and the responses provided.
+        )
+        run_as_group
+
+        test from: :pas_client_v221_gather_must_support
+      end
+
+      # $submit Bundle Conformance Validation
+      group do
+        title '$submit Bundle Conformance'
+        description %(
+          Verify that the $submit request bundles sent by the client are conformant
+          and that the $submit response bundles provided for Inferno to send back
+          are conformant.
+        )
+        run_as_group
+
+        test from: :pas_client_v221_request_bundle_validation_test,
+             config: { options: { workflow_tag: MUST_SUPPORT_WORKFLOW_TAG } }
+        test from: :pas_client_v221_response_bundle_validation_test,
+             config: { options: { workflow_tag: MUST_SUPPORT_WORKFLOW_TAG } }
+      end
+
+      # $submit Request Must Support (fail when errors detected)
+      group from: :pas_client_v221_submit_must_support
+
+      # $submit Response Must Support (skip when errors detected)
+      group from: :pas_client_v221_submit_response_must_support
+
+      # $inquire Bundle Conformance Validation
+      group do
+        title '$inquire Bundle Conformance'
+        description %(
+          Verify that the $inquire request bundles sent by the client are conformant
+          and that the $inquire response bundles provided for Inferno to send back
+          are conformant.
+        )
+        run_as_group
+
+        test from: :pas_client_v221_inquire_request_bundle_validation_test,
+             config: { options: { workflow_tag: MUST_SUPPORT_WORKFLOW_TAG } }
+        test from: :pas_client_v221_inquire_response_bundle_validation_test,
+             config: { options: { workflow_tag: MUST_SUPPORT_WORKFLOW_TAG } }
+      end
+
+      # $inquire Request Must Support (fail when errors detected)
+      group from: :pas_client_v221_inquire_must_support
+
+      # $inquire Response Must Support (skip when errors detected)
+      group from: :pas_client_v221_inquire_response_must_support
+    end
+  end
+end