subscriptions_test_kit 0.12.1 → 0.13.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 10ffb662d80a36170cabd608e69c7a776d7aab12ed7c32e347e7b32f68d8b8dd
-  data.tar.gz: 30b825cba5b772ed7265385ee247f3a22648aa07ea1d31dfb86917f1cee1a610
+  metadata.gz: 22bedb9e7ab1b3784b17117262e36654dd9bd9d652a2ae81db58abfcd6ca8b04
+  data.tar.gz: 72a233c69e0554ef66d8031504f3cbb962cef548e8507ecc95dbdd18ee94998b
 SHA512:
-  metadata.gz: ae18d19fe351b026841bf6627195a09ad96156ddbc9fd28a36e9501a93c52a424cdba615edcd8c915f99e24572171633a3780e86936b5d4a6e82024e3d773978
-  data.tar.gz: 020a331e5cd162b763a6adeb3ebb6076828f63104faa8849b5b464ccc5c53e1a740eb73b03c35c95ff4a8bab9e319924662b32e3af02a59d6bcca83ace512f14
+  metadata.gz: 6161dbfb63aa5950300c2d3a092acef3e42dc43c9e976b11d1491da3eaaa937fcb0cafa553ac0b0f76f8d906c228f2874b0bbb4cc3bc6309d3f12df92b5c6925
+  data.tar.gz: 0f5ced8f4e1ebf1d856d391cda49f1e5a50f90bd2e6c36e621ced9f839043ca78f8c55b05bd71533271f132937f9e9ac0ebfe3aae6a3f32f08082aedeb660de1

data/lib/subscriptions_test_kit/common/notification_conformance_verification.rb

@@ -48,17 +48,19 @@ module SubscriptionsTestKit
       end
     end
 
-    def parameters_verification(subscription_status)
+    def parameters_verification(subscription_status, validator: :default)
       resource_type = subscription_status.resourceType
       if resource_type == 'Parameters'
-        resource_is_valid?(resource: subscription_status, profile_url: 'http://hl7.org/fhir/uv/subscriptions-backport/StructureDefinition/backport-subscription-status-r4')
+        resource_is_valid?(resource: subscription_status, validator:,
+                           profile_url: 'http://hl7.org/fhir/uv/subscriptions-backport/StructureDefinition/backport-subscription-status-r4')
       else
         add_message('error',
                     "Unexpected resource type: Expected `Parameters`. Got `#{resource_type}`")
       end
     end
 
-    def notification_verification(notification_bundle, notification_type, subscription_id: nil, status: nil)
+    def notification_verification(notification_bundle, notification_type, subscription_id: nil, status: nil,
+                                  validator: :default)
       assert_valid_json(notification_bundle)
       bundle = FHIR.from_contents(notification_bundle)
       assert bundle.present?, 'Not a FHIR resource'
@@ -76,7 +78,7 @@ module SubscriptionsTestKit
       check_history_bundle_request_response(bundle, subscription_status_entry, subscription_id)
 
       subscription_status = subscription_status_entry.resource
-      parameters_verification(subscription_status)
+      parameters_verification(subscription_status, validator:)
 
       return unless subscription_status.respond_to?(:parameter)
 

data/lib/subscriptions_test_kit/common/subscription_conformance_verification.rb

@@ -44,11 +44,13 @@ module SubscriptionsTestKit
       false
     end
 
-    def subscription_verification(subscription_resource)
+    def subscription_verification(subscription_resource, validator: :default)
       assert_valid_json(subscription_resource)
       subscription = JSON.parse(subscription_resource)
+      assert(subscription.is_a?(Hash), 'The Subscription must be a JSON object.')
 
       subscription_channel = subscription['channel']
+      assert(subscription_channel.is_a?(Hash), 'The Subscription must include a `channel` element.')
       assert(channel_field_matches?(subscription_channel, 'type', 'rest-hook'), %(
         The `type` element on the Subscription resource must be set to `rest-hook`,
         the `#{subscription_channel['type']}` channel type is unsupported.))
@@ -62,7 +64,7 @@ module SubscriptionsTestKit
       end
       subscription_resource = FHIR.from_contents(subscription.to_json)
       assert_resource_type('Subscription', resource: subscription_resource)
-      assert_valid_resource(resource: subscription_resource,
+      assert_valid_resource(resource: subscription_resource, validator:,
                             profile_url: 'http://hl7.org/fhir/uv/subscriptions-backport/StructureDefinition/backport-subscription')
 
       cross_version_extension_check(subscription)

data/lib/subscriptions_test_kit/docs/subscriptions_r5_backport_r4_client_suite_description.md

@@ -13,20 +13,26 @@ requirements and may change the test verification logic.
 
 ## Test Methodology
 
-For these tests Inferno simulates a Subscriptions server application. Inferno will wait for
-the client under test to request a Subscription and then will send notifications
-back to the client based on that Subscription using additional information provided by the tester.
-Using the interactions between Inferno and the client under test, Inferno will verify that
+For these tests Inferno simulates a Subscriptions server application. The client contains
+two groups:
+- *Demonstrate the Rest-Hook Subscription Workflow*, which tests the client's ability to
+  create a Subscription using the rest-hook channel and receive notifications based on it.
+- *Demonstrate Subscription Update and Deletion*, which tests the client's ability to
+  update and delete the Subscription created during the first group.
+
+During each group, Inferno will wait for the client system to make requests against Inferno.
+Inferno will react to those requests, triggering handshakes and notifications. 
+Using the interactions between Inferno and the client system, Inferno will verify that
 the client meets the obligations from the implementation guide both on individual interactions
 and in aggregate.
 
-Inferno does not implement a real data repository that recognizes resource-level changes
-and so relies on the tester to provide an event notification that Inferno will send back
-to the client under test. Inferno will manipulate this provided notification to generate other
-notifications, such as handshakes and `$status` operation responses, to send
-and respond with as directed by the IG. Inferno will verify that the provided event
-notification is conformant and that it matches the requirements for the Subscription
-sent by the client under test.
+Inferno does not implement a real data repository that recognizes resource-level changes.
+So, for the first group, Inferno relies on the tester to provide an event notification that
+Inferno will send back to the client system. Inferno will manipulate this provided
+notification to generate other notifications, such as handshakes and `$status` operation
+responses, to send and respond with as directed by the IG. Inferno will verify that the
+provided event notification is conformant and that it matches the requirements for the
+Subscription sent by the client system.
 
 The content of all Subscription interactions sent by the client, 
 as well as tester-provided notifications, will be checked 
@@ -41,7 +47,7 @@ HL7® FHIR® resources are checked for conformance using the Java validator with
 
 The following inputs must be provided by the tester at a minimum to execute
 any tests in this suite:
-1. *Access Token*: A `Bearer` token that the client under test will send in the 
+1. *Access Token*: A `Bearer` token that the client system will send in the 
    `Authorization` header of HTTP requests made against Inferno. Inferno uses the
    value to identify incoming requests that belong to the testing session.
 1. *Notification Bundle*: an `event-notification` conforming to the [R4 Topic-Based
@@ -49,7 +55,7 @@ any tests in this suite:
    Inferno uses this as the basis for responses and notifications that it will send
    to the client.
 
-All other details needed to interact with the client under test, such as where to send notifications,
+All other details needed to interact with the client system, such as where to send notifications,
 will be determined from the subscription that the client will create. Once the testing start,
 Inferno will wait for a Subscription creation request and then send the relevant handshakes
 and notification requests to the client and verify the interaction.
@@ -81,8 +87,14 @@ To run the client tests against the server tests:
 1. Wait 10-15 seconds while the client session makes requests, 
    then click the "Click here" link in the wait dialog to evaluate the notifications.
 1. Back in the client session, click the "click here to complete the test" link
-   and respond to the attestation based on the results in the server session and review
-   the results.
+   and respond to the attestation based on the results in the server session.
+1. The client session will then wait for the Subscription to be updated and deleted. The server
+   session's *Subscription Update and Deletion Verification* tests have already made these requests,
+   but they will have failed as Inferno only accepts these interactions when made during this test.
+   Return to the server session and re-run the *Subscription Update and Deletion Verification*
+   group.
+1. Once the server run has completed, return to the client session and click the "click here to
+   complete the test" link and review the results.
 
 NOTE: Inferno uses the `Bearer` token sent in the `Authorization` HTTP header 
 to associate requests with sessions. If multiple concurrent sessions are configured
@@ -99,7 +111,7 @@ that appears when initiating a test run.
 
 ### Client Notification Access Token
 
-If the client under test needs Inferno to send a specific `Bearer` token in the HTTP `Authorization` header
+If the client system needs Inferno to send a specific `Bearer` token in the HTTP `Authorization` header
 when sending notifications and it cannot be specified in the `channel.header` element of the Subscription
 instance that the client sends to Inferno, then a value can be provided here.
 
@@ -111,7 +123,7 @@ that the test kit covers and does not cover in the [Requirements
 Coverage](https://github.com/inferno-framework/subscriptions-test-kit/blob/main/lib/subscriptions_test_kit/requirements/generated/subscriptions-test-kit_requirements_coverage.csv)
 CSV document.
 
-Specific limitations to highlight include
+Specific limitations to highlight include:
 - Inferno supports only the `rest-hook` channel type. Support for other channels may be added in the future.
   If there is a channel type that you would like to see verified, please 
   [provide feedback](https://github.com/inferno-framework/subscriptions-test-kit/issues) to that effect.
@@ -123,4 +135,13 @@ Specific limitations to highlight include
   are defined within the SubscriptionTopic which is not available in FHIR R4.
 - When sending notifications, Inferno supports only JSON payloads and will always use `application/fhir+json`
   as the value of the `content-type` HTTP header, unless the client system explicitly asks for
-  `application/json` using the `Subscription.channel.payload` element.
+  `application/json` using the `Subscription.channel.payload` element.
+- Inferno supports Subscription `PATCH` requests only when they use JSON Patch. XML Patch and FHIRPath Patch
+  are not supported.
+- Inferno does not support re-creating a deleted Subscription with a `PUT` request. Once the client deletes the
+  Subscription, Inferno responds to `PUT` and `PATCH` requests for it with `404 Not Found`, and the update
+  conformance verification tests will report those requests as failures.
+- Inferno records each request it receives just after responding to it, and its simulated Subscription reflects
+  only the requests it has recorded. As a result, a request sent immediately after an update or delete, for
+  example in parallel or over a separate connection, may be answered as if that change had not happened yet.
+  If Inferno's responses appear inconsistent with earlier changes, pause briefly between requests.

data/lib/subscriptions_test_kit/docs/subscriptions_r5_backport_r4_server_suite_description.md

@@ -24,13 +24,17 @@ Over the course of a test session, Inferno may request multiple Subscriptions to
 different features of the IG, e.g., different notification content types. Because the
 choice of what topics and specific features to implement is left to individual servers,
 Inferno does not dictate specific Subscription features or topics. Instead, the
-tester will provide Subsription instances that Inferno will submit, modified lightly if needed, 
+tester will provide Subscription instances that Inferno will submit, modified lightly if needed, 
 e.g., to point to Inferno's notification endpoint, to the server
 as a part of the tests. In order for the tests to pass, the provided Subscription instances
 must themselves be conformant and consistent with the notifications subsequently sent,
 but no other requirements are placed on them, 
 except those related to Inferno limitations (see the Current Limitations section below).
 
+At the end of the session, Inferno will update the Subscription created during the Subscription
+workflow tests using `PUT` and JSON Patch `PATCH` requests and then delete it, verifying that the
+server supports these optional interactions.
+
 The content of all interactions sent by the server (responses and notifications), 
 as well as tester-provided requests, will be checked 
 for conformance to the Subscriptions IG requirements individually and used in 
@@ -91,8 +95,14 @@ To run the server tests against the client tests:
 1. Wait 10-15 seconds while the client session makes requests, 
    then click the "Click here" link in the wait dialog to evaluate the notifications.
 1. Back in the client session, click the "click here to complete the test" link
-   and respond to the attestation
-1. Meanwhile, the server tests will have completed and will be ready for review.
+   and respond to the attestation based on the results in the server session.
+1. The client session will then wait for the Subscription to be updated and deleted. The server
+   session's *Subscription Update and Deletion Verification* tests have already made these requests,
+   but they will have failed as Inferno only accepts these interactions when made during this test.
+   Return to the server session and re-run the *Subscription Update and Deletion Verification*
+   group.
+1. Once the server run has completed, return to the client session and click the "click here to
+   complete the test" link. Return to the server session to review the results.
 
 NOTE: Inferno uses the `Bearer` token sent in the `Authorization` HTTP header 
 to associate requests with sessions. If multiple concurrent sessions are configured
@@ -177,4 +187,6 @@ Specific limitations to highlight include
   header using the `Subscription.channel.payload` element. Testers may instruct
   Inferno to request that `application/json` be used instead by placing it in the
   `Subscription.channel.payload` element of the Subscription they provide for Inferno
-  to use.
+  to use.
+- When verifying Subscription modification using `PATCH`, Inferno only uses JSON Patch. XML Patch and
+  FHIRPath Patch are not tested.

data/lib/subscriptions_test_kit/endpoints/subscription_create_endpoint.rb

@@ -6,23 +6,25 @@ module SubscriptionsTestKit
   class SubscriptionCreateEndpoint < Inferno::DSL::SuiteEndpoint
     include SubscriptionsR5BackportR4Client::SubscriptionSimulationUtils
 
+    error_response_format :operation_outcome
+
     def test_run_identifier
       request.headers['authorization']&.delete_prefix('Bearer ')
     end
 
     def make_response
       response.format = :json
-      response.status = 400
 
       begin
         subscription = FHIR.from_contents(request.body.string)
       rescue StandardError
-        response.body = operation_outcome('error', 'invalid', 'No recognized R4 Subscription in request body').to_json
+        fhir_error_response(400, 'invalid', 'No recognized R4 Subscription in request body')
         return
       end
 
       verification_outcome = verify_subscription(subscription)
       if verification_outcome.present?
+        response.status = 400
         response.body = verification_outcome.to_json
         return
       end
@@ -34,7 +36,7 @@ module SubscriptionsTestKit
         subscription_hash = JSON.parse(existing_subscription_request.response_body)
         error_text = 'Inferno only supports one subscription per test run. Subscription already created with ' \
                      "ID #{subscription_hash['id']}"
-        response.body = operation_outcome('error', 'business-rule', error_text).to_json
+        fhir_error_response(400, 'business-rule', error_text)
         return
       end
 
@@ -60,35 +62,5 @@ module SubscriptionsTestKit
     def tags
       [SUBSCRIPTION_CREATE_TAG]
     end
-
-    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_url?(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
-
-    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_url?(url)
-      uri = URI.parse(url)
-      %w[http https].include?(uri.scheme)
-    rescue URI::InvalidURIError
-      false
-    end
   end
 end

data/lib/subscriptions_test_kit/endpoints/subscription_delete_endpoint.rb

@@ -0,0 +1,38 @@
+require_relative '../tags'
+require_relative '../suites/subscriptions_r5_backport_r4_client/common/subscription_simulation_utils'
+
+module SubscriptionsTestKit
+  class SubscriptionDeleteEndpoint < Inferno::DSL::SuiteEndpoint
+    include SubscriptionsR5BackportR4Client::SubscriptionSimulationUtils
+
+    error_response_format :operation_outcome
+
+    def test_run_identifier
+      request.headers['authorization']&.delete_prefix('Bearer ')
+    end
+
+    def make_response
+      unless subscription_change_allowed?
+        reject_subscription_change
+        return
+      end
+
+      subscription_id = request.params[:id]
+      subscription = find_subscription(test_run.test_session_id)
+
+      if subscription.present? && subscription.id == subscription_id
+        # Deleting an already deleted resource has no effect, so respond the same way
+        response.status = 204
+      else
+        fhir_error_response(404, 'not-found', "No subscription exists with ID #{subscription_id}")
+      end
+    end
+
+    # Rejected changes are left untagged so that they are not treated as part of the update and delete tests
+    def tags
+      return [] unless subscription_change_allowed?
+
+      [SUBSCRIPTION_DELETE_TAG, request.params[:id]]
+    end
+  end
+end

data/lib/subscriptions_test_kit/endpoints/subscription_patch_endpoint.rb

@@ -0,0 +1,69 @@
+require 'hana'
+require_relative 'subscription_update_endpoint'
+
+module SubscriptionsTestKit
+  # Supports updates via JSON Patch (https://hl7.org/fhir/R4/http.html#patch). Other patch formats
+  # (XML Patch and FHIRPath Patch) are not supported.
+  class SubscriptionPatchEndpoint < SubscriptionUpdateEndpoint
+    # Not inherited from SubscriptionUpdateEndpoint, so it must be declared here as well
+    error_response_format :operation_outcome
+
+    def requested_subscription_hash(current_subscription)
+      # Media types are case-insensitive
+      unless request.content_type&.downcase&.start_with?(JSON_PATCH_MIME_TYPE)
+        fhir_error_response(415, 'not-supported',
+                            "Inferno only supports JSON Patch requests with Content-Type '#{JSON_PATCH_MIME_TYPE}'")
+        return
+      end
+
+      patch = parse_json_patch(request.body.string)
+      if patch.nil?
+        fhir_error_response(400, 'invalid', 'Request body is not a valid JSON Patch document')
+        return
+      end
+
+      # Apply the patch to the Subscription as the client would see it on a read
+      current_status = current_subscription_status_code(current_subscription)
+      current_hash = current_subscription.source_hash.deep_dup.merge('status' => current_status)
+      apply_json_patch(patch, current_hash)
+    end
+
+    # The Subscription hash with the patch applied, or nil if an error response has been set
+    def apply_json_patch(patch, subscription_hash)
+      patched_hash = Hana::Patch.new(patch).apply(subscription_hash)
+      return patched_hash if patched_hash.is_a?(Hash)
+
+      fhir_error_response(422, 'processing', 'Applying the JSON Patch did not produce a JSON object')
+      nil
+    # Besides its own exceptions, Hana raises plain Ruby errors for some patches it cannot apply, e.g., an
+    # IndexError for a copy from a missing array index or a TypeError for a path through a number
+    rescue StandardError => e
+      fhir_error_response(422, 'processing', "Unable to apply JSON Patch: #{e.message}")
+      nil
+    end
+
+    def parse_json_patch(body)
+      patch = JSON.parse(body)
+      return unless patch.is_a?(Array) && patch.all? { |operation| valid_json_patch_operation?(operation) }
+
+      patch
+    rescue JSON::ParserError
+      nil
+    end
+
+    # Checks the members each operation requires (https://datatracker.ietf.org/doc/html/rfc6902#section-4)
+    # so that malformed operations are rejected here rather than raising non-patch errors when applied
+    def valid_json_patch_operation?(operation)
+      return false unless operation.is_a?(Hash) && operation['path'].is_a?(String)
+
+      case operation['op']
+      when 'add', 'replace', 'test'
+        operation.key?('value')
+      when 'move', 'copy'
+        operation['from'].is_a?(String)
+      else
+        operation['op'] == 'remove'
+      end
+    end
+  end
+end

data/lib/subscriptions_test_kit/endpoints/subscription_read_endpoint.rb

@@ -5,6 +5,8 @@ module SubscriptionsTestKit
   class SubscriptionReadEndpoint < Inferno::DSL::SuiteEndpoint
     include SubscriptionsR5BackportR4Client::SubscriptionSimulationUtils
 
+    error_response_format :operation_outcome
+
     def test_run_identifier
       request.headers['authorization']&.delete_prefix('Bearer ')
     end
@@ -13,15 +15,13 @@ module SubscriptionsTestKit
       response.format = :json
       subscription_id = request.params[:id]
 
-      subscription = find_subscription(test_run.test_session_id)
+      subscription = find_current_subscription(test_run.test_session_id)
 
       if subscription.present? && subscription.id == subscription_id
-        status_code = determine_subscription_status_code(subscription_id)
+        status_code = current_subscription_status_code(subscription)
         response.body = subscription.source_hash.merge('status' => status_code).to_json
       else
-        response.status = 404
-        response.body = operation_outcome('error', 'not-found',
-                                          "No subscription exists with ID #{subscription_id}").to_json
+        fhir_error_response(404, 'not-found', "No subscription exists with ID #{subscription_id}")
       end
     end
 

data/lib/subscriptions_test_kit/endpoints/subscription_status_endpoint.rb

@@ -5,33 +5,35 @@ module SubscriptionsTestKit
   class SubscriptionStatusEndpoint < Inferno::DSL::SuiteEndpoint
     include SubscriptionsR5BackportR4Client::SubscriptionSimulationUtils
 
+    error_response_format :operation_outcome
+
     def test_run_identifier
       request.headers['authorization']&.delete_prefix('Bearer ')
     end
 
     def make_response
       response.format = :json
-      subscription = find_subscription(test_run.test_session_id)
+      subscription = find_current_subscription(test_run.test_session_id)
 
-      unless subscription.present?
-        not_found
+      subscription_id = request.params[:id]
+      if subscription.blank? || (subscription_id.present? && subscription_id != subscription.id)
+        fhir_error_response(404, 'not-found')
         return
       end
 
-      subscription_id = request.params[:id]
+      status_code = current_subscription_status_code(subscription)
 
       # Handle resource-level status params
       unless subscription_id.present?
         begin
           params = FHIR.from_contents(request.body.string)
         rescue StandardError
-          response.status = 400
-          response.body = operation_outcome('error', 'invalid', 'Invalid Parameters in request body').to_json
+          fhir_error_response(400, 'invalid', 'Invalid Parameters in request body')
           return
         end
 
-        unless subscription_params_match?(params, subscription)
-          not_found
+        unless subscription_params_match?(params, subscription, status_code)
+          fhir_error_response(404, 'not-found')
           return
         end
       end
@@ -39,32 +41,25 @@ module SubscriptionsTestKit
       notification_json = notification_bundle_input(result)
       subscription_url = "#{base_subscription_url}/#{subscription.id}"
       subscription_topic = subscription.criteria
-      status_code = determine_subscription_status_code(subscription_id)
       event_count = determine_event_count(test_run.test_session_id)
       response.status = 200
       response.body = derive_status_bundle(notification_json, subscription_url, subscription_topic, status_code,
                                            event_count, request.url).to_json
     end
 
-    def subscription_params_match?(params, subscription)
+    def subscription_params_match?(params, subscription, status_code)
       id_params = find_params(params, 'id')
 
       return false if id_params&.any? && id_params&.none? { |p| p.valueString == subscription.id }
 
       status_params = find_params(params, 'status')
-      subscription_status = determine_subscription_status_code(subscription.id)
-      status_params.blank? || status_params.any? { |p| p.valueString == subscription_status }
+      status_params.blank? || status_params.any? { |p| p.valueString == status_code }
     end
 
     def tags
       [SUBSCRIPTION_STATUS_TAG]
     end
 
-    def not_found
-      response.status = 404
-      response.body = operation_outcome('error', 'not-found').to_json
-    end
-
     def find_params(params, name)
       params&.parameter&.filter { |p| p.name == name }
     end

data/lib/subscriptions_test_kit/endpoints/subscription_update_endpoint.rb

@@ -0,0 +1,81 @@
+require_relative '../tags'
+require_relative '../suites/subscriptions_r5_backport_r4_client/common/subscription_simulation_utils'
+
+module SubscriptionsTestKit
+  class SubscriptionUpdateEndpoint < Inferno::DSL::SuiteEndpoint
+    include SubscriptionsR5BackportR4Client::SubscriptionSimulationUtils
+
+    error_response_format :operation_outcome
+
+    def test_run_identifier
+      request.headers['authorization']&.delete_prefix('Bearer ')
+    end
+
+    def make_response
+      if subscription_change_allowed?
+        update_subscription
+      else
+        reject_subscription_change
+      end
+    end
+
+    def update_subscription
+      response.format = :json
+      subscription_id = request.params[:id]
+
+      current_subscription = find_current_subscription(test_run.test_session_id)
+      unless current_subscription.present? && current_subscription.id == subscription_id
+        fhir_error_response(404, 'not-found', "No subscription exists with ID #{subscription_id}")
+        return
+      end
+
+      # We have to manipulate the raw hash so that we don't lose the _payload primitive extension
+      subscription_hash = requested_subscription_hash(current_subscription)
+      return if subscription_hash.nil?
+
+      begin
+        subscription = FHIR.from_contents(subscription_hash.to_json)
+      rescue StandardError
+        subscription = nil
+      end
+
+      verification_outcome = verify_subscription(subscription)
+      if verification_outcome.present?
+        response.status = 400
+        response.body = verification_outcome.to_json
+        return
+      end
+
+      unless subscription.id == subscription_id
+        fhir_error_response(400, 'invalid', "Updated Subscription id '#{subscription.id}' does not match the id " \
+                                            "'#{subscription_id}' in the request URL")
+        return
+      end
+
+      subscription_hash['status'] = current_subscription_status_code(subscription)
+      subscription_hash['channel']['payload'] = actual_mime_type(subscription)
+      response.status = 200
+      response.body = subscription_hash.to_json
+    end
+
+    # The requested state of the Subscription as a raw hash, or nil if an error response has been set
+    def requested_subscription_hash(_current_subscription)
+      subscription_hash = begin
+        JSON.parse(request.body.string)
+      rescue JSON::ParserError
+        nil
+      end
+      return subscription_hash if subscription_hash.is_a?(Hash)
+
+      fhir_error_response(400, 'invalid', 'No recognized R4 Subscription in request body')
+      nil
+    end
+
+    # Rejected changes are left untagged so that they are not treated as part of the update and delete tests
+    def tags
+      return [] unless subscription_change_allowed?
+
+      [SUBSCRIPTION_UPDATE_TAG, request.params[:id]]
+    end
+  end
+end

data/lib/subscriptions_test_kit/fhir_validation.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+module SubscriptionsTestKit
+  # Values shared by the FHIR validators that the client and server suites define
+  # Validator definitions kept in the suites rather than pulled out into this module
+  # to keep them local to the suites even though identical.
+  SUBSCRIPTIONS_BACKPORT_IG = 'hl7.fhir.uv.subscriptions-backport#1.1.0'
+  UNRESOLVED_URL_VALIDATION_MESSAGE = /\A\S+: \S+: URL value '.*' does not resolve/
+end

data/lib/subscriptions_test_kit/requirements/generated/subscriptions_r5_backport_r4_server_requirements_coverage.csv

@@ -103,8 +103,8 @@ hl7.fhir.uv.subscriptions_1.1.0,122,https://hl7.org/fhir/uv/subscriptions-backpo
 hl7.fhir.uv.subscriptions_1.1.0,123,https://hl7.org/fhir/uv/subscriptions-backport/STU1.1/CapabilityStatement-backport-subscription-server-r4.html#summary,MAY support the $get-ws-binding-token operation,MAY,Server,,Not Tested,Used for Websocket channels that Inferno does not currently support,NA,NA
 hl7.fhir.uv.subscriptions_1.1.0,124,https://hl7.org/fhir/uv/subscriptions-backport/STU1.1/CapabilityStatement-backport-subscription-server-r4.html#summary,A Server SHALL be capable of returning a Subscription resource using: GET [base]/Subscription/[id],SHALL,Server,,,,"",""
 hl7.fhir.uv.subscriptions_1.1.0,125,https://hl7.org/fhir/uv/subscriptions-backport/STU1.1/CapabilityStatement-backport-subscription-server-r4.html#summary,A Server SHOULD be capable of creating a Subscription resource using either: POST [base]/Subscription or PUT [base]/Subscription/[id],SHOULD,Server,,,,"",""
-hl7.fhir.uv.subscriptions_1.1.0,126,https://hl7.org/fhir/uv/subscriptions-backport/STU1.1/CapabilityStatement-backport-subscription-server-r4.html#summary,A Server SHOULD be capable of modifying a Subscription resource using either: PUT [base]/Subscription/[id] or PATCH [base]/Subscription/[id],SHOULD,Server,,,,"",""
-hl7.fhir.uv.subscriptions_1.1.0,127,https://hl7.org/fhir/uv/subscriptions-backport/STU1.1/CapabilityStatement-backport-subscription-server-r4.html#summary,A Server SHOULD be capable of deleting a Subscription resource using: DELETE [base]/Subscription/[id],SHOULD,Server,,,,"",""
+hl7.fhir.uv.subscriptions_1.1.0,126,https://hl7.org/fhir/uv/subscriptions-backport/STU1.1/CapabilityStatement-backport-subscription-server-r4.html#summary,A Server SHOULD be capable of modifying a Subscription resource using either: PUT [base]/Subscription/[id] or PATCH [base]/Subscription/[id],SHOULD,Server,,,,"7.01, 7.02","subscriptions_r5_backport_r4_server-subscriptions_r4_server_update_delete-subscriptions_r4_server_update_put, subscriptions_r5_backport_r4_server-subscriptions_r4_server_update_delete-subscriptions_r4_server_update_patch"
+hl7.fhir.uv.subscriptions_1.1.0,127,https://hl7.org/fhir/uv/subscriptions-backport/STU1.1/CapabilityStatement-backport-subscription-server-r4.html#summary,A Server SHOULD be capable of deleting a Subscription resource using: DELETE [base]/Subscription/[id],SHOULD,Server,,,,7.03,subscriptions_r5_backport_r4_server-subscriptions_r4_server_update_delete-subscriptions_r4_server_delete
 hl7.fhir.uv.subscriptions_1.1.0,128,https://hl7.org/fhir/uv/subscriptions-backport/STU1.1/CapabilityStatement-backport-subscription-server-r4.html#summary,A Server [MAY] be capable of searching for Subscription resources using: GET [base]/Subscription/?[parameters],MAY,Server,,,,"",""
 hl7.fhir.uv.subscriptions_1.1.0,129,https://hl7.org/fhir/uv/subscriptions-backport/STU1.1/CapabilityStatement-backport-subscription-server-r4.html#summary,Search Parameter Summary: SHALL [support] url,SHALL,Server,,,,"",""
 hl7.fhir.uv.subscriptions_1.1.0,130,https://hl7.org/fhir/uv/subscriptions-backport/STU1.1/CapabilityStatement-backport-subscription-server-r4.html#summary,Search Parameter Summary: SHOULD [support] status,SHOULD,Server,,,,"",""