davinci_pas_test_kit 0.14.0 → 0.15.0

data/lib/davinci_pas_test_kit/{response_generator.rb → client/response_generator.rb}

@@ -1,23 +1,37 @@
+require_relative '../parameters_helper'
+
 module DaVinciPASTestKit
   module ResponseGenerator
-    def mock_id_only_notification_bundle(submit_response, subscription_reference, subscription_topic)
+    include ParametersHelper
+
+    def mock_id_only_notification_bundle(submit_response, subscription_reference, subscription_topic,
+                                         ig_version = 'v2.0.1')
       notification_timestamp = Time.now.utc
       mock_notification_bundle = build_mock_notification_bundle(notification_timestamp, subscription_reference,
-                                                                subscription_topic, submit_response, 'id-only', nil)
+                                                                subscription_topic, submit_response, 'id-only', nil,
+                                                                ig_version)
       mock_notification_bundle.to_json
     end
 
-    def mock_full_resource_notification_bundle(submit_response, subscription_reference, subscription_topic, decision)
+    def mock_full_resource_notification_bundle(submit_response, subscription_reference, subscription_topic, decision,
+                                               ig_version = 'v2.0.1')
       notification_timestamp = Time.now.utc
       mock_notification_bundle = build_mock_notification_bundle(notification_timestamp, subscription_reference,
                                                                 subscription_topic, submit_response, 'full-resource',
-                                                                decision)
+                                                                decision, ig_version)
       mock_notification_bundle.to_json
     end
 
-    def mock_response_bundle(request_bundle, operation, decision, claim_response_uuid = nil)
+    def mock_response_bundle(request_bundle, operation, decision, claim_response_uuid = nil, ig_version = 'v2.0.1')
       mocked_timestamp = Time.now.utc
-      build_mock_response_bundle(request_bundle, operation, decision, mocked_timestamp, claim_response_uuid)&.to_json
+      response = build_mock_response_bundle(request_bundle, operation, decision, mocked_timestamp,
+                                            claim_response_uuid, ig_version)
+      return nil unless response.present?
+
+      # For v2.2.1 inquire operations, wrap the Bundle in a Parameters resource
+      response = wrap_bundle_in_parameters(response) if ig_version == 'v2.2.1' && operation == 'inquire'
+
+      response.to_json
     end
 
     # update things that tester cannot get right themselves
@@ -25,20 +39,33 @@ module DaVinciPASTestKit
     # - reference to the submitted Claim (may not have control of created id). NOTE: this is likely
     #   incomplete - when the Claim is included, there are other things that
     #   need to be in the Bundle that may also not be controlled
-    def update_tester_provided_response(user_inputted_response, claim_full_url)
-      response_bundle = FHIR.from_contents(user_inputted_response)
-      return user_inputted_response unless response_bundle.present?
+    def update_tester_provided_response(user_inputted_response, claim_full_url, operation, ig_version = 'v2.0.1')
+      response_resource = FHIR.from_contents(user_inputted_response)
+      return user_inputted_response unless response_resource.present?
+
+      # For v2.2.1 inquire responses, wrap user's Bundle in Parameters if needed
+      if ig_version == 'v2.2.1' && operation == 'inquire' && response_resource.is_a?(FHIR::Bundle)
+        response_resource = wrap_bundle_in_parameters(response_resource)
+      end
+
+      # Extract Bundle(s) for updating
+      bundles_to_update = []
+      is_parameters = response_resource.resourceType == 'Parameters'
+
+      if is_parameters
+        bundles_to_update = extract_bundles_from_pas_inquiry_response_parameters(response_resource)
+      elsif response_resource.is_a?(FHIR::Bundle)
+        bundles_to_update = [response_resource]
+      else
+        return user_inputted_response
+      end
 
       now = Time.now.utc
-      response_bundle.timestamp = now.iso8601 if response_bundle&.timestamp.present?
-      claim_response_entry = response_bundle&.entry&.find { |e| e&.resource&.resourceType == 'ClaimResponse' }
-      if claim_response_entry.present?
-        claim_response_entry.resource.created = now.iso8601 if claim_response_entry.resource.created
-        if claim_response_entry.resource.request.present? && claim_full_url.present?
-          claim_response_entry.resource.request.reference = claim_full_url
-        end
+      bundles_to_update.each do |response_bundle|
+        update_response_bundle(response_bundle, claim_full_url, now, ig_version)
       end
-      response_bundle.to_json
+
+      response_resource.to_json
     end
 
     # update things that tester cannot get right themselves
@@ -94,45 +121,76 @@ module DaVinciPASTestKit
       claim_response_entry.resource.id = claim_response_id
     end
 
+    def update_response_bundle(response_bundle, claim_full_url, now, ig_version)
+      response_bundle.timestamp = now.iso8601 if response_bundle&.timestamp.present?
+      if ig_version == 'v2.2.1' && response_bundle.identifier.blank?
+        response_bundle.identifier = FHIR::Identifier.new(system: 'urn:ietf:rfc:3986',
+                                                          value: "urn:uuid:#{SecureRandom.uuid}")
+      end
+      claim_response_entry = response_bundle&.entry&.find { |e| e&.resource&.resourceType == 'ClaimResponse' }
+      return unless claim_response_entry.present?
+
+      claim_response_entry.resource.created = now.iso8601 if claim_response_entry.resource.created
+      return unless claim_full_url.present?
+
+      if claim_response_entry.resource.request.present?
+        claim_response_entry.resource.request.reference = claim_full_url
+      elsif ig_version == 'v2.2.1'
+        claim_response_entry.resource.request = FHIR::Reference.new(reference: claim_full_url)
+      end
+    end
+
     def build_mock_notification_bundle(notification_timestamp, subscription_reference, subscription_topic,
-                                       submit_response, type, decision)
-      submit_bundle = FHIR.from_contents(submit_response)
-      claim_response_full_url = claim_response_full_url_from_submit_response_bundle(submit_bundle)
+                                       submit_response, type, decision, _ig_version = 'v2.0.1')
+      submit_response_bundle = FHIR.from_contents(submit_response)
+
+      focus_reference, inner_bundle_full_url = determine_notification_focus(type, submit_response_bundle)
+
       mock_notification_bundle = FHIR::Bundle.new(
         id: SecureRandom.uuid,
         timestamp: notification_timestamp.iso8601,
         type: 'history'
       )
 
-      additional_context_references =
-        if type == 'full-resource' && submit_bundle.present? && submit_bundle.is_a?(FHIR::Bundle)
-          submit_bundle.entry.reject { |entry| entry.resource&.resourceType == 'ClaimResponse' }.map(&:fullUrl).compact
-        else
-          []
-        end
       mock_notification_status = build_mock_notification_status(notification_timestamp, subscription_reference,
-                                                                subscription_topic, claim_response_full_url,
-                                                                additional_context_references)
+                                                                subscription_topic, focus_reference, [])
       mock_notification_bundle.entry << build_mock_notification_status_entry(mock_notification_status,
                                                                              subscription_reference)
-      if type == 'full-resource' && submit_bundle.present? && submit_bundle.is_a?(FHIR::Bundle)
-        fhir_base_url = extract_fhir_base_url(subscription_reference)
-        submit_bundle.entry.each do |entry|
-          update_claim_response_decisions(entry.resource, decision) if entry.resource.resourceType == 'ClaimResponse'
-          entry.request = FHIR::Bundle::Entry::Request.new(
-            method: 'POST',
-            url: "#{fhir_base_url}/#{entry.resource.resourceType}"
-          )
-          entry.response = FHIR::Bundle::Entry::Response.new(
-            status: '201'
-          )
-          mock_notification_bundle.entry << entry
-        end
-      end
+
+      add_notification_entries(mock_notification_bundle, submit_response_bundle, type, decision,
+                               subscription_reference, inner_bundle_full_url)
 
       mock_notification_bundle
     end
 
+    def determine_notification_focus(type, submit_response_bundle)
+      if type == 'full-resource' && submit_response_bundle.is_a?(FHIR::Bundle)
+        bundle_full_url = "urn:uuid:#{submit_response_bundle.id}"
+        [bundle_full_url, bundle_full_url]
+      else
+        [claim_response_full_url_from_submit_response_bundle(submit_response_bundle), nil]
+      end
+    end
+
+    def add_notification_entries(mock_notification_bundle, submit_response_bundle, type, decision,
+                                 subscription_reference, inner_bundle_full_url)
+      return unless type == 'full-resource' && submit_response_bundle.is_a?(FHIR::Bundle)
+
+      claim_response_entry = submit_response_bundle.entry.find { |e| e.resource&.resourceType == 'ClaimResponse' }
+      if claim_response_entry.present?
+        update_claim_response_decisions(claim_response_entry.resource, decision)
+        claim_response_entry.resource.outcome = 'complete'
+      end
+
+      fhir_base_url = extract_fhir_base_url(subscription_reference)
+      mock_notification_bundle.entry << FHIR::Bundle::Entry.new(
+        fullUrl: inner_bundle_full_url,
+        resource: submit_response_bundle,
+        request: FHIR::Bundle::Entry::Request.new(method: 'POST', url: "#{fhir_base_url}/Bundle"),
+        response: FHIR::Bundle::Entry::Response.new(status: '201')
+      )
+    end
+
     def update_claim_response_decisions(claim_response, decision)
       claim_response&.item&.each do |item|
         item.adjudication.each do |adjudication|
@@ -153,15 +211,17 @@ module DaVinciPASTestKit
       end
     end
 
-    def build_mock_response_bundle(request_bundle, operation, decision, timestamp, claim_response_uuid = nil)
+    def build_mock_response_bundle(request_bundle, operation, decision, timestamp, claim_response_uuid = nil,
+                                   ig_version = 'v2.0.1')
       claim_entry = request_bundle&.entry&.find { |e| e&.resource&.resourceType == 'Claim' }
       claim_full_url = claim_entry&.fullUrl
       return nil if claim_entry.blank? || claim_full_url.blank?
 
       root_url = extract_fhir_base_url(claim_full_url)
       mocked_claim_response = build_mock_claim_response(claim_entry.resource, request_bundle, root_url, operation,
-                                                        decision, timestamp, claim_response_uuid)
-      build_mock_bundle(mocked_claim_response, request_bundle, root_url, operation, timestamp)
+                                                        decision, timestamp, ig_version, claim_response_uuid,
+                                                        claim_full_url)
+      build_mock_bundle(mocked_claim_response, request_bundle, root_url, operation, timestamp, ig_version)
     end
 
     # Note that references from the claim to other resources in the bundle need to be changed to absolute URLs
@@ -169,16 +229,16 @@ module DaVinciPASTestKit
     #
     # @private
     def build_mock_claim_response(claim, request_bundle, root_url, operation, decision, timestamp,
-                                  claim_response_uuid = nil)
+                                  ig_version = 'v2.0.1', claim_response_uuid = nil, claim_full_url = nil)
       claim_response_uuid = SecureRandom.uuid if claim_response_uuid.blank?
       return FHIR::ClaimResponse.new(id: claim_response_uuid) if claim.blank?
 
-      FHIR::ClaimResponse.new(
+      claim_response = FHIR::ClaimResponse.new(
         id: claim_response_uuid,
         meta: FHIR::Meta.new(profile: if operation == 'submit'
-                                        'http://hl7.org/fhir/us/davinci-pas/StructureDefinition/profile-claimresponse'
+                                        "http://hl7.org/fhir/us/davinci-pas/StructureDefinition/profile-claimresponse|#{ig_version.delete('v')}"
                                       else
-                                        'http://hl7.org/fhir/us/davinci-pas/StructureDefinition/profile-claiminquiryresponse'
+                                        "http://hl7.org/fhir/us/davinci-pas/StructureDefinition/profile-claiminquiryresponse|#{ig_version.delete('v')}"
                                       end),
         identifier: claim.identifier,
         type: claim.type,
@@ -188,7 +248,14 @@ module DaVinciPASTestKit
         created: timestamp.iso8601,
         insurer: absolute_reference(claim.insurer, request_bundle.entry, root_url),
         requestor: absolute_reference(claim.provider, request_bundle.entry, root_url),
-        outcome: 'complete',
+        request: claim_full_url.present? ? FHIR::Reference.new(reference: claim_full_url) : nil,
+        # v2.2.1 removed 'queued' from ClaimResponseOutcome ValueSet; pended status is
+        # conveyed via item.extension:reviewActionCode instead.
+        outcome: decision == :pended && ig_version != 'v2.2.1' ? 'queued' : 'complete',
+        preAuthPeriod: FHIR::Period.new(
+          start: timestamp.strftime('%Y-%m-%d'),
+          end: (timestamp + 1.month).strftime('%Y-%m-%d')
+        ),
         item: claim.item.map do |item|
           FHIR::ClaimResponse::Item.new(
             extension: [
@@ -230,16 +297,61 @@ module DaVinciPASTestKit
           )
         end
       )
+
+      add_modified_items(claim_response, claim) if decision == :modification
+
+      claim_response
+    end
+
+    # Pairs each modified item (already marked A6 above) with a ClaimResponse.addItem, referenced by
+    # the same itemSequence, conveying what the payer authorized (marked A1, 'Certified in total').
+    def add_modified_items(claim_response, claim)
+      claim_response.addItem = claim.item.map do |item|
+        FHIR::ClaimResponse::AddItem.new(
+          itemSequence: [item.sequence],
+          productOrService: item.productOrService,
+          adjudication: [
+            FHIR::ClaimResponse::Item::Adjudication.new(
+              extension: [
+                FHIR::Extension.new(
+                  url: 'http://hl7.org/fhir/us/davinci-pas/StructureDefinition/extension-reviewAction',
+                  extension: [
+                    FHIR::Extension.new(
+                      url: 'http://hl7.org/fhir/us/davinci-pas/StructureDefinition/extension-reviewActionCode',
+                      valueCodeableConcept: FHIR::CodeableConcept.new(
+                        coding: [
+                          get_review_action_code(:approval)
+                        ]
+                      )
+                    )
+                  ]
+                )
+              ],
+              category: FHIR::CodeableConcept.new(
+                coding: [
+                  FHIR::Coding.new(system: 'http://terminology.hl7.org/CodeSystem/adjudication', code: 'submitted')
+                ]
+              )
+            )
+          ]
+        )
+      end
     end
 
-    def build_mock_bundle(claim_response, request_bundle, root_url, operation, timestamp)
+    def build_mock_bundle(claim_response, request_bundle, root_url, operation, timestamp, ig_version = 'v2.0.1')
       response_bundle = FHIR::Bundle.new(
         id: SecureRandom.uuid,
         meta: FHIR::Meta.new(profile: if operation == 'submit'
-                                        'http://hl7.org/fhir/us/davinci-pas/StructureDefinition/profile-pas-response-bundle'
+                                        "http://hl7.org/fhir/us/davinci-pas/StructureDefinition/profile-pas-response-bundle|#{ig_version.delete('v')}"
                                       else
-                                        'http://hl7.org/fhir/us/davinci-pas/StructureDefinition/profile-pas-inquiry-response-bundle'
+                                        "http://hl7.org/fhir/us/davinci-pas/StructureDefinition/profile-pas-inquiry-response-bundle|#{ig_version.delete('v')}"
                                       end),
+        identifier: if ig_version == 'v2.2.1'
+                      FHIR::Identifier.new(
+                        system: 'urn:ietf:rfc:3986',
+                        value: "urn:uuid:#{SecureRandom.uuid}"
+                      )
+                    end,
         timestamp: timestamp.iso8601,
         type: 'collection',
         entry: [
@@ -248,6 +360,7 @@ module DaVinciPASTestKit
         ]
       )
       response_bundle.entry.concat(referenced_entities(claim_response, request_bundle.entry, root_url))
+
       response_bundle
     end
 
@@ -327,6 +440,9 @@ module DaVinciPASTestKit
       when :pended
         code = 'A4'
         display = 'Pending'
+      when :modification
+        code = 'A6'
+        display = 'Modified'
       else # approval or no workflow
         code = 'A1'
         display = 'Certified in total'
@@ -344,19 +460,23 @@ module DaVinciPASTestKit
       ref
     end
 
-    def referenced_entities(resource, entries, root_url)
-      matches = []
+    def referenced_entities(resource, entries, root_url, matches = [])
       attributes = resource&.source_hash&.keys
-      attributes.each do |attr|
+      attributes&.each do |attr|
+        if attr.to_s == 'request' && resource.respond_to?(:resourceType) && resource.resourceType == 'ClaimResponse'
+          next
+        end
+
         value = resource.send(attr.to_sym)
         if value.is_a?(FHIR::Reference) && value.reference.present?
           match = find_matching_entry(value.reference, entries, root_url)
-          if match.present? && matches.none?(match)
+          if match.present? && matches.none? { |m| m.fullUrl == match.fullUrl }
             value.reference = match.fullUrl
-            matches.concat([match], referenced_entities(match.resource, entries, root_url))
+            matches << match
+            referenced_entities(match.resource, entries, root_url, matches)
           end
-        elsif value.is_a?(Array) && value.all? { |elmt| elmt.is_a?(FHIR::Model) }
-          value.each { |val| matches.concat(referenced_entities(val, entries, root_url)) }
+        elsif value.is_a?(Array) && value.all?(FHIR::Model)
+          value.each { |val| referenced_entities(val, entries, root_url, matches) }
         end
       end
 
@@ -382,8 +502,10 @@ module DaVinciPASTestKit
       url.sub(%r{/[^/]*/[^/]*(/)?\z}, '')
     end
 
-    def claim_response_full_url_from_submit_response_bundle(submit_bundle)
-      claim_response_entry = submit_bundle&.entry&.find { |e| e&.resource&.resourceType == 'ClaimResponse' }
+    def claim_response_full_url_from_submit_response_bundle(submit_response_bundle)
+      submit_response_bundle = submit_response_bundle.parameter[0] if submit_response_bundle.is_a?(FHIR::Parameters)
+
+      claim_response_entry = submit_response_bundle&.entry&.find { |e| e&.resource&.resourceType == 'ClaimResponse' }
 
       if claim_response_entry.present?
         return claim_response_entry.fullUrl unless claim_response_entry.fullUrl.blank?
@@ -393,5 +515,19 @@ module DaVinciPASTestKit
       end
       "urn:uuid:#{SecureRandom.uuid}"
     end
+
+    # Wraps a Bundle in a Parameters resource for v2.2.1 inquire responses
+    # @param bundle [FHIR::Bundle] The Bundle to wrap
+    # @return [FHIR::Parameters] Parameters resource with the bundle as a return parameter
+    def wrap_bundle_in_parameters(bundle)
+      return nil unless bundle.is_a?(FHIR::Bundle)
+
+      parameters = FHIR::Parameters.new
+      parameters.parameter << FHIR::Parameters::Parameter.new(
+        name: 'return',
+        resource: bundle
+      )
+      parameters
+    end
   end
 end

data/lib/davinci_pas_test_kit/{session_identification.rb → client/session_identification.rb}

@@ -1,5 +1,4 @@
 require 'udap_security_test_kit'
-require_relative 'urls'
 
 module DaVinciPASTestKit
   module SessionIdentification
@@ -12,7 +11,7 @@ module DaVinciPASTestKit
       test_session_id
     end
 
-    def session_endpont_url(endpoint, client_id, session_url_path)
+    def session_endpoint_url(endpoint, client_id, session_url_path)
       path =
         if client_id.present?
           ''

data/lib/davinci_pas_test_kit/client/user_input_response.rb

@@ -0,0 +1,64 @@
+module DaVinciPASTestKit
+  module UserInputResponse
+    def self.included(klass)
+      klass.extend ClassMethods
+    end
+
+    # Reads an arbitrary input value by name from result.input_json.
+    def self.read_input(result, input_name)
+      JSON.parse(result.input_json)&.find { |i| i['name'] == input_name.to_s }&.dig('value')
+    rescue JSON::ParserError
+      nil
+    end
+
+    def self.user_inputted_response(configurable, operation, result)
+      config_key = operation == 'submit' ? :submit_respond_with : :inquire_respond_with
+      input_key = configurable.config.options[config_key]
+      return unless input_key.present?
+
+      read_input(result, input_key)
+    end
+
+    # Returns the tester-provided response candidates for the must support workflow
+    # as a list of parsed JSON hashes. The input value may be a single entry or a
+    # JSON array of entries, where each entry is either a bare FHIR Bundle or a
+    # wrapper object holding the response Bundle under "bundle" alongside optional
+    # selection "criteria".
+    # Returns nil if the input is not present, not parseable, or malformed.
+    def self.response_candidates(result, operation)
+      input_name = operation == 'submit' ? 'ms_submit_responses' : 'ms_inquire_responses'
+      input_value = JSON.parse(result.input_json)&.find { |i| i['name'] == input_name }&.dig('value')
+      return unless input_value.present?
+
+      candidates = JSON.parse(input_value)
+      candidates = [candidates] unless candidates.is_a?(Array)
+      candidates if candidates.all? { |candidate| valid_candidate?(candidate) }
+    rescue JSON::ParserError
+      nil
+    end
+
+    def self.valid_candidate?(candidate)
+      return false unless candidate.is_a?(Hash)
+
+      candidate['resourceType'] == 'Bundle' || candidate['bundle'].is_a?(Hash)
+    end
+
+    def user_inputted_response?(input_key)
+      input_key.present? && send(input_key).present?
+    end
+
+    def input_title(input_key)
+      config.inputs[input_key]&.title || config.inputs[input_key]&.name
+    end
+
+    module ClassMethods
+      def submit_respond_with(key)
+        config options: { submit_respond_with: key }
+      end
+
+      def inquire_respond_with(key)
+        config options: { inquire_respond_with: key }
+      end
+    end
+  end
+end

data/lib/davinci_pas_test_kit/{client_suite.rb → client/v2.0.1/client_suite.rb}

@@ -1,21 +1,20 @@
 require 'subscriptions_test_kit'
 require 'udap_security_test_kit'
 require 'smart_app_launch_test_kit'
-require_relative 'validator_suppressions'
-require_relative 'tags'
-require_relative 'urls'
-require_relative 'endpoints/claim_endpoint'
-require_relative 'endpoints/token_endpoint'
-require_relative 'endpoints/subscription_create_endpoint'
-require_relative 'endpoints/subscription_status_endpoint'
-require_relative 'custom_groups/v2.0.1/pas_client_options'
-require_relative 'custom_groups/v2.0.1/pas_client_workflows_group'
-require_relative 'custom_groups/v2.0.1/pas_client_must_support_group'
-require_relative 'custom_groups/v2.0.1/pas_client_subscription_setup_group'
-require_relative 'custom_groups/v2.0.1/pas_client_registration_group'
-require_relative 'custom_groups/v2.0.1/pas_client_auth_smart_group'
-require_relative 'custom_groups/v2.0.1/pas_client_auth_udap_group'
-require_relative 'descriptions'
+require_relative '../../cross_suite/validator_suppressions'
+require_relative '../../cross_suite/tags'
+require_relative '../endpoints/claim_endpoint'
+require_relative '../endpoints/token_endpoint'
+require_relative '../endpoints/subscription_create_endpoint'
+require_relative '../endpoints/subscription_status_endpoint'
+require_relative '../pas_client_options'
+require_relative 'pas_client_workflows_group'
+require_relative 'pas_client_must_support_group'
+require_relative 'pas_client_subscription_setup_group'
+require_relative 'pas_client_registration_group'
+require_relative 'pas_client_auth_smart_group'
+require_relative 'pas_client_auth_udap_group'
+require_relative '../client_input_descriptions'
 
 module DaVinciPASTestKit
   module DaVinciPASV201
@@ -34,7 +33,7 @@ module DaVinciPASTestKit
         requirements and may change the test validation logic.
 
         The best place to get started is the [Client Testing
-        Walkthrough](https://github.com/inferno-framework/davinci-pas-test-kit/wiki/Client-Walkthrough),
+        Walkthrough](https://github.com/inferno-framework/davinci-pas-test-kit/wiki/Client-Instructions-v2.0.1),
         which provides a step-by-step guide for running the tests against a client and provides
         an example client implemented in Postman.  Visit the [Client Testing
         Details](https://github.com/inferno-framework/davinci-pas-test-kit/wiki/Client-Details)
@@ -101,6 +100,10 @@ module DaVinciPASTestKit
           # We strip `<ResourceType>: <FHIRPath>: ` for the sake of matching
           SUPPRESSED_MESSAGES.match?(message.message.sub(/\A\S+: \S+: /, ''))
         end
+
+        validation_context do
+          snomedCT '731000124108'
+        end
       end
 
       suite_option :client_type,
@@ -145,6 +148,14 @@ module DaVinciPASTestKit
       suite_endpoint :get, SESSION_FHIR_SUBSCRIPTION_INSTANCE_STATUS_PATH, SubscriptionStatusEndpoint
       suite_endpoint :post, FHIR_SUBSCRIPTION_RESOURCE_STATUS_PATH, SubscriptionStatusEndpoint
       suite_endpoint :post, SESSION_FHIR_SUBSCRIPTION_RESOURCE_STATUS_PATH, SubscriptionStatusEndpoint
+      allow_cors UDAPSecurityTestKit::UDAP_DISCOVERY_PATH, SMARTAppLaunch::SMART_DISCOVERY_PATH,
+                 FHIR_METADATA_PATH, SESSION_FHIR_METADATA_PATH,
+                 UDAPSecurityTestKit::REGISTRATION_PATH, UDAPSecurityTestKit::TOKEN_PATH,
+                 SUBMIT_PATH, SESSION_SUBMIT_PATH, INQUIRE_PATH, SESSION_INQUIRE_PATH,
+                 FHIR_SUBSCRIPTION_PATH, SESSION_FHIR_SUBSCRIPTION_PATH,
+                 FHIR_SUBSCRIPTION_INSTANCE_PATH, SESSION_FHIR_SUBSCRIPTION_INSTANCE_PATH,
+                 FHIR_SUBSCRIPTION_INSTANCE_STATUS_PATH, SESSION_FHIR_SUBSCRIPTION_INSTANCE_STATUS_PATH,
+                 FHIR_SUBSCRIPTION_RESOURCE_STATUS_PATH, SESSION_FHIR_SUBSCRIPTION_RESOURCE_STATUS_PATH
 
       resume_test_route :get, RESUME_PASS_PATH do |request|
         request.query_parameters['token']
@@ -154,6 +165,12 @@ module DaVinciPASTestKit
         request.query_parameters['token']
       end
 
+      config(
+        options: {
+          ig_version: 'v2.0.1'
+        }
+      )
+
       group from: :pas_client_v201_registration
 
       # SMART test groups (with :session_url_path input removed)

data/lib/davinci_pas_test_kit/client/v2.0.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 DaVinciPASV201
+    class PASClientGatherMustSupportTest < AbstractGatherMustSupportTest
+      include URLs
+
+      id :pas_client_v201_gather_must_support
+    end
+  end
+end

data/lib/davinci_pas_test_kit/{custom_groups/v2.0.1/must_support/pas_client_must_support_requirement_test.rb → client/v2.0.1/must_support/pas_client_must_support_request_profiles_test.rb}

@@ -1,14 +1,9 @@
-require_relative '../../../must_support_test'
-require_relative '../../../generator/group_metadata'
+require_relative '../../../cross_suite/must_support/must_support_request_type_test'
 
 module DaVinciPASTestKit
   module DaVinciPASV201
-    class PasClientMustSupportRequirementTest < Inferno::Test
-      include DaVinciPASTestKit::MustSupportTest
-
-      attr_accessor :resource_type
-
-      id :pas_client_submit_v201_must_support_requirement
+    class PasClientMustSupportRequestProfilesTest < DaVinciPASTestKit::MustSupportRequestTypeTest
+      id :pas_client_v201_must_support_request_profiles
       title %(
         At least one instance of a request profile (PAS Medication Request, PAS Service Request,
         PAS Device Request, or PAS Nutrition Order) is observed with all of its must support elements
@@ -74,44 +69,15 @@ module DaVinciPASTestKit
         * NutritionOrder.patient
       )
 
-      def resource_types
-        ['DeviceRequest', 'MedicationRequest', 'NutritionOrder', 'ServiceRequest']
-      end
-
-      def self.metadata
-        metadata_file_name = "#{@@resource_type.underscore}_metadata.yml"
-        Generator::GroupMetadata.new(YAML.load_file(File.join(__dir__, metadata_file_name),
-                                                    aliases: true))
-      end
-
-      def scratch_resources
-        scratch[:submit_request_resources] ||= {}
-      end
-
-      def all_scratch_resources
-        scratch_resources[:all] ||= []
-      end
-
-      def resources_of_interest
-        collection = tagged_resources(SUBMIT_TAG).presence || all_scratch_resources
-        collection.select { |resource| resource_types.include?(resource.resourceType) }
-      end
-
-      def grouped_resources
-        resources_of_interest.group_by(&:resourceType)
-      end
-
-      run do
-        msg = 'Request Bundle must include at least one instance of either DeviceRequest, MedicationRequest,
-                NutritionOrder, or ServiceRequest resource'
-        assert resources_of_interest.present?, msg
-
-        grouped_resources.each do |type, resources|
-          @@resource_type = @resource_type = type # rubocop:disable Style/ClassVars
-          perform_must_support_test(resources)
-        end
-        validate_must_support(false)
-      end
+      config(
+        options: {
+          profile_keys: ['device_request', 'medication_request', 'nutrition_order', 'service_request'],
+          user_input_validation: false,
+          ig_version: 'v2.0.1',
+          type: 'request',
+          operation: 'submit'
+        }
+      )
     end
   end
 end

data/lib/davinci_pas_test_kit/{custom_groups → client}/v2.0.1/pas_client_approval_group.rb

@@ -1,8 +1,8 @@
-require_relative 'client_tests/pas_client_approval_submit_test'
-require_relative 'client_tests/pas_client_response_attest'
-require_relative 'client_tests/pas_client_request_bundle_validation_test'
-require_relative 'client_tests/pas_client_response_bundle_validation_test'
-require_relative '../../tags'
+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 DaVinciPASV201

data/lib/davinci_pas_test_kit/{custom_groups → client}/v2.0.1/pas_client_auth_smart_group.rb

@@ -1,6 +1,5 @@
 require 'smart_app_launch_test_kit'
-require_relative 'pas_client_options'
-require_relative '../../tags'
+require_relative '../../cross_suite/tags'
 
 module DaVinciPASTestKit
   module DaVinciPASV201