subscriptions_test_kit 0.12.2 → 0.13.0

data/lib/subscriptions_test_kit/suites/subscriptions_r5_backport_r4_client/common/subscription_simulation_utils.rb

@@ -7,9 +7,16 @@ module SubscriptionsTestKit
       # application/json, so we'll allow that. Disallow XML for now.
       DEFAULT_MIME_TYPE = 'application/fhir+json'
       ALLOWED_MIME_TYPES = [DEFAULT_MIME_TYPE, 'application/json'].freeze
+      JSON_PATCH_MIME_TYPE = 'application/json-patch+json'
 
       def notification_bundle_input(test_result)
-        JSON.parse(test_result.input_json).find { |i| i['name'] == 'notification_bundle' }['value']
+        input = JSON.parse(test_result.input_json).find { |i| i['name'] == 'notification_bundle' }
+        return input['value'] if input.present?
+
+        # Tests that wait after the Subscription workflow (e.g., update and delete) do not take the notification
+        # bundle as an input, so fall back to the value stored for the session.
+        Inferno::Repositories::SessionData.new.load(test_session_id: test_result.test_session_id,
+                                                    name: 'notification_bundle')
       end
 
       def client_access_token_input(test_result)
@@ -69,19 +76,63 @@ module SubscriptionsTestKit
         end
         return unless request
 
-        begin
-          if as_json
-            # needed to access primitive extensions
-            JSON.parse(request.response_body)
-          else
-            FHIR.from_contents(request.response_body)
-          end
-        rescue StandardError
-          nil
-        end
+        parse_subscription(request.response_body, as_json:)
+      end
+
+      # The created Subscription as modified by any subsequent successful updates, or nil if it has been deleted.
+      # Updates and deletes are only accepted during the update and delete interaction test (see
+      # subscription_change_allowed?), so each run of that test starts again from the created Subscription.
+      def find_current_subscription(test_session_id)
+        subscription = find_subscription(test_session_id)
+        return if subscription.nil?
+
+        # Only updates and deletes are tagged with the Subscription id, so load them together
+        delete_requests, update_requests = requests_repo.tagged_requests(test_session_id, [subscription.id])
+          .partition { |r| r.tags.include?(SUBSCRIPTION_DELETE_TAG) }
+        return if delete_requests.any? { |r| r.status.between?(200, 299) }
+
+        update_request = update_requests.reverse.find { |r| r.status == 200 }
+        return subscription unless update_request
+
+        parse_subscription(update_request.response_body)
+      end
+
+      # For endpoints: whether the waiting test accepts changes (updates and deletes) to the Subscription, which
+      # a test indicates with the accepts_subscription_changes config option
+      def subscription_change_allowed?
+        test.config.options[:accepts_subscription_changes] == true
       end
 
+      # For endpoints: reject a change to the Subscription requested while a different test is waiting
+      def reject_subscription_change
+        fhir_error_response(422, 'business-rule', %(
+          Inferno only accepts Subscription updates and deletes during the Demonstrate Subscription Update and
+          Deletion tests.
+        ).squish)
+      end
+
+      # For endpoints: respond with an error status and an OperationOutcome describing the error
+      def fhir_error_response(status, code, text = nil)
+        response.format = :json
+        response.status = status
+        response.body = operation_outcome('error', code, text).to_json
+      end
+
+      # Inferno does not act on status changes requested by the client, except to honor requests to turn
+      # the Subscription off
+      def current_subscription_status_code(subscription)
+        return 'off' if subscription.status == 'off'
+
+        determine_subscription_status_code(subscription.id)
+      end
+
+      # Memoized because the handshakes do not change while an endpoint responds to a request
       def determine_subscription_status_code(subscription_id)
+        @subscription_status_codes ||= {}
+        @subscription_status_codes[subscription_id] ||= handshake_status_code(subscription_id)
+      end
+
+      def handshake_status_code(subscription_id)
         handshakes = requests_repo.tagged_requests(test_run.test_session_id, [REST_HOOK_HANDSHAKE_NOTIFICATION_TAG])
         handshake = handshakes.filter { |h| notification_subscription_id(h.request_body) == subscription_id }.last
 
@@ -106,8 +157,51 @@ module SubscriptionsTestKit
         end
       end
 
+      # Checks that Inferno is able to simulate the requested Subscription.
+      # Returns an OperationOutcome describing the problem, or nil if the Subscription is supported.
+      def verify_subscription(subscription)
+        unless subscription.is_a? FHIR::Subscription
+          return operation_outcome('error', 'invalid', 'No recognized R4 Subscription in request body')
+        end
+
+        unless subscription.channel&.type == 'rest-hook'
+          return operation_outcome('error', 'business-rule', 'channel.type must be rest-hook')
+        end
+
+        unless valid_channel_endpoint?(subscription.channel&.endpoint)
+          return operation_outcome('error', 'value', 'channel.endpoint is not recognized as a conformant URL')
+        end
+
+        heartbeat_period = find_heartbeat_period(subscription)
+        operation_outcome('error', 'not-supported', 'heartbeatPeriod is not supported') unless heartbeat_period.nil?
+      end
+
       private
 
+      def parse_subscription(subscription_json, as_json: false)
+        if as_json
+          # needed to access primitive extensions
+          JSON.parse(subscription_json)
+        else
+          FHIR.from_contents(subscription_json)
+        end
+      rescue StandardError
+        nil
+      end
+
+      def find_heartbeat_period(subscription)
+        subscription.channel&.extension&.find do |e|
+          e.url == 'http://hl7.org/fhir/uv/subscriptions-backport/StructureDefinition/backport-heartbeat-period'
+        end
+      end
+
+      def valid_channel_endpoint?(url)
+        uri = URI.parse(url)
+        %w[http https].include?(uri.scheme)
+      rescue URI::InvalidURIError
+        false
+      end
+
       def requests_repo
         @requests_repo ||= Inferno::Repositories::Requests.new
       end

data/lib/subscriptions_test_kit/suites/subscriptions_r5_backport_r4_client/fixtures/capability_statement.json

@@ -9,6 +9,9 @@
   "format": [
     "json"
   ],
+  "patchFormat": [
+    "application/json-patch+json"
+  ],
   "software": {
     "name": "Inferno Subscriptions Test Kit Client Suite"
   },
@@ -42,6 +45,15 @@
             },
             {
               "code": "create"
+            },
+            {
+              "code": "update"
+            },
+            {
+              "code": "patch"
+            },
+            {
+              "code": "delete"
             }
           ],
           "operation": [

data/lib/subscriptions_test_kit/suites/subscriptions_r5_backport_r4_client/update_delete_workflow/conformance_verification/delete_verification_test.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+require_relative '../../common/subscription_simulation_utils'
+
+module SubscriptionsTestKit
+  module SubscriptionsR5BackportR4Client
+    class DeleteVerificationTest < Inferno::Test
+      include SubscriptionSimulationUtils
+
+      id :subscriptions_r4_client_delete_verification
+      title 'Client Subscription Delete Conformance Verification'
+      description %(
+        This test verifies that the client under test sent a conformant
+        [delete](https://hl7.org/fhir/R4/http.html#delete) request for the Subscription it created
+        in this session to Inferno's simulated FHIR server.
+      )
+
+      run do
+        subscription = find_subscription(test_session_id)
+        skip_if(subscription.nil?, 'No Subscription was created in this session')
+
+        load_tagged_requests(SUBSCRIPTION_DELETE_TAG)
+        skip_if(requests.none?, 'Inferno did not receive a Subscription delete request')
+
+        delete_request = requests.find { |r| r.tags.include?(subscription.id) }
+        assert(delete_request.present?, %(
+          Subscription delete request(s) did not target the created Subscription with id #{subscription.id}.
+          Requested URL(s): #{requests.map { |r| "`#{r.url}`" }.join(', ')}
+        ))
+      end
+    end
+  end
+end

data/lib/subscriptions_test_kit/suites/subscriptions_r5_backport_r4_client/update_delete_workflow/conformance_verification/patch_update_verification_test.rb

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+require_relative '../../../../common/subscription_conformance_verification'
+require_relative 'update_request_loading'
+
+module SubscriptionsTestKit
+  module SubscriptionsR5BackportR4Client
+    class PatchUpdateVerificationTest < Inferno::Test
+      include SubscriptionConformanceVerification
+      include UpdateRequestLoading
+
+      id :subscriptions_r4_client_patch_update_verification
+      title 'Client Subscription PATCH Update Conformance Verification'
+      description %(
+        This test verifies that the [patch](https://hl7.org/fhir/R4/http.html#patch) (`PATCH`) requests
+        that the client under test sent to Inferno for the Subscription it created during this session
+        are conformant. Specifically, that each request
+        - was a [JSON Patch](https://datatracker.ietf.org/doc/html/rfc6902) that Inferno was able to
+          apply to the Subscription, and
+        - resulted in a patched Subscription that is conformant to the [R4/B Topic-Based Subscription
+          profile](https://hl7.org/fhir/uv/subscriptions-backport/STU1.1/StructureDefinition-backport-subscription.html)
+          and meets other requirements placed on it by the IG.
+
+        Requests sent for other Subscription ids are not considered.
+
+        Inferno manages the `Subscription.status` and `Subscription.channel.payload` values itself (see the
+        *Subscription Update and Delete Interaction* test), so the values that the patch gives those elements
+        are not verified and not used by Inferno.
+
+        Inferno does not support XML Patch or FHIRPath Patch requests.
+      )
+
+      run do
+        load_update_requests('patch')
+
+        verify_update_requests do |patch_request|
+          # The response contains the Subscription with the patch applied, except for the status and
+          # payload values that Inferno manages
+          subscription_verification(patch_request.response_body)
+        end
+      end
+    end
+  end
+end

data/lib/subscriptions_test_kit/suites/subscriptions_r5_backport_r4_client/update_delete_workflow/conformance_verification/put_update_verification_test.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+require_relative '../../../../common/subscription_conformance_verification'
+require_relative 'update_request_loading'
+
+module SubscriptionsTestKit
+  module SubscriptionsR5BackportR4Client
+    class PutUpdateVerificationTest < Inferno::Test
+      include SubscriptionConformanceVerification
+      include UpdateRequestLoading
+
+      id :subscriptions_r4_client_put_update_verification
+      title 'Client Subscription PUT Update Conformance Verification'
+      description %(
+        This test verifies that the [update](https://hl7.org/fhir/R4/http.html#update) (`PUT`) requests
+        that the client under test sent to Inferno for the Subscription it created during this session
+        are conformant. Specifically, that each request
+        - was accepted by Inferno, which requires, for example, that the `id` of the Subscription in the request
+          body matches the `id` in the request URL, and
+        - contained a Subscription in the request body that is conformant to the [R4/B Topic-Based Subscription
+          profile](https://hl7.org/fhir/uv/subscriptions-backport/STU1.1/StructureDefinition-backport-subscription.html)
+          and meets other requirements placed on it by the IG.
+
+        Requests sent for other Subscription ids are not considered.
+      )
+
+      run do
+        load_update_requests('put')
+
+        verify_update_requests do |update_request|
+          subscription_verification(update_request.request_body)
+        end
+      end
+    end
+  end
+end

data/lib/subscriptions_test_kit/suites/subscriptions_r5_backport_r4_client/update_delete_workflow/conformance_verification/update_request_loading.rb

@@ -0,0 +1,61 @@
+# frozen_string_literal: true
+
+require_relative '../../common/subscription_simulation_utils'
+
+module SubscriptionsTestKit
+  module SubscriptionsR5BackportR4Client
+    module UpdateRequestLoading
+      include SubscriptionSimulationUtils
+
+      # Loads the update requests for the created Subscription that used the given HTTP method. Requests that
+      # targeted other ids are ignored. Skips if the client did not send any such requests.
+      def load_update_requests(verb)
+        subscription = find_subscription(test_session_id)
+        skip_if(subscription.nil?, 'No Subscription was created in this session')
+
+        update_requests = requests_repo.tagged_requests(test_session_id, [SUBSCRIPTION_UPDATE_TAG, subscription.id])
+        requests.concat(update_requests.select { |r| r.verb.casecmp?(verb) })
+        skip_if(requests.none?, %(
+          Inferno did not receive a #{verb.upcase} request for the created Subscription with id #{subscription.id}
+        ))
+
+        subscription
+      end
+
+      # Verifies each loaded update request, using the given block for the checks specific to the HTTP method.
+      # Every request must have been accepted by Inferno and pass those checks. Each message is prefixed with
+      # the number of the request that it is about.
+      def verify_update_requests(&)
+        requests.each.with_index(1) do |update_request, request_number|
+          verify_update_request(update_request, request_number, &)
+        end
+
+        no_error_verification("Subscription #{requests.first.verb.upcase} update request is not conformant.")
+      end
+
+      def verify_update_request(update_request, request_number)
+        first_message_index = messages.length
+        begin
+          assert(update_request.status == 200, %(
+            Inferno could not apply the request (status #{update_request.status}):
+            #{error_response_text(update_request.response_body)}
+          ))
+          yield update_request
+        rescue Inferno::Exceptions::AssertionException => e
+          add_message('error', e.message)
+        end
+
+        messages[first_message_index..].each do |message|
+          message[:message] = "Request #{request_number}: #{message[:message]}"
+        end
+      end
+
+      def error_response_text(response_body)
+        outcome = JSON.parse(response_body)
+        (outcome.dig('issue', 0, 'details', 'text') if outcome.is_a?(Hash)) || 'no details provided'
+      rescue JSON::ParserError, TypeError
+        'no details provided'
+      end
+    end
+  end
+end

data/lib/subscriptions_test_kit/suites/subscriptions_r5_backport_r4_client/update_delete_workflow/update_delete_conformance_verification_group.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+require_relative 'conformance_verification/put_update_verification_test'
+require_relative 'conformance_verification/patch_update_verification_test'
+require_relative 'conformance_verification/delete_verification_test'
+
+module SubscriptionsTestKit
+  module SubscriptionsR5BackportR4Client
+    class UpdateDeleteConformanceVerificationGroup < Inferno::TestGroup
+      id :subscriptions_r4_client_update_delete_conformance_verification
+      title 'Subscription Update and Delete Conformance Verification'
+
+      test from: :subscriptions_r4_client_put_update_verification, optional: true
+      test from: :subscriptions_r4_client_patch_update_verification, optional: true
+      test from: :subscriptions_r4_client_delete_verification, optional: true
+    end
+  end
+end

data/lib/subscriptions_test_kit/suites/subscriptions_r5_backport_r4_client/update_delete_workflow/update_delete_interaction_test.rb

@@ -0,0 +1,95 @@
+# frozen_string_literal: true
+
+require_relative '../common/subscription_simulation_utils'
+
+module SubscriptionsTestKit
+  module SubscriptionsR5BackportR4Client
+    class UpdateDeleteInteractionTest < Inferno::Test
+      include URLs
+      include SubscriptionSimulationUtils
+
+      id :subscriptions_r4_client_update_delete_interaction
+      title 'Subscription Update and Delete Interaction'
+      description %(
+        During this test, Inferno will wait while the client system changes the Subscription
+        that it created during the *Demonstrate the Rest-Hook Subscription Workflow* tests.
+        Inferno accepts the FHIR [update](https://hl7.org/fhir/R4/http.html#update),
+        [patch](https://hl7.org/fhir/R4/http.html#patch) (JSON only), and [delete](https://hl7.org/fhir/R4/http.html#delete)
+        interactions and testers can demonstrate system support for any or all of them.
+
+        Additional notes:
+        - Inferno will not send additional notifications or handshakes based on the updated Subscription.
+        - Inferno will modify the `Subscription.channel.payload` value on the updated Subscription to
+          `application/fhir+json` unless it is `application/json`.
+        - Inferno manages the `Subscription.status` value and will ignore requested changes to it, unless
+          the requested status is `off`.
+        - Inferno only accepts updates and deletes of the Subscription while this test is waiting.
+        - Each run of this test starts from the Subscription as created during the *Demonstrate the Rest-Hook
+          Subscription Workflow* tests. Changes made during earlier runs of this test, including deletion,
+          are not carried over.
+      )
+
+      input :access_token,
+            title: 'Access Token',
+            description: %(
+              The bearer token that the client under test will use when making Subscription update, delete, and other
+              requests to Inferno's simulated Subscriptions server.
+            )
+      # Inferno's Subscription update and delete endpoints only accept requests while this test is waiting
+      config options: { accepts_subscription_changes: true }
+
+      output :confirmation_url
+      output :fail_url
+      output :subscription_url
+
+      run do
+        subscription = find_subscription(test_session_id)
+        skip_if(subscription.nil?, %(
+          No Subscription was created in this session. Run the *Demonstrate the Rest-Hook Subscription Workflow*
+          tests before running these tests.
+        ))
+
+        subscription_url = "#{fhir_subscription_url}/#{subscription.id}"
+        output(subscription_url:)
+        confirmation_url = "#{resume_pass_url_client}?test_run_identifier=#{access_token}"
+        output(confirmation_url:)
+        fail_url = "#{resume_fail_url_client}?test_run_identifier=#{access_token}"
+        output(fail_url:)
+
+        wait(
+          identifier: access_token,
+          timeout: 600,
+          message: <<~MESSAGE
+            Inferno will wait while the client updates and/or deletes the Subscription created earlier
+            in the session. The Subscription is in the state it was created in: changes made during
+            earlier runs of these tests, including deletion, have not been kept. Inferno accepts the FHIR [update](https://hl7.org/fhir/R4/http.html#update),
+            [patch](https://hl7.org/fhir/R4/http.html#patch) (JSON only), and [delete](https://hl7.org/fhir/R4/http.html#delete)
+            interactions and testers can demonstrate system support for any or all of them by making
+            a request using the corresponding HTTP verb against `#{subscription_url}`:
+
+            - **PUT**: Change the Subscription with the update interaction by sending
+              a PUT request containing an updated Subscription resource in the request body.
+            - **PATCH**: Change the Subscription with a patch interaction by sending
+              a PATCH request containing a JSON Patch (`Content-Type: application/json-patch+json`)
+              in the request body
+            - **DELETE**: Remove the Subscription with a delete interaction by sending a
+              DELETE request with no body.
+
+            All requests must have the Authorization header set to:
+
+            `Bearer #{access_token}`
+
+            At any point while this test is waiting, Inferno will respond to Subscription GET and $status requests
+            for the Subscription until it has been deleted.
+
+            Once the client has demonstrated the Subscription interactions it supports,
+            [click here to complete the test](#{confirmation_url})
+
+            If at any point something has gone wrong and the client is unable to continue,
+            [click here to fail the test](#{fail_url})
+          MESSAGE
+        )
+      end
+    end
+  end
+end

data/lib/subscriptions_test_kit/suites/subscriptions_r5_backport_r4_client/update_delete_workflow_group.rb

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+require_relative 'update_delete_workflow/update_delete_interaction_test'
+require_relative 'update_delete_workflow/update_delete_conformance_verification_group'
+
+module SubscriptionsTestKit
+  module SubscriptionsR5BackportR4Client
+    class UpdateDeleteWorkflowGroup < Inferno::TestGroup
+      id :subscriptions_r4_client_update_delete_workflow
+      title 'Demonstrate Subscription Update and Deletion'
+      description %(
+        During this test, the tester will demonstrate the ability of the client
+        to update and/or delete the Subscription instance that it created
+        during the *Demonstrate the Rest-Hook Subscription Workflow* tests.
+        Those tests must be run first in the same session.
+
+        Inferno will wait for the client to send update and delete requests and
+        will then verify that the requests are conformant. Note that
+        - Update and delete requests are only accepted by Inferno while
+          this group is waiting.
+        - If this group is re-run, Inferno will forget about the previous
+          update and delete interactions sent by the Subscriptions client.
+          The Subscriptions client can interact with it as it was after
+          it was created. If the Subscriptions client cannot reactivate
+          the deleted Subscription and make updates to it again, re-run
+          the *Demonstrate the Rest-Hook Subscription Workflow* group
+          to create a new Subscription.
+      )
+      run_as_group
+      optional
+
+      group 'Subscription Update and Delete Interaction' do
+        id :subscriptions_r4_client_update_delete_workflow_interaction
+        test from: :subscriptions_r4_client_update_delete_interaction
+      end
+
+      group from: :subscriptions_r4_client_update_delete_conformance_verification
+    end
+  end
+end

data/lib/subscriptions_test_kit/suites/subscriptions_r5_backport_r4_client/workflow/conformance_verification/notification_input_verification_test.rb

@@ -14,13 +14,15 @@ module SubscriptionsTestKit
         to the [R4 Topic-Based Subscription Notification Bundle
         profile](https://hl7.org/fhir/uv/subscriptions-backport/STU1.1/StructureDefinition-backport-subscription-notification-r4.html).
         The content of the notification will be based on the Bundle provided by the tester.
+        To ensure that the subscriptions client is driving its behavior only based on
+        standard information, custom extensions are not allowed within the notifcation Bundle.
         )
       simulation_verification
 
       run do
         load_tagged_requests(REST_HOOK_EVENT_NOTIFICATION_TAG)
         skip_if(requests.none?, 'Inferno did not send an event notification')
-        notification_verification(request.request_body, 'event-notification')
+        notification_verification(request.request_body, 'event-notification', validator: :no_custom_extensions)
         no_error_verification('Notification bundle was not conformant, see error messages')
       end
     end

data/lib/subscriptions_test_kit/suites/subscriptions_r5_backport_r4_client/workflow/conformance_verification/processing_attestation_test.rb

@@ -16,6 +16,7 @@ module SubscriptionsTestKit
         of what should happen when the client receives an event notification for the requested
         Subscription.
       )
+      attestation
 
       output :attest_true_url
       output :attest_false_url

data/lib/subscriptions_test_kit/suites/subscriptions_r5_backport_r4_client_suite.rb

@@ -1,8 +1,13 @@
 # frozen_string_literal: true
 
 require_relative 'subscriptions_r5_backport_r4_client/workflow_group'
+require_relative 'subscriptions_r5_backport_r4_client/update_delete_workflow_group'
+require_relative '../fhir_validation'
 require_relative '../endpoints/subscription_create_endpoint'
 require_relative '../endpoints/subscription_read_endpoint'
+require_relative '../endpoints/subscription_update_endpoint'
+require_relative '../endpoints/subscription_patch_endpoint'
+require_relative '../endpoints/subscription_delete_endpoint'
 require_relative '../endpoints/subscription_status_endpoint'
 
 module SubscriptionsTestKit
@@ -43,10 +48,23 @@ module SubscriptionsTestKit
 
       # All FHIR validation requests will use this FHIR validator
       fhir_resource_validator do
-        igs 'hl7.fhir.uv.subscriptions-backport#1.1.0'
+        igs SUBSCRIPTIONS_BACKPORT_IG
 
         exclude_message do |message|
-          message.message.match?(/\A\S+: \S+: URL value '.*' does not resolve/)
+          message.message.match?(UNRESOLVED_URL_VALIDATION_MESSAGE)
+        end
+      end
+
+      # Used to validate tester-provided content so that it cannot rely on extensions not defined in the IG
+      fhir_resource_validator :no_custom_extensions do
+        igs SUBSCRIPTIONS_BACKPORT_IG
+
+        validation_context do
+          extensions [] # no extensions not in the spec
+        end
+
+        exclude_message do |message|
+          message.message.match?(UNRESOLVED_URL_VALIDATION_MESSAGE)
         end
       end
 
@@ -61,6 +79,9 @@ module SubscriptionsTestKit
 
       suite_endpoint :post, FHIR_SUBSCRIPTION_PATH, SubscriptionCreateEndpoint
       suite_endpoint :get, FHIR_SUBSCRIPTION_INSTANCE_PATH, SubscriptionReadEndpoint
+      suite_endpoint :put, FHIR_SUBSCRIPTION_INSTANCE_PATH, SubscriptionUpdateEndpoint
+      suite_endpoint :patch, FHIR_SUBSCRIPTION_INSTANCE_PATH, SubscriptionPatchEndpoint
+      suite_endpoint :delete, FHIR_SUBSCRIPTION_INSTANCE_PATH, SubscriptionDeleteEndpoint
       suite_endpoint :post, FHIR_SUBSCRIPTION_INSTANCE_STATUS_PATH, SubscriptionStatusEndpoint
       suite_endpoint :get, FHIR_SUBSCRIPTION_INSTANCE_STATUS_PATH, SubscriptionStatusEndpoint
       suite_endpoint :post, FHIR_SUBSCRIPTION_RESOURCE_STATUS_PATH, SubscriptionStatusEndpoint
@@ -74,6 +95,7 @@ module SubscriptionsTestKit
       end
 
       group from: :subscriptions_r4_client_workflow
+      group from: :subscriptions_r4_client_update_delete_workflow
     end
   end
 end

data/lib/subscriptions_test_kit/suites/subscriptions_r5_backport_r4_server/common/interaction/subscription_conformance_test.rb

@@ -11,7 +11,8 @@ module SubscriptionsTestKit
         This test accepts a Subscription resource as an input and verifies that it is conformant to the
         [R4/B Topic-Based Subscription profile](https://hl7.org/fhir/uv/subscriptions-backport/STU1.1/StructureDefinition-backport-subscription.html)
         and that it is constructed to make supported notifications to Inferno's simulated
-        Subscriptions client.
+        Subscriptions client. To ensure that the subscriptions server is driving its behavior only based on
+        standard information, custom extensions are not allowed within the provided Subscription.
 
         For the server to successfuly deliver notifications recognized by this test session, the Subscription `channel`
         element should have it's subelements populated with the following information:
@@ -65,7 +66,7 @@ module SubscriptionsTestKit
         updated_subscription = subscription.to_json
         output(updated_subscription:)
 
-        subscription_verification(updated_subscription)
+        subscription_verification(updated_subscription, validator: :no_custom_extensions)
         no_error_verification('Subscription resource is not conformant.')
       end
     end

data/lib/subscriptions_test_kit/suites/subscriptions_r5_backport_r4_server/common/subscription_creation.rb

@@ -63,6 +63,7 @@ module SubscriptionsTestKit
         tags = ['subscription_creation']
         payload_type = subscription_payload_type(subscription)
         tags.append(payload_type) if payload_type.present?
+        tags.append('workflow') if config.options[:workflow_subscription]
 
         fhir_operation('/Subscription', body: subscription, tags:)
         assert_response_status(201)

data/lib/subscriptions_test_kit/suites/subscriptions_r5_backport_r4_server/common/subscription_update_delete.rb

@@ -0,0 +1,43 @@
+module SubscriptionsTestKit
+  module SubscriptionsR5BackportR4Server
+    module SubscriptionUpdateDelete
+      def created_subscription_id
+        creation_requests = load_tagged_requests('subscription_creation', 'workflow').select { |r| r.status == 201 }
+        skip_if creation_requests.empty?, %(
+          No successful Subscription creation request has been made during the "Demonstrate the Subscription Workflow"
+          group. Run that group successfully before re-running this one.
+        )
+
+        JSON.parse(creation_requests.first.response_body)['id']
+      end
+
+      # Returns the raw JSON hash so that primitive extensions, such as the payload content extension on
+      # Subscription.channel.payload, are preserved
+      def read_subscription_json(subscription_id)
+        fhir_read(:subscription, subscription_id)
+        assert_response_status(200)
+        assert_valid_json(request.response_body)
+        JSON.parse(request.response_body)
+      end
+
+      # FHIR models drop primitive extensions, so send the raw JSON as the body of the update
+      def raw_subscription_resource(subscription_hash)
+        FHIR::Subscription.new(subscription_hash).tap do |resource|
+          resource.define_singleton_method(:to_json) { |*| subscription_hash.to_json }
+        end
+      end
+
+      def updated_reason(subscription, interaction)
+        "#{subscription['reason']} (updated by Inferno using #{interaction} at #{Time.now.utc.iso8601})"
+      end
+
+      def verify_reason_updated(subscription_id, expected_reason)
+        subscription = read_subscription_json(subscription_id)
+        assert(subscription['reason'] == expected_reason, %(
+          Expected the `reason` of the updated Subscription to be `#{expected_reason}`, but was
+          `#{subscription['reason']}`.
+        ))
+      end
+    end
+  end
+end