subscriptions_test_kit 0.9.0

data/lib/subscriptions_test_kit/docs/samples/Subscription_empty.json

@@ -0,0 +1,37 @@
+
+{
+    "resourceType" : "Subscription",
+    "meta" : {
+      "profile" : ["http://hl7.org/fhir/uv/subscriptions-backport/StructureDefinition/backport-subscription"]
+    },
+    "status" : "requested",
+    "end" : "2020-12-31T12:00:00Z",
+    "reason" : "R4 Topic-Based Workflow Subscription for Patient Admission",
+    "criteria" : "http://inferno.healthit.gov/suites/custom/subscriptions_r5_backport_r4_client/topics/patient-admission",
+    "_criteria" : {
+      "extension" : [{
+        "url" : "http://hl7.org/fhir/uv/subscriptions-backport/StructureDefinition/backport-filter-criteria",
+        "valueString" : "Encounter?patient=Patient/123"
+      }]
+    },
+    "channel" : {
+      "extension" : [{
+        "url" : "http://hl7.org/fhir/uv/subscriptions-backport/StructureDefinition/backport-timeout",
+        "valueUnsignedInt" : 60
+      },
+      {
+        "url" : "http://hl7.org/fhir/uv/subscriptions-backport/StructureDefinition/backport-max-count",
+        "valuePositiveInt" : 20
+      }],
+      "type" : "rest-hook",
+      "header": ["Authorization: Bearer SAMPLE_TOKEN"],
+      "endpoint" : "http://inferno.healthit.gov/suites/custom/subscriptions_r5_backport_r4_server/subscription/channel/notification_listener",
+      "payload" : "application/json",
+      "_payload" : {
+        "extension" : [{
+          "url" : "http://hl7.org/fhir/uv/subscriptions-backport/StructureDefinition/backport-payload-content",
+          "valueCode" : "empty"
+        }]
+      }
+    }
+  }

data/lib/subscriptions_test_kit/docs/samples/Subscription_full-resource.json

@@ -0,0 +1,37 @@
+
+{
+    "resourceType" : "Subscription",
+    "meta" : {
+      "profile" : ["http://hl7.org/fhir/uv/subscriptions-backport/StructureDefinition/backport-subscription"]
+    },
+    "status" : "requested",
+    "end" : "2020-12-31T12:00:00Z",
+    "reason" : "R4 Topic-Based Workflow Subscription for Patient Admission",
+    "criteria" : "http://inferno.healthit.gov/suites/custom/subscriptions_r5_backport_r4_client/topics/patient-admission",
+    "_criteria" : {
+      "extension" : [{
+        "url" : "http://hl7.org/fhir/uv/subscriptions-backport/StructureDefinition/backport-filter-criteria",
+        "valueString" : "Encounter?patient=Patient/123"
+      }]
+    },
+    "channel" : {
+      "extension" : [{
+        "url" : "http://hl7.org/fhir/uv/subscriptions-backport/StructureDefinition/backport-timeout",
+        "valueUnsignedInt" : 60
+      },
+      {
+        "url" : "http://hl7.org/fhir/uv/subscriptions-backport/StructureDefinition/backport-max-count",
+        "valuePositiveInt" : 20
+      }],
+      "type" : "rest-hook",
+      "header": ["Authorization: Bearer SAMPLE_TOKEN"],
+      "endpoint" : "http://inferno.healthit.gov/suites/custom/subscriptions_r5_backport_r4_server/subscription/channel/notification_listener",
+      "payload" : "application/json",
+      "_payload" : {
+        "extension" : [{
+          "url" : "http://hl7.org/fhir/uv/subscriptions-backport/StructureDefinition/backport-payload-content",
+          "valueCode" : "full-resource"
+        }]
+      }
+    }
+  }

data/lib/subscriptions_test_kit/docs/samples/Subscription_id-only.json

@@ -0,0 +1,38 @@
+
+
+{
+    "resourceType" : "Subscription",
+    "meta" : {
+      "profile" : ["http://hl7.org/fhir/uv/subscriptions-backport/StructureDefinition/backport-subscription"]
+    },
+    "status" : "requested",
+    "end" : "2020-12-31T12:00:00Z",
+    "reason" : "R4 Topic-Based Workflow Subscription for Patient Admission",
+    "criteria" : "http://inferno.healthit.gov/suites/custom/subscriptions_r5_backport_r4_client/topics/patient-admission",
+    "_criteria" : {
+      "extension" : [{
+        "url" : "http://hl7.org/fhir/uv/subscriptions-backport/StructureDefinition/backport-filter-criteria",
+        "valueString" : "Encounter?patient=Patient/123"
+      }]
+    },
+    "channel" : {
+      "extension" : [{
+        "url" : "http://hl7.org/fhir/uv/subscriptions-backport/StructureDefinition/backport-timeout",
+        "valueUnsignedInt" : 60
+      },
+      {
+        "url" : "http://hl7.org/fhir/uv/subscriptions-backport/StructureDefinition/backport-max-count",
+        "valuePositiveInt" : 20
+      }],
+      "type" : "rest-hook",
+      "header": ["Authorization: Bearer SAMPLE_TOKEN"],
+      "endpoint" : "http://inferno.healthit.gov/suites/custom/subscriptions_r5_backport_r4_server/subscription/channel/notification_listener",
+      "payload" : "application/json",
+      "_payload" : {
+        "extension" : [{
+          "url" : "http://hl7.org/fhir/uv/subscriptions-backport/StructureDefinition/backport-payload-content",
+          "valueCode" : "id-only"
+        }]
+      }
+    }
+  }

data/lib/subscriptions_test_kit/docs/subscriptions_r5_backport_r4_client_suite_description.md

@@ -0,0 +1,120 @@
+The Subscriptions R5 Backport IG v1.1.0 FHIR R4 Client Test Suite 
+verifies the conformance of
+client systems to the STU 1.1.0 version of the HL7® FHIR®
+[Subscriptions R5 Backport IG](https://hl7.org/fhir/uv/subscriptions-backport/STU1.1/).
+
+## Scope
+
+These tests are a **DRAFT** intended to allow implementers to perform
+preliminary checks of their systems against Subscriptions capabilities backported
+from FHIR R5 to R4 and [provide feedback](https://github.com/inferno-framework/subscriptions-test-kit/issues)
+on the tests. Future versions of these tests may verify other
+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
+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.
+
+The content of all Subscription interactions sent by the client, 
+as well as tester-provided notifications, will be checked 
+for conformance to the Subscriptions IG requirements individually and used in 
+aggregate to determine whether required features and functionality are present. 
+HL7® FHIR® resources are checked for conformance using the Java validator with 
+`tx.fhir.org` as the terminology server.
+
+## Running the Tests
+
+### Quick Start
+
+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 
+   `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
+   Subscription Notification Bundle profile](https://hl7.org/fhir/uv/subscriptions-backport/STU1.1/StructureDefinition-backport-subscription-notification-r4.html).
+   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,
+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.
+
+Additional inputs described in the *Additional Configuration Details* section below can enable
+verification of additional content types and some Subscription creation error scenarios.
+
+### Sample Execution
+
+To try out these tests without a Subscriptions client implementation or performing steps to
+create a Subscription, run them against the Subscriptions server test suite included
+in this test kit. Related presets contain example Subscriptions and event notifications that
+the test kits can use to interact. The server test suite can simulate
+a subscriptions client creating a `rest-hook` Subscription responding to appropriate handshakes
+and notifications.
+
+To run the client tests against the server tests:
+1. Start an Inferno session of the Subscriptions Client test suite.
+1. Select one of the *Inferno Subscription R4 Client [content type] Preset* from the Preset dropdown in the
+   upper left.
+1. Click the "Run All Tests" button in the upper right and click the "Submit" button in the dialog
+   that appears. The simulated server will then be waiting for an interaction.
+1. Start an Inferno session of the Subscriptions Server test suite.
+1. Select the *[content type] Notifications Against The Subscriptions Client Suite* corresponding
+   to the content type selected in the client test from the Preset dropdown in the upper left.
+1. Click the "Run All Tests" button in the upper right and click the "Submit" button in the
+   dialog that appears. The server tests make a Subscription request will and indicate that
+   it is waiting for notifications to be made.
+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.
+
+NOTE: Inferno uses the `Bearer` token sent in the `Authorization` HTTP header 
+to associate requests with sessions. If multiple concurrent sessions are configured
+to use the same token, they may interfere with each other. To prevent concurrent executors
+of these sample executions from disrupting your session it
+is recommended, but not required, to change all instances of `SAMPLE_TOKEN` in the
+Inferno inputs for both client server suites (including within the Subscription instance body), 
+to the same unique value so that the session will not interact with other concurrent users.
+
+## Additional Configuration Details
+
+The details provided here supplement the documentation of individual fields in the input dialog
+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
+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.
+
+## Current Limitations
+
+This test kit is still in draft form and does not test all of the requirements and features
+described in the Subscriptions IG. You can find information on the requirements
+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
+- 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.
+- Inferno does not test delivery error handling and recovery scenarios, including
+  the optional `$events` API and event numbering details.
+- Inferno does not support sending heartbeat notifications.

data/lib/subscriptions_test_kit/docs/subscriptions_r5_backport_r4_server_suite_description.md

@@ -0,0 +1,170 @@
+The Subscriptions R5 Backport IG v1.1.0 FHIR R4 Server Test Suite 
+verifies the conformance of
+server systems to the STU 1.1.0 version of the HL7® FHIR®
+[Subscriptions R5 Backport IG](https://hl7.org/fhir/uv/subscriptions-backport/STU1.1/).
+
+## Scope
+
+These tests are a **DRAFT** intended to allow implementers to perform
+preliminary checks of their systems against Subscriptions capabilities backported
+from FHIR R5 to R4 and [provide feedback](https://github.com/inferno-framework/subscriptions-test-kit/issues)
+on the tests. Future versions of these tests may verify other
+requirements and may change the test verification logic.
+
+## Test Methodology
+
+For these tests Inferno simulates a Subscriptions client application. Inferno will subscribe
+to certain updates on the server under test and wait for one or more notifications
+indicating changes meeting those criteria. Using the interactions between Inferno and
+the server under test, Inferno will verify that the server under test meets
+the obligations from the implementation guide both on individual interactions
+and in aggregate.
+
+Over the course of a test session, Inferno may request multiple Subscriptions to verify
+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, 
+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).
+
+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 
+aggregate to determine whether required features and functionality are present. 
+HL7® FHIR® resources are checked for conformance using the Java validator with 
+`tx.fhir.org` as the terminology server.
+
+## Running the Tests
+
+### Quick Start
+
+The following inputs must be provided by the tester at a minimum to execute
+any tests in this suite:
+1. *FHIR Server Base URL*: The server's FHIR base URL. Inferno will use this when 
+   performing Subscription creation requests and other interactions against the server
+   under test.
+1. *OAuth Credentials*: Auth credentials for Inferno to use when making requests against the 
+   server under test. Specifically, Inferno will provide the *Access Token* input as a `Bearer`
+   token in the `Authorization` header of HTTP requests. This input is not required if the server
+   does not require authorization.
+1. *Notification Access Token*: An access token that the server will send
+   as a `Bearer` token in the `Authorization` header of HTTP notifications requests sent to Inferno. 
+   Inferno uses the value to identify incoming requests that belong to the testing session.
+1. *Workflow Subscription Resource*: A Subscription instance for Inferno to create on the server.
+   Inferno will adjust it to be use the `rest-hook` channel and point to its notification endpoint.
+   It must be conformant to the [R4/B Topic-Based Subscription profile](https://hl7.org/fhir/uv/subscriptions-backport/STU1.1/StructureDefinition-backport-subscription.html). 
+
+Using these inputs, Inferno will perform a Subscription interaction loop with the server under test:
+creating a Subscription, waiting for notifications, and then verifying the interactions. The tester will
+be responsible for monitoring their system for the new Subscription from Inferno and performing
+an action in their system that triggers an event notification to be sent to Inferno based on
+that Subscription.
+
+Additional inputs described in the *Additional Configuration Details* section below can enable
+verification of additional content types and some Subscription creation error scenarios.
+
+### Sample Execution
+
+To try out these tests without a Subscriptions server implementation or performing steps to
+generate an event notification, run them against the Subscriptions client test suite included
+in this test kit. Related presets contain example Subscriptions and event notifications that
+the test kits can use to interact. The client test suite can run a loop to simulate
+a subscriptions server using the `rest-hook` channel type including responding to a
+Subscription creation request and sending appropriate handshakes and notifications.
+
+To run the server tests against the client tests:
+1. Start an Inferno session of the Subscriptions Client test suite.
+1. Select one of the *Inferno Subscription R4 Client [content type] Preset* from the Preset dropdown in the
+   upper left.
+1. Click the "Run All Tests" button in the upper right and click the "Submit" button in the dialog
+   that appears. The simulated server will then be waiting for an interaction.
+1. Start an Inferno session of the Subscriptions Server test suite.
+1. Select the *[content type] Notifications Against The Subscriptions Client Suite* corresponding
+   to the content type selected in the client test from the Preset dropdown in the upper left.
+1. Click the "Run All Tests" button in the upper right and click the "Submit" button in the
+   dialog that appears. The server tests make a Subscription request will and indicate that
+   it is waiting for notifications to be made.
+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.
+
+NOTE: Inferno uses the `Bearer` token sent in the `Authorization` HTTP header 
+to associate requests with sessions. If multiple concurrent sessions are configured
+to use the same token, they may interfere with each other. To prevent concurrent executors
+of these sample executions from disrupting your session it
+is recommended, but not required, to change all instances of `SAMPLE_TOKEN` in the
+Inferno inputs for both client server suites (including within the Subscription instance body), 
+to the same unique value so that the session will not interact with other concurrent users.
+
+## Additional Configuration Details
+
+The details provided here supplement the documentation of individual fields in the input dialog
+that appears when initiating a test run.
+
+### Subscriptions for other content types
+
+To demonstrate the ability of the server under test to serve notifications of multiple different
+content types, additional Subscription instances can be provided in one or more of the
+following inputs:
+- *Empty Notification Subscription Resource*
+- *Id-Only Notification Subscription Resource*
+- *Full-Resource Notification Subscription Resource*
+
+When populated, Inferno will perform an interation loop with the server as a part of the 
+*Notification Verification* test for the corresponding content type, including requesting that the
+system under test create a Subscription for Inferno, waiting for notifications, and then
+continuing with verification.
+
+Additionally, if previously executed during this testing session, Inferno will include 
+the Subscription interaction performed as a part of the *Demonstrate the Subscription
+Workflow* group and verify is correctness as a part of the test for the content type
+indicated in that Subscription. Thus, no additional Subscription needs to be provided
+for the content type used in the *Workflow Subscription Resource* input.
+
+Examples of Subscriptions that can be used in each of these inputs can be found within the
+test kit source code:
+- [`empty` Notification example](https://github.com/inferno-framework/subscriptions-test-kit/blob/main/lib/subscriptions_test_kit/docs/samples/Subscription_empty.json)
+- [`id-only` Notification example](https://github.com/inferno-framework/subscriptions-test-kit/blob/main/lib/subscriptions_test_kit/docs/samples/Subscription_id-only.json)
+- [`full-resource` Notification example](https://github.com/inferno-framework/subscriptions-test-kit/blob/main/lib/subscriptions_test_kit/docs/samples/Subscription_full-resource.json)
+
+### Unsupported Subscription creation element values
+
+The Subscriptions Backport IG indicates that when accepting new Subscription creation requests
+servers [*SHOULD* check the validity of serveral
+elements](https://hl7.org/fhir/uv/subscriptions-backport/STU1.1/components.html#accepting-subscription-requests). 
+Since which values are unsupported are specific to individual implementations, testers that wish
+to verify that the system under test meets these requirements can provide specific values
+in the following input fields:
+
+- *Unsupported Subscription Topic*
+- *Unsupported Subscription Filter*
+- *Unsupported Subscription Channel Type*
+- *Unsupported Subscription Channel Endpoint*
+- *Unsupported Subscription Payload Type*
+- *Unsupported Subscription Channel and Payload Combination*
+
+In each case, Inferno will take the Subscription provided in the *Workflow Subscription Resource*
+input, modify the corresponding element with the provided value, and expect that either the server
+1. Rejects the Subscription, or
+2. Changes the unsupported element value to something else that is supported
+
+## Current Limitations
+
+This test kit is still in draft form and does not test all of the requirements and features
+described in the Subscriptions IG. You can find information on the requirements
+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
+- 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.
+- Inferno does not test delivery error handling and recovery scenarios, including
+  the optional `$events` API and event numbering details.

data/lib/subscriptions_test_kit/endpoints/subscription_create_endpoint.rb

@@ -0,0 +1,90 @@
+require_relative '../tags'
+require_relative '../jobs/send_subscription_notifications'
+require_relative '../suites/subscriptions_r5_backport_r4_client/common/subscription_simulation_utils'
+
+module SubscriptionsTestKit
+  class SubscriptionCreateEndpoint < Inferno::DSL::SuiteEndpoint
+    include SubscriptionsR5BackportR4Client::SubscriptionSimulationUtils
+
+    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
+        return
+      end
+
+      verification_outcome = verify_subscription(subscription)
+      if verification_outcome.present?
+        response.body = verification_outcome.to_json
+        return
+      end
+
+      # Deny subscription if one already created
+      requests = requests_repo.tagged_requests(test_run.test_session_id, tags)
+      existing_subscription_request = requests.find { |r| r.status == 201 }
+      if existing_subscription_request.present?
+        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
+        return
+      end
+
+      # Form response
+      notification_json = notification_bundle_input(result)
+      subscription_id = SecureRandom.uuid
+      # We have to manipulate the raw hash so that we don't lose the _payload primitive extension
+      subscription_hash = JSON.parse(request.body.string).merge('id' => subscription_id, 'status' => 'requested')
+      subscription_hash['channel']['payload'] = actual_mime_type(subscription)
+      response.status = 201
+      response.body = subscription_hash.to_json
+
+      # Kick off notification job
+      subscription_url = "#{request.url}/#{subscription_id}"
+      client_endpoint = subscription.channel.endpoint
+      bearer_token = client_access_token_input(result)
+      test_suite_base_url = request.url.chomp('/').chomp(FHIR_SUBSCRIPTION_PATH)
+      Inferno::Jobs.perform(Jobs::SendSubscriptionNotifications, test_run.id, test_run.test_session_id, result.id,
+                            subscription_id, subscription_url, client_endpoint, bearer_token, notification_json,
+                            test_run_identifier, test_suite_base_url)
+    end
+
+    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 = subscription.channel&.extension&.find do |e|
+        e.url == 'http://hl7.org/fhir/uv/subscriptions-backport/StructureDefinition/backport-heartbeat-period'
+      end
+      operation_outcome('error', 'not-supported', 'heartbeatPeriod is not supported') unless heartbeat_period.nil?
+    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_read_endpoint.rb

@@ -0,0 +1,32 @@
+require_relative '../tags'
+require_relative '../suites/subscriptions_r5_backport_r4_client/common/subscription_simulation_utils'
+
+module SubscriptionsTestKit
+  class SubscriptionReadEndpoint < Inferno::DSL::SuiteEndpoint
+    include SubscriptionsR5BackportR4Client::SubscriptionSimulationUtils
+
+    def test_run_identifier
+      request.headers['authorization']&.delete_prefix('Bearer ')
+    end
+
+    def make_response
+      response.format = :json
+      subscription_id = request.params[:id]
+
+      subscription = find_subscription(test_run.test_session_id)
+
+      if subscription.present? && subscription.id == subscription_id
+        status_code = determine_subscription_status_code(subscription_id)
+        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
+      end
+    end
+
+    def tags
+      [SUBSCRIPTION_READ_TAG]
+    end
+  end
+end

data/lib/subscriptions_test_kit/endpoints/subscription_rest_hook_endpoint.rb

@@ -0,0 +1,66 @@
+require_relative '../tags'
+module SubscriptionsTestKit
+  class SubscriptionRestHookEndpoint < Inferno::DSL::SuiteEndpoint
+    def test_run_identifier
+      bearer_token = extract_bearer_token(request)
+      "notification #{bearer_token}"
+    end
+
+    # Header expected to be a bearer token of the form "Bearer <token>"
+    def extract_bearer_token(request)
+      request.headers['authorization']&.delete_prefix('Bearer ')
+    end
+
+    def notification_extract_subscription_status(request)
+      notification_bundle_entries = request.params[:entry]
+      return if notification_bundle_entries.blank?
+
+      subscription_status_entry = notification_bundle_entries.find do |entry|
+        entry[:resource][:resourceType] == 'Parameters'
+      end
+
+      subscription_status_entry[:resource]
+    end
+
+    def extract_notification_type(request)
+      subscription_status = notification_extract_subscription_status(request)
+      return unless subscription_status.present?
+
+      notification_type = subscription_status[:parameter].find { |param| param[:name] == 'type' }
+      notification_type[:valueCode]
+    end
+
+    def subscription_status_extract_parameter(parameters, param_name)
+      return unless parameters.present?
+
+      parameters.find do |entry|
+        entry[:name] == param_name
+      end
+    end
+
+    def notification_extract_subscription_id(request)
+      subscription_status = notification_extract_subscription_status(request)
+      return unless subscription_status.present?
+
+      subscription_param = subscription_status_extract_parameter(subscription_status[:parameter], 'subscription')
+      return unless subscription_param.present?
+
+      subscription_reference = subscription_param[:valueReference][:reference]
+      subscription_reference.split('/').last
+    end
+
+    def make_response
+      response.status = 200
+    end
+
+    def tags
+      notification_type = extract_notification_type(request)
+      subscription_id = notification_extract_subscription_id(request)
+      [notification_type, subscription_id]
+    end
+
+    def update_result
+      results_repo.update(result.id, result: 'pass') unless test.config.options[:accepts_multiple_requests]
+    end
+  end
+end

data/lib/subscriptions_test_kit/endpoints/subscription_status_endpoint.rb

@@ -0,0 +1,70 @@
+require_relative '../tags'
+require_relative '../suites/subscriptions_r5_backport_r4_client/common/subscription_simulation_utils'
+
+module SubscriptionsTestKit
+  class SubscriptionStatusEndpoint < Inferno::DSL::SuiteEndpoint
+    include SubscriptionsR5BackportR4Client::SubscriptionSimulationUtils
+
+    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)
+
+      unless subscription.present?
+        not_found
+        return
+      end
+
+      subscription_id = request.params[:id]
+
+      # 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
+          return
+        end
+
+        id_params = params&.parameter&.filter { |p| p.name == 'id' }
+
+        if id_params&.any? && id_params&.none? { |p| p.valueString == subscription.id }
+          not_found
+          return
+        else
+          status_params = params&.parameter&.filter { |p| p.name == 'status' }
+          subscription_status = determine_subscription_status_code(subscription.id)
+          if status_params&.any? && status_params.none? { |p| p.valueString == subscription_status }
+            not_found
+            return
+          end
+        end
+      end
+
+      notification_json = notification_bundle_input(result)
+      subscription_url = "#{base_subscription_url}/#{subscription.id}"
+      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, status_code, event_count,
+                                           request.url).to_json
+    end
+
+    def tags
+      [SUBSCRIPTION_STATUS_TAG]
+    end
+
+    def not_found
+      response.status = 404
+      response.body = operation_outcome('error', 'not-found').to_json
+    end
+
+    def base_subscription_url
+      request.url.sub(%r{(#{Regexp.escape(FHIR_SUBSCRIPTION_PATH)}).*}, '\1')
+    end
+  end
+end