davinci_pas_test_kit 0.14.1 → 0.15.0

data/lib/davinci_pas_test_kit/server/v2.2.1/claim_updates/server_claim_update_response_tests.rb

@@ -0,0 +1,143 @@
+require_relative '../../../cross_suite/tags'
+
+module DaVinciPASTestKit
+  module DaVinciPASV221
+    # Shared helpers for the server-side Claim Update response verification tests. Inferno (acting
+    # as the client) sends a sequence of update submissions to the server under test; these helpers
+    # reload each submission by its unique tag and compare the submitted Claim's items against the
+    # ClaimResponse the server returned. No live state is used - everything is reloaded from the
+    # tagged, persisted requests/responses.
+    module ServerClaimUpdateResponseValidation
+      # The ordered Claim Update submissions, paired with the unique tag each was stored under.
+      def claim_update_response_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 most recent request stored under `tag` (it carries both the request body Inferno sent
+      # and the response body the server returned).
+      def tagged_update_request(tag)
+        load_tagged_requests(tag).last
+      end
+
+      # The Claim under submission is the first Bundle entry (a conformant update Bundle also
+      # includes the referenced prior Claim per spec-65, so select by position, not by type-order).
+      def submitted_claim(request)
+        first_resource_of_type(request&.request_body, FHIR::Claim)
+      end
+
+      # The PAS Response Bundle starts with the ClaimResponse.
+      def response_claim_response(request)
+        first_resource_of_type(request&.response_body, FHIR::ClaimResponse)
+      end
+
+      def first_resource_of_type(body, type)
+        return nil if body.blank?
+
+        bundle = FHIR.from_contents(body)
+        return nil unless bundle.is_a?(FHIR::Bundle)
+
+        first_resource = bundle.entry.first&.resource
+        return first_resource if first_resource.is_a?(type)
+
+        # Fall back to the first matching resource if the Bundle is ordered unexpectedly.
+        bundle.entry.map(&:resource).find { |resource| resource.is_a?(type) }
+      rescue StandardError
+        nil
+      end
+
+      def claim_item_sequences(claim)
+        Array(claim&.item).map(&:sequence).compact
+      end
+
+      def claim_response_item_sequences(claim_response)
+        Array(claim_response&.item).map(&:itemSequence).compact
+      end
+
+      # Collects the steps for which the server returned a ClaimResponse, attaching the submitted
+      # Claim item sequences and the returned ClaimResponse item sequences.
+      def evaluated_update_steps
+        claim_update_response_steps.filter_map do |step|
+          request = tagged_update_request(step[:tag])
+          next if request.nil?
+
+          claim = submitted_claim(request)
+          claim_response = response_claim_response(request)
+          next if claim.nil? || claim_response.nil?
+
+          step.merge(submitted_sequences: claim_item_sequences(claim),
+                     response_sequences: claim_response_item_sequences(claim_response))
+        end
+      end
+
+      # The item-bearing steps (cancel-entire-request carries no items, so item.sequence checks do
+      # not apply to it).
+      def item_bearing_update_steps
+        evaluated_update_steps.reject { |step| step[:submitted_sequences].empty? }
+      end
+    end
+
+    # spec-34
+    class PASServerClaimUpdateItemSequenceEchoTest < Inferno::Test
+      include ServerClaimUpdateResponseValidation
+
+      id :pas_server_v221_claim_update_item_sequence_echo_test
+      title 'Server echoes item.sequence values in Claim Update responses'
+      description %(
+        The PAS IG [requires](https://hl7.org/fhir/us/davinci-pas/2.2.1/en/conformancedetails.html#ci-c-spec-34)
+        that each item returned on a ClaimResponse echoes the same `item.sequence` it had on the submitted Claim.
+        This test checks each Claim Update made during this group and confirms that every item returned in the
+        server's response corresponds to an item that was submitted.
+      )
+      verifies_requirements 'hl7.fhir.us.davinci-pas_2.2.1@spec-34'
+
+      run do
+        steps = item_bearing_update_steps
+        skip_if steps.empty?,
+                'No Claim Update responses with items were returned by the server to verify.'
+
+        steps.each do |step|
+          unexpected = step[:response_sequences] - step[:submitted_sequences]
+          assert unexpected.empty?,
+                 "In the server's response to the #{step[:label]}, the ClaimResponse returned " \
+                 "item.itemSequence value(s) #{unexpected.join(', ')} that were not present on the submitted " \
+                 'Claim. Each returned item SHALL echo an item.sequence from the submitted Claim.'
+        end
+      end
+    end
+
+    # spec-46
+    class PASServerClaimUpdateCurrentResultsTest < Inferno::Test
+      include ServerClaimUpdateResponseValidation
+
+      id :pas_server_v221_claim_update_current_results_test
+      title 'Server returns current results for all submitted items in Claim Update responses'
+      description %(
+        The PAS IG [requires](https://hl7.org/fhir/us/davinci-pas/2.2.1/en/conformancedetails.html#ci-c-spec-46)
+        that a ClaimResponse includes the current results for all submitted items, including any items changed or
+        canceled since the original authorization request. This test checks each Claim Update made during this
+        group and confirms the server's response includes a result for every submitted item.
+      )
+      verifies_requirements 'hl7.fhir.us.davinci-pas_2.2.1@spec-46'
+
+      run do
+        steps = item_bearing_update_steps
+        skip_if steps.empty?,
+                'No Claim Update responses with items were returned by the server to verify.'
+
+        steps.each do |step|
+          missing = step[:submitted_sequences] - step[:response_sequences]
+          assert missing.empty?,
+                 "The server's response to the #{step[:label]} did not include results for all submitted items. " \
+                 "Missing ClaimResponse item.itemSequence value(s): #{missing.join(', ')}. The returned " \
+                 'ClaimResponse SHALL include the current results for all submitted items, including changed or ' \
+                 'canceled items.'
+        end
+      end
+    end
+  end
+end

data/lib/davinci_pas_test_kit/server/v2.2.1/error_tests/nonconformant_pas_bundle.json

@@ -0,0 +1,16 @@
+{
+  "resourceType" : "Bundle",
+  "id" : "ReferralAuthorizationBundleExample",
+  "meta" : {
+    "profile" : [
+      "http://hl7.org/fhir/us/davinci-pas/StructureDefinition/profile-pas-request-bundle"
+    ]
+  },
+  "identifier" : {
+    "system" : "http://example.org/SUBMITTER_TRANSACTION_IDENTIFIER",
+    "value" : "A12345"
+  },
+  "type" : "collection",
+  "timestamp" : "2005-05-02T11:01:00+05:00",
+  "entry" : []
+}

data/lib/davinci_pas_test_kit/server/v2.2.1/error_tests/pas_inquiry_error_test.rb

@@ -0,0 +1,38 @@
+module DaVinciPASTestKit
+  module DaVinciPASV221
+    class PasServerInquiryErrorTest < Inferno::Test
+      id :pas_server_v221_prior_auth_inquiry_error
+      title %(
+        Server returns OperationOutcome instance when invoking the $inquire operation on the Claim endpoint
+        (/Claim/$inquire) with nonconformant PAS Request Bundle
+      )
+      description %(
+        A server SHALL support PAS Inquiry requests (a POST interaction to the /Claim/$inquire endpoint).
+        This test submits a Prior Authorization Inquiry request containing an empty Bundle
+        to the server and verifies that an OperationOutcome instance is returned with request
+        status 400 when a nonconformant PAS Inquiry Bundle is submitted.
+
+        It is possible that the incoming prior authorization Bundle can not be processed due to validation errors or
+        other non-business-errors. In these instances, the receiving system SHALL return OperationOutcome instances
+        that detail why the Bundle could not be processed and no ClaimResponse will be returned. These errors are NOT
+        the errors that are detected by the system processing the request and that can be conveyed in a ClaimResponse
+        via the error capability.
+      )
+      makes_request :pa_invalid_inquiry
+
+      run do
+        file_path = File.join(File.dirname(__FILE__), 'nonconformant_pas_bundle.json')
+
+        begin
+          invalid_bundle_json = JSON.parse(File.read(file_path))
+          fhir_operation('/Claim/$inquire', body: invalid_bundle_json, name: :pa_invalid_inquiry)
+
+          assert !(200..299).include?(response[:status]), 'HTTP status code should not be within the 2xx range'
+          assert_resource_type(:operation_outcome)
+        rescue JSON::ParserError => e
+          skip "Internal error parsing the invalid bundle JSON: #{e.message}"
+        end
+      end
+    end
+  end
+end

data/lib/davinci_pas_test_kit/server/v2.2.1/error_tests/pas_submission_error_test.rb

@@ -0,0 +1,56 @@
+module DaVinciPASTestKit
+  module DaVinciPASV221
+    class PasServerSubmissionErrorTest < Inferno::Test
+      id :pas_server_v221_prior_auth_submission_error
+      title %(
+        Server returns OperationOutcome instance when invoking the $submit operation on the Claim endpoint
+        (/Claim/$submit) with nonconformant PAS Request Bundle
+      )
+      description %{
+        A server SHALL support PAS prior authorization requests (a POST interaction to the /Claim/$submit endpoint).
+        This test submits a Prior Authorization (PA) request containing an empty Bundle
+        to the server and verifies that an OperationOutcome instance is returned with request
+        status 400 when a nonconformant PAS Request Bundle is submitted.
+
+        It is possible that the incoming prior authorization Bundle can not be processed due to validation errors or
+        other non-business-errors. In these instances, the receiving system SHALL return OperationOutcome instances
+        that detail why the Bundle could not be processed and no ClaimResponse will be returned. These errors are NOT
+        the errors that are detected by the system processing the request and that can be conveyed in a ClaimResponse
+        via the error capability.
+
+        The server SHOULD respond within 15 seconds.
+      }
+
+      output :response_time
+      makes_request :pa_invalid_request
+
+      run do
+        file_path = File.join(File.dirname(__FILE__), 'nonconformant_pas_bundle.json')
+
+        begin
+          invalid_bundle_json = JSON.parse(File.read(file_path))
+          start_time = Time.now
+          fhir_operation('/Claim/$submit', body: invalid_bundle_json, name: :pa_invalid_request)
+          end_time = Time.now
+          response_time = end_time - start_time
+
+          if response_time > 15
+            warning %(
+              The server took more that 15 seconds to respond to the Prior Authorization
+              request.
+
+              Response Time: #{response_time}
+            )
+          end
+
+          assert !(200..299).include?(response[:status]), 'HTTP status code should not be within the 2xx range'
+          assert_resource_type(:operation_outcome)
+
+          output response_time:
+        rescue JSON::ParserError => e
+          skip "Internal error parsing the invalid bundle JSON: #{e.message}"
+        end
+      end
+    end
+  end
+end

data/lib/davinci_pas_test_kit/server/v2.2.1/must_support/pas_server_must_support_request_profiles_test.rb

@@ -0,0 +1,86 @@
+require_relative '../../../cross_suite/must_support/must_support_request_type_test'
+
+module DaVinciPASTestKit
+  module DaVinciPASV221
+    class PasServerMustSupportRequestProfilesTest < DaVinciPASTestKit::MustSupportRequestTypeTest
+      id :pas_server_v221_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
+      )
+      description %(
+        **USER INPUT VALIDATION**: This test validates input provided by the user instead of the system under test.
+        Errors encountered will be treated as a skip instead of a failure.
+
+        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.
+
+        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.
+
+        The test will look through the instances included in submissions for the following must
+        support elements:
+
+        ### PAS Medication Request
+        * MedicationRequest.authoredOn
+        * MedicationRequest.dispenseRequest
+        * MedicationRequest.dispenseRequest.quantity
+        * MedicationRequest.dosageInstruction
+        * MedicationRequest.dosageInstruction.text
+        * MedicationRequest.dosageInstruction.timing
+        * MedicationRequest.encounter
+        * MedicationRequest.extension:coverage
+        * MedicationRequest.intent
+        * MedicationRequest.medication[x]
+        * MedicationRequest.reported[x]
+        * MedicationRequest.requester
+        * MedicationRequest.status
+        * MedicationRequest.subject
+
+        ### PAS Service Request
+        * ServiceRequest.code
+        * ServiceRequest.extension:coverage
+        * ServiceRequest.extension:serviceCodeEnd
+        * ServiceRequest.occurrence[x]
+        * ServiceRequest.quantity[x]
+        * ServiceRequest.subject
+
+        ### PAS Device Request
+        * DeviceRequest.code[x]
+        * DeviceRequest.extension:coverage
+        * DeviceRequest.occurrence[x]
+        * DeviceRequest.subject
+
+        ### PAS Nutrition Order
+        * NutritionOrder.enteralFormula
+        * NutritionOrder.enteralFormula.baseFormulaType
+        * NutritionOrder.extension:coverage
+        * NutritionOrder.oralDiet
+        * NutritionOrder.oralDiet.type
+        * NutritionOrder.patient
+      )
+
+      config(
+        options: {
+          profile_keys: ['device_request', 'medication_request', 'nutrition_order', 'service_request'],
+          user_input_validation: true,
+          ig_version: 'v2.2.1',
+          type: 'request',
+          operation: 'submit'
+        }
+      )
+    end
+  end
+end

data/lib/davinci_pas_test_kit/server/v2.2.1/pas_error_group.rb

@@ -0,0 +1,20 @@
+require_relative 'error_tests/pas_submission_error_test'
+require_relative 'error_tests/pas_inquiry_error_test'
+
+module DaVinciPASTestKit
+  module DaVinciPASV221
+    class PASServerErrorGroup < Inferno::TestGroup
+      title 'Demonstrate Error Handling'
+      description %(
+        Validates Prior Authorization transaction error handling for malformed
+        request bundles.
+      )
+
+      id :pas_v221_error_group
+      run_as_group
+
+      test from: :pas_server_v221_prior_auth_submission_error
+      test from: :pas_server_v221_prior_auth_inquiry_error
+    end
+  end
+end

data/lib/davinci_pas_test_kit/server/v2.2.1/pas_server_claim_updates_group.rb

@@ -0,0 +1,104 @@
+require_relative '../server_request_bundle_validation_test'
+require_relative '../claim_submit_operation_test'
+require_relative '../server_response_bundle_validation_test'
+require_relative 'claim_updates/server_claim_update_response_tests'
+require_relative '../../cross_suite/tags'
+
+module DaVinciPASTestKit
+  module DaVinciPASV221
+    class PASServerClaimUpdatesGroup < Inferno::TestGroup
+      id :pas_server_v221_claim_updates
+      title 'Claim Updates'
+      description %(
+        Demonstrate the ability of the server to receive and respond to a sequence of Claim Update
+        `$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 acts as the client: for each step it validates the tester-provided request Bundle, POSTs it
+        to the server's `/Claim/$submit` endpoint, and validates that the server's response Bundle is
+        conformant. The tester provides the four request Bundles (the same Bundles used to drive the Client
+        Suite's Claim Update tests can be reused here).
+
+        After the sequence is sent, the verification tests check the server's handling of updates against 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 - that the returned ClaimResponse echoes submitted item sequences and
+        includes current results for all submitted items, including changed or canceled items.
+      )
+      run_as_group
+
+      claim_update_steps = [
+        { key: 'initial', title: 'Initial submission',
+          input: :claim_update_initial_submit_payload,
+          input_title: 'PAS $submit Payload: Initial Claim',
+          use_case: 'initial claim submission', tag: CLAIM_UPDATE_INITIAL_TAG },
+        { key: 'add_item', title: 'Update - add an item',
+          input: :claim_update_add_item_submit_payload,
+          input_title: 'PAS $submit Payload: Update Adding an Item',
+          use_case: 'add-item claim update', tag: CLAIM_UPDATE_ADD_ITEM_TAG },
+        { key: 'modify_cancel', title: 'Update - modify an item and cancel an item',
+          input: :claim_update_modify_cancel_submit_payload,
+          input_title: 'PAS $submit Payload: Update Modifying and Canceling Items',
+          use_case: 'modify-and-cancel claim update', tag: CLAIM_UPDATE_MODIFY_CANCEL_TAG },
+        { key: 'cancel_all', title: 'Update - cancel the entire request',
+          input: :claim_update_cancel_all_submit_payload,
+          input_title: 'PAS $submit Payload: Update Canceling the Entire Request',
+          use_case: 'cancel-entire-request claim update', tag: CLAIM_UPDATE_CANCEL_ALL_TAG }
+      ]
+
+      claim_update_steps.each do |step|
+        group do
+          title step[:title]
+
+          test from: :pas_server_request_bundle_validation_test do
+            id :"pas_server_v221_claim_update_request_validation_#{step[:key]}"
+            title 'Provided $submit Request Bundle is conformant'
+            description %(
+              **USER INPUT VALIDATION**: This test validates input provided by the tester instead of the
+              system under test. Errors encountered will be treated as a skip instead of a failure.
+
+              This test validates the conformity of the tester-provided Claim Update request Bundle to the
+              PAS Request Bundle profile so that subsequent tests can accurately exercise the server.
+            )
+            config(
+              inputs: { bundle_payload: { name: step[:input], title: step[:input_title] } },
+              options: { operation: 'submit', use_case: step[:use_case], ig_version: 'v2.2.1' }
+            )
+            simulation_verification
+          end
+
+          test from: :pas_claim_submit_operation_test do
+            id :"pas_server_v221_claim_update_submit_#{step[:key]}"
+            config(
+              inputs: { pa_submit_request_payload: { name: step[:input], title: step[:input_title] } },
+              options: { use_case: step[:use_case], ig_version: 'v2.2.1', request_tag: step[:tag] }
+            )
+          end
+
+          test from: :pas_server_response_bundle_validation_test do
+            id :"pas_server_v221_claim_update_response_validation_#{step[:key]}"
+            title 'Server $submit Response Bundle is conformant'
+            description %(
+              This test validates the conformity of the server's response to the Claim Update `$submit`
+              request against the PAS Response Bundle profile.
+            )
+            config(
+              options: { use_case: step[:use_case], operation: 'submit', ig_version: 'v2.2.1',
+                         request_tag: step[:tag] }
+            )
+          end
+        end
+      end
+
+      group do
+        title "Verify the server's responses to the claim updates"
+        description %(
+          These tests check the server's responses from the submission sequence and verify that the server
+          returned current results for all submitted items and echoed the submitted item sequences.
+        )
+
+        test from: :pas_server_v221_claim_update_item_sequence_echo_test
+        test from: :pas_server_v221_claim_update_current_results_test
+      end
+    end
+  end
+end

data/lib/davinci_pas_test_kit/server/v2.2.1/pas_server_subscription_input_conformance.rb

@@ -0,0 +1,48 @@
+require_relative '../../cross_suite/pas_subscription_verification'
+
+module DaVinciPASTestKit
+  module DaVinciPASV221
+    class PASServerSubscriptionInputConformance < Inferno::Test
+      include PASSubscriptionVerification
+      include SubscriptionsTestKit::SubscriptionConformanceVerification
+
+      id :pas_server_v221_subscription_input_conformance
+      title 'Verify Subscription PAS conformance'
+      description %(
+        This test accepts a Subscription resource as an input and verifies that it is conformant to PAS requirements on
+        the Subscriptions, including:
+        - The payload content type must be `full-resource`
+        - Conformance to the [PAS Subscription
+          profile](http://hl7.org/fhir/us/davinci-pas/StructureDefinition/profile-subscription)
+        - The channel type is `rest-hook`
+        - Inclusion of filter criteria for the client's organization.
+      )
+      input :subscription_resource
+      input :access_token,
+            title: 'Notification Access Token',
+            description: %(
+              An access token that the server under test will send to Inferno on notifications
+              so that the request gets associated with this test session. The token must be
+              provided as a `Bearer` token in the `Authorization` header of HTTP requests
+              sent to Inferno.
+            )
+
+      output :updated_subscription
+
+      simulation_verification
+
+      run do
+        omit_if subscription_resource.blank?, 'Did not input a Subscription resource of this type.'
+
+        assert_valid_json(subscription_resource)
+        subscription = JSON.parse(subscription_resource)
+        server_check_channel(subscription, access_token)
+
+        updated_subscription = subscription.to_json
+        output(updated_subscription:)
+
+        verify_pas_subscription(updated_subscription, ig_version: 'v2.2.1')
+      end
+    end
+  end
+end

data/lib/davinci_pas_test_kit/server/v2.2.1/pas_server_subscription_notification_wait_test.rb

@@ -0,0 +1,12 @@
+require_relative '../abstract_pas_subscription_notification_wait_test'
+require_relative 'server_urls'
+
+module DaVinciPASTestKit
+  module DaVinciPASV221
+    class PASSubscriptionNotificationWaitTest < AbstractPASSubscriptionNotificationWaitTest
+      include ServerURLs
+
+      id :pas_server_v221_subscription_notification_wait
+    end
+  end
+end

data/lib/davinci_pas_test_kit/server/v2.2.1/pas_server_subscription_setup.rb

@@ -0,0 +1,42 @@
+require 'subscriptions_test_kit'
+require_relative 'pas_server_subscription_input_conformance'
+
+module DaVinciPASTestKit
+  module DaVinciPASV221
+    class PASServerSubscriptionSetup < Inferno::TestGroup
+      id :pas_server_v221_subscription_setup
+      title 'Subscription Setup'
+      description %(
+          The Subscription Setup tests verify that the server supports creation of a rest-hook Subscription. The
+          Subscription instance created in these tests will be used for a notification in the pended workflow tests
+          later.
+        )
+      config inputs: { url: { name: :server_endpoint } }
+      input_order :server_endpoint, :smart_credentials, :access_token, :subscription_resource
+      run_as_group
+
+      test from: :pas_server_v221_subscription_input_conformance do
+        input :subscription_resource,
+              title: 'Pended Prior Authorization Subscription',
+              type: 'textarea',
+              description: %(
+                     A Subscription resource in JSON format that Inferno will send to the server under test so that it
+                     can demonstrate its ability to notify Inferno when pended prior authorization requests have been
+                     updated. The instance must be conformant to the R4/B Topic-Based Subscription profile. Inferno may
+                     modify the Subscription before submission, e.g., to point to Inferno's notification endpoint.
+                   )
+      end
+      test from: :subscriptions_r4_server_notification_delivery,
+           title: 'Send Subscription and Receive Handshake Notification from Server',
+           description: %(
+               This test sends a request to create the Subscription resource to the Subscriptions Backport FHIR Server.
+               If successful, it then waits for a handshake
+               [notification](https://hl7.org/fhir/uv/subscriptions-backport/STU1.1/notifications.html#notifications).
+               Other types of notifications, including heartbeat and event notifications, will be accepted by Inferno
+               but ignored by this test group.
+             )
+      test from: :subscriptions_r4_server_creation_response_conformance
+      test from: :subscriptions_r4_server_handshake_conformance
+    end
+  end
+end

data/lib/davinci_pas_test_kit/server/v2.2.1/server_urls.rb

@@ -0,0 +1,13 @@
+require_relative '../../cross_suite/base_urls'
+
+module DaVinciPASTestKit
+  module DaVinciPASV221
+    module ServerURLs
+      include BaseURLs
+
+      def suite_id
+        DaVinciPASTestKit::DaVinciPASV221::ServerSuite.id
+      end
+    end
+  end
+end

data/lib/davinci_pas_test_kit/version.rb

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
 module DaVinciPASTestKit
-  VERSION = '0.14.1'
-  LAST_UPDATED = '2025-06-01'
+  VERSION = '0.15.0'
+  LAST_UPDATED = '2025-07-13'
 end

data/lib/davinci_pas_test_kit.rb

@@ -1,3 +1,6 @@
+require_relative 'davinci_pas_test_kit/ext/inferno_core/runnable'
 require_relative 'davinci_pas_test_kit/metadata'
-require_relative 'davinci_pas_test_kit/client_suite'
-require_relative 'davinci_pas_test_kit/generated/v2.0.1/server_suite'
+require_relative 'davinci_pas_test_kit/client/v2.0.1/client_suite'
+require_relative 'davinci_pas_test_kit/client/v2.2.1/client_suite'
+require_relative 'davinci_pas_test_kit/server/generated/v2.0.1/server_suite'
+require_relative 'davinci_pas_test_kit/server/generated/v2.2.1/server_suite'