subscriptions_test_kit 0.9.0

data/lib/subscriptions_test_kit/suites/subscriptions_r5_backport_r4_client/workflow/interaction_test.rb

@@ -0,0 +1,128 @@
+# frozen_string_literal: true
+
+module SubscriptionsTestKit
+  module SubscriptionsR5BackportR4Client
+    class InteractionTest < Inferno::Test
+      id :subscriptions_r5_backport_r4_client_interaction
+      description %(
+        During this test, the client under test will interact with Inferno following the Subscription
+        workflow over a `rest-hook` channel. This includes the following steps
+        1. The client under test sends a Subscription request to Inferno
+        2. Inferno sends a handshake notification request to the endpoint specified in the Subscription.
+        3. Inferno sends an event notification request to the endpoint specified in the Subscription.
+
+        While these steps are taking place and after, Inferno will be waiting for the user to indicate that
+        the interaction has completed successfully or failed for some reason. Additionally, the client
+        system may make additional requests, such as `$status` checks, while the test is waiting.
+        Afterwards, Inferno will no longer respond to requests.
+
+        To create the handshake and event notifications, Inferno uses the contents of the *Event
+        Notification Bundle* input. The provided notification will be modified as appropriate for 
+        the request Inferno is making:
+        - General changes for all notification types
+          - update the `subscription` parameter entry reference.
+          - update the `status` parameter entry based on the previous interactions.
+          - update the `type` parameter entry based on the notification type (e.g., `event-notification` or `handshake`).
+          - update the number of notifications sent in the `events-since-subscription-start` parameter entry.
+        - `handshake`-specific changes:
+          - clear the `events` parameter entry.
+          - clear the `errors` parameter entry.
+
+        While the provided Notification must be conformant to the 
+        [R4 Topic-Based Subscription Notification Bundle 
+        profile](https://hl7.org/fhir/uv/subscriptions-backport/STU1.1/StructureDefinition-backport-subscription-notification-r4.html)
+        for the tests to pass, the tests can run as long as the notification meets the
+        following minimal requirements:
+        1. The provided content must be a valid json representation of a FHIR Bundle resource.
+        2. The first instance in the Bundle is a Parameters resource.
+        3. The first Parameters instance has a `subscription` parameter entry.
+      )
+      title 'Subscription Workflow Interaction'
+
+      input :access_token,
+            title: 'Access Token',
+            description: %(
+              The bearer token that the client under test will use when making Subscription creation, $status, and other
+              requests to Inferno's simulated Subscriptions server.
+            )
+      input :client_endpoint_access_token,
+            optional: true,
+            title: 'Client Notification Access Token',
+            description: %(
+              The bearer token that Inferno will send on requests to the client under test's rest-hook notification endpoint. Not
+              needed if the client under test will create a Subscription with an appropriate header value in the
+              `channel.header` element. If a value for the `authorization` header is provided in `channel.header`, this
+              value will override it.
+            )
+      input :notification_bundle,
+            title: 'Event Notification Bundle',
+            type: 'textarea',
+            description: %(
+              The event notification bundle from which Inferno will derive a handshake notification, an event
+              notification to send to the client endpoint, and responses to $status operation requests. The provided
+              Bundle must conform to the R4 Topic-Based Subscription Notification Bundle profile.
+            )
+
+      verifies_requirements 'hl7.fhir.uv.subscriptions_1.1.0@23'
+
+      run do
+        minimally_validate_notification(notification_bundle)
+        assert(messages.none? { |m| m[:type] == 'error' }, 'Notification Bundle input is invalid for use by Inferno, see error message(s)')
+
+        wait(
+          identifier: access_token,
+          timeout: 600,
+          message: %(
+            Inferno will wait until the the event notification workflow is complete. The steps in the workflow are:
+
+            1. Inferno expects a Subscription POST request at:
+
+              `#{fhir_subscription_url}`
+
+              with the Authorization header set to:
+
+              `Bearer #{access_token}`
+
+            2. Inferno will send a handshake notification to the rest-hook endpoint specified in the subscription.
+
+            3. After a 5–10 second delay, Inferno will send an event notification to the rest-hook endpoint.
+
+            At any point while this test is waiting, Inferno will respond to Subscription GET and $status requests.
+
+            Once the client has received an event notification and has made any additional requests,
+            [click here to complete the test](#{resume_pass_url}?test_run_identifier=#{access_token})
+
+            If at any point something has gone wrong and the client is unable to continue,
+            [click here to fail the test](#{resume_fail_url}?test_run_identifier=#{access_token})
+
+            NOTE: The test must be completed or failed using the links above within 10 minutes. After that,
+            attempts to send requests or to complete or fail the tests using the links above
+            will result in a *"session not found"* error.
+          )
+        )
+      end
+
+      # Perform only the verification necessary for the Inferno test to function
+      def minimally_validate_notification(notification_bundle)
+        assert_valid_json(notification_bundle)
+        begin
+          bundle = FHIR.from_contents(notification_bundle)
+        rescue StandardError
+          assert(false, 'Notification bundle input is not a conformant FHIR Bundle')
+        end
+        assert_resource_type(:bundle, resource: bundle)
+        subscription_status = bundle.entry&.first&.resource
+        assert(subscription_status.present?, 'Notification bundle input must contain a subscription status entry')
+        assert_resource_type(:parameters, resource: subscription_status)
+
+        # Require the subscription param, just because we need something to later identify the subscription status
+        # bundle entry. Note we could just as easily use a different required param, like status or type.
+        subscription_param = subscription_status.parameter&.find { |p| p.name == 'subscription' }
+        assert(subscription_param.present?, 'Subscription status entry in notification bundle input must contain a'\
+                                            'subscription parameter')
+      rescue Inferno::Exceptions::AssertionException => e
+        add_message('error', e.message)
+      end
+    end
+  end
+end

data/lib/subscriptions_test_kit/suites/subscriptions_r5_backport_r4_client/workflow/interaction_verification/event_notification_verification_test.rb

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+require_relative '../../common/subscription_simulation_utils'
+
+module SubscriptionsTestKit
+  module SubscriptionsR5BackportR4Client
+    class EventNotificationVerificationTest < Inferno::Test
+      include SubscriptionSimulationUtils
+
+      id :subscriptions_r5_backport_r4_client_event_notification_verification
+      title 'Rest-Hook Event Notification Verification'
+      description %(
+        This test verifies that the client's response to the event notification
+        was conformant.
+      )
+      verifies_requirements 'hl7.fhir.uv.subscriptions_1.1.0@24',
+                            'hl7.fhir.uv.subscriptions_1.1.0@71'
+
+      run do
+        load_tagged_requests(REST_HOOK_EVENT_NOTIFICATION_TAG)
+        skip_if(requests.none?, 'Inferno did not send an event notification')
+
+        # The SendSubscriptionNotifications job saves a nil status if the request fails entirely
+        assert(request.status.present?, "Handshake notification request failed with error: #{request.response_body}")
+
+        assert(request.status.between?(200, 299), "Event notification was not successful, status code #{request.status}")
+
+        subscription = find_subscription(test_session_id)
+        if subscription.present?
+          mime_type = subscription&.channel&.payload
+          unless ALLOWED_MIME_TYPES.include?(mime_type)
+            add_message('warning', %(Subscription specified '#{mime_type}' for `Subscription.channel.payload`, but Inferno
+                                    only supports: #{ALLOWED_MIME_TYPES.map { |type| "'#{type}'" }.join(', ')}.
+                                    Event notification was sent with Content-Type: '#{DEFAULT_MIME_TYPE}'.))
+          end
+        end
+      end
+    end
+  end
+end

data/lib/subscriptions_test_kit/suites/subscriptions_r5_backport_r4_client/workflow/interaction_verification/handshake_notification_verification_test.rb

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+require_relative '../../common/subscription_simulation_utils'
+
+module SubscriptionsTestKit
+  module SubscriptionsR5BackportR4Client
+    class HandshakeNotificationVerificationTest < Inferno::Test
+      include SubscriptionSimulationUtils
+
+      id :subscriptions_r5_backport_r4_client_handshake_notification_verification
+      title 'Rest-Hook Handshake Notification Verification'
+      description %(
+        This test verifies that the client's response to the handshake notification
+        was conformant.
+      )
+      verifies_requirements 'hl7.fhir.uv.subscriptions_1.1.0@71'
+
+      run do
+        load_tagged_requests(REST_HOOK_HANDSHAKE_NOTIFICATION_TAG)
+        skip_if(requests.none?, 'Inferno did not send a handshake notification')
+
+        # The SendSubscriptionNotifications job saves a nil status if the request fails entirely
+        assert(request.status.present?, "Handshake notification request failed with error: #{request.response_body}")
+
+        assert(request.status.between?(200, 299),
+              "Handshake notification was not successful, status code #{request.status}")
+
+        subscription = find_subscription(test_session_id)
+        if subscription.present?
+          mime_type = subscription&.channel&.payload
+          unless ALLOWED_MIME_TYPES.include?(mime_type)
+            add_message('warning', %(Subscription specified '#{mime_type}' for `Subscription.channel.payload`, but Inferno
+                                    only supports: #{ALLOWED_MIME_TYPES.map { |type| "'#{type}'" }.join(', ')}.
+                                    Handshake notification was sent with Content-Type: '#{DEFAULT_MIME_TYPE}'.))
+          end
+        end
+      end
+    end
+  end
+end

data/lib/subscriptions_test_kit/suites/subscriptions_r5_backport_r4_client/workflow/interaction_verification_group.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+require_relative 'interaction_verification/handshake_notification_verification_test'
+require_relative 'interaction_verification/event_notification_verification_test'
+
+module SubscriptionsTestKit
+  module SubscriptionsR5BackportR4Client
+    class InteractionVerificationGroup < Inferno::TestGroup
+      id :subscriptions_r5_backport_r4_client_interaction_verification
+      title 'Rest-Hook Subscription Interaction Verification'
+
+      test from: :subscriptions_r5_backport_r4_client_handshake_notification_verification
+      test from: :subscriptions_r5_backport_r4_client_event_notification_verification
+    end
+  end
+end

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

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+require_relative 'workflow/interaction_test'
+require_relative 'workflow/interaction_verification_group'
+require_relative 'workflow/conformance_verification_group'
+
+module SubscriptionsTestKit
+  module SubscriptionsR5BackportR4Client
+    class WorkflowGroup < Inferno::TestGroup
+      include URLs
+
+      id :subscriptions_r5_backport_r4_client_workflow
+      title 'Demonstrate the Rest-Hook Subscription Workflow'
+      description %(
+          Demonstrate the ability of the client to request the
+          creation of a FHIR Subscription instance and receive a notification
+          for that Subscription. The tester must provide the body of a Notification
+          that it expects to receive. Inferno will act as a server,
+        waiting for the Subscription creation request and then sending the
+        notification. Inferno will then verify that the provided Subscription
+        and notification match and that the exchange is conformant.
+      )
+      run_as_group
+
+      group 'Rest-Hook Subscription Interaction' do
+        test from: :subscriptions_r5_backport_r4_client_interaction
+      end
+
+      group from: :subscriptions_r5_backport_r4_client_interaction_verification
+      group from: :subscriptions_r5_backport_r4_client_conformance_verification
+    end
+  end
+end

data/lib/subscriptions_test_kit/suites/subscriptions_r5_backport_r4_client_suite.rb

@@ -0,0 +1,66 @@
+# frozen_string_literal: true
+
+require_relative 'subscriptions_r5_backport_r4_client/workflow_group'
+require_relative '../endpoints/subscription_create_endpoint'
+require_relative '../endpoints/subscription_read_endpoint'
+require_relative '../endpoints/subscription_status_endpoint'
+require_relative '../version'
+
+module SubscriptionsTestKit
+  module SubscriptionsR5BackportR4Client
+    class SubscriptionsR5BackportR4ClientSuite < Inferno::TestSuite
+      id :subscriptions_r5_backport_r4_client
+      title 'Subscriptions R5 Backport IG v1.1.0 FHIR R4 Client Test Suite'
+      short_title 'Subscriptions R4 Client'
+      version VERSION
+      description File.read(File.join(__dir__, '..', 'docs', 'subscriptions_r5_backport_r4_client_suite_description.md'))
+
+      links [
+        {
+          label: 'Report Issue',
+          url: 'https://github.com/inferno-framework/subscriptions-test-kit/issues'
+        },
+        {
+          label: 'Open Source',
+          url: 'https://github.com/inferno-framework/subscriptions-test-kit'
+        },
+        {
+          label: 'Download',
+          url: 'https://github.com/inferno-framework/subscriptions-test-kit/releases'
+        },
+        {
+          label: 'Implementation Guide',
+          url: 'https://hl7.org/fhir/uv/subscriptions-backport/STU1.1/'
+        }
+      ]
+
+      # All FHIR validation requests will use this FHIR validator
+      fhir_resource_validator do
+        igs 'hl7.fhir.uv.subscriptions-backport#1.1.0'
+
+        exclude_message do |message|
+          message.message.match?(/\A\S+: \S+: URL value '.*' does not resolve/)
+        end
+      end
+
+      capability_statement = File.read(File.join(__dir__, 'subscriptions_r5_backport_r4_client', 'fixtures', 'capability_statement.json'))
+      route(:get, '/fhir/metadata', proc { [200, { 'Content-Type' => 'application/json' }, [capability_statement]] })
+
+      suite_endpoint :post, FHIR_SUBSCRIPTION_PATH, SubscriptionCreateEndpoint
+      suite_endpoint :get, FHIR_SUBSCRIPTION_INSTANCE_PATH, SubscriptionReadEndpoint
+      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
+
+      resume_test_route :get, RESUME_PASS_PATH do |request|
+        request.query_parameters['test_run_identifier']
+      end
+
+      resume_test_route :get, RESUME_FAIL_PATH, result: 'fail' do |request|
+        request.query_parameters['test_run_identifier']
+      end
+
+      group from: :subscriptions_r5_backport_r4_client_workflow
+    end
+  end
+end

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

@@ -0,0 +1,51 @@
+module SubscriptionsTestKit
+  module SubscriptionsR5BackportR4Server
+    class CreationResponseConformanceTest < Inferno::Test
+      id :subscriptions_r5_backport_r4_server_creation_response_conformance
+      title 'Verify Subscription Creation Response'
+      description %(
+        This test ensures that the server responded to the Subscription creation test with the new created Subscription
+        resource. If the Subscription's channel type is set to 'rest-hook', the test will ensure that the Subscription's
+        status is set to 'requested'.
+      )
+
+      verifies_requirements 'hl7.fhir.uv.subscriptions_1.1.0@7',
+                            'hl7.fhir.uv.subscriptions_1.1.0@25',
+                            'hl7.fhir.uv.subscriptions_1.1.0@49',
+                            'hl7.fhir.uv.subscriptions_1.1.0@29'
+
+      def subscription_type
+        config.options[:subscription_type]
+      end
+
+      run do
+        if subscription_type.present?
+          subscription_requests = load_tagged_requests('subscription_creation', subscription_type)
+          requests =
+            subscription_requests
+              .select { |request| request.status == 201 }
+          skip_if requests.empty?, 'No successful Subscription creation request was made in the previous test.'
+        else
+          all_requests = load_tagged_requests('subscription_creation')
+          all_subscription_requests =
+            all_requests
+              .select { |request| request.status == 201 }
+          skip_if all_subscription_requests.empty?,
+                  'No successful Subscription creation request was made in the previous test.'
+          requests = [all_subscription_requests.first]
+        end
+
+        requests.each do |subscription_request|
+          assert_valid_json(subscription_request.response_body)
+          subscription = FHIR.from_contents(subscription_request.response_body)
+          assert subscription.present?, 'Not a FHIR resource'
+
+          assert_resource_type('Subscription', resource: subscription)
+
+          assert(subscription.channel.type == 'rest-hook' && subscription.status == 'requested',
+                "The Subscription resource should have it's status set to 'requested', was '#{subscription.status}'")
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,56 @@
+require_relative '../subscription_creation'
+require_relative '../../../../urls'
+
+module SubscriptionsTestKit
+  module SubscriptionsR5BackportR4Server
+    class NotificationDeliveryTest < Inferno::Test
+      include SubscriptionCreation
+      include URLs
+
+      id :subscriptions_r5_backport_r4_server_notification_delivery
+      title 'Send Subscription and Receive Notification Requests from Server'
+      description %(
+        This test sends a request to create the Subscription resource to the Subscriptions Backport FHIR Server.
+        If successful, it then waits for [notification](https://hl7.org/fhir/uv/subscriptions-backport/STU1.1/notifications.html#notifications)
+        requests of the following types:
+          - handshake (required for `rest-hook` notifications)
+          - heartbeat (required if `heartbeatPeriod` field is populated in Subscription resource)
+          - event-notification
+      )
+      config options: { accepts_multiple_requests: true }
+
+      verifies_requirements 'hl7.fhir.uv.subscriptions_1.1.0@133'
+
+      input :updated_subscription
+      input :access_token,
+            title: 'Notification Access Token',
+            description: %(
+              An access token that the server under test will send to Inferno on notifications
+              so that the request gets associated with this test session. The token must be
+              provided as a `Bearer` token in the `Authorization` header of HTTP requests
+              sent to Inferno.
+            )
+
+      run do
+        subscription = JSON.parse(updated_subscription)
+        subscription_type = send_subscription(subscription)
+
+        wait(
+          identifier: "notification #{access_token}",
+          message: %(
+            **Subscription `#{subscription['id']}`: `#{subscription_type}` Notification Test**
+
+            Send any handshake, heartbeat, and `#{subscription_type}` event-notification requests for the Subscription
+            with id `#{subscription['id']}` to:
+
+            `#{subscription_channel_url}`
+
+            [Click here](#{resume_pass_url}?token=notification%20#{access_token}) when you have finished submitting
+            requests.
+
+          )
+        )
+      end
+    end
+  end
+end

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

@@ -0,0 +1,72 @@
+require_relative '../../../../common/subscription_conformance_verification'
+
+module SubscriptionsTestKit
+  module SubscriptionsR5BackportR4Server
+    class SubscriptionConformanceTest < Inferno::Test
+      include SubscriptionConformanceVerification
+
+      id :subscriptions_r5_backport_r4_server_subscription_conformance
+      title '[USER INPUT VERIFICATION] Verify Subscription to Send to Server'
+      description %(
+        The Subscription resource is used to request notifications for a specific client about a specific topic
+        Conceptually, a subscription is a concrete request for a single client to receive notifications per a single
+        topic. In order to support topic-based subscriptions in R4, this guide defines several extensions for use on the
+        [R4 Subscription resource](http://hl7.org/fhir/R4/subscription.html). A list of extensions defined by this guide can
+        be found on the [Subscriptions R5 Backport IG's Artifacts page](https://hl7.org/fhir/uv/subscriptions-backport/STU1.1/artifacts.html#5).
+
+        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).
+
+        The Subscription channel should have it's fields populated with the following information:
+          - The `endpoint` field must be set to
+          `#{Inferno::Application['base_url']}/custom/subscriptions_r5_backport_r4_server/subscription/channel/notification_listener`.
+          The test will add the correct url to this field if it is not properly set.
+          - The `type` field must be set to `rest-hook`, as the Inferno subscription workflow tests use a `rest-hook`
+          subscription channel to receive incoming notifications. The test will add the correct type to this field if it
+          is not properly set.
+          - The `payload` field must be set to `application/json`, as Inferno will only accept resources in requests with
+          this content type.
+          - The `header` field must include the `Authorization` header with a Bearer token set to the inputted Inferno
+          access token.
+      )
+
+      verifies_requirements 'hl7.fhir.uv.subscriptions_1.1.0@72',
+                            'hl7.fhir.uv.subscriptions_1.1.0@86'
+
+      input :subscription_resource,
+            title: 'Workflow Subscription Resource',
+            type: 'textarea',
+            description: %(
+              A Subscription resource in JSON format that Inferno will send to the server under test
+              so that it can demonstrate its ability to perform the Subscription creation and Notification
+              response workflow. The instance must be conformant to the R4/B Topic-Based Subscription profile.
+              Inferno may modify the Subscription before submission, e.g., to point to Inferno's notification endpoint.
+              This input is also used by the unsupported Subscription test as the base on which to add unsupported element
+              values to test for server rejection.
+            )
+      input :access_token,
+            title: 'Notification Access Token',
+            description: %(
+              An access token that the server under test will send to Inferno on notifications
+              so that the request gets associated with this test session. The token must be
+              provided as a `Bearer` token in the `Authorization` header of HTTP requests
+              sent to Inferno.
+            )
+
+      output :updated_subscription, :subscription_topic
+
+      run do
+        omit_if subscription_resource.blank?, 'Did not input a Subscription resource of this type.'
+        subscription = subscription_verification(subscription_resource)
+        no_error_verification('Subscription resource is not conformant.')
+
+        assert(subscription['criteria'].present?,
+              'The `criteria` field SHALL be populated and contain the canonical URL for the Subscription Topic.')
+        output subscription_topic: subscription['criteria']
+
+        subscription = server_check_channel(subscription, access_token)
+        output updated_subscription: subscription.to_json
+      end
+    end
+  end
+end

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

@@ -0,0 +1,24 @@
+require_relative 'interaction/subscription_conformance_test'
+require_relative 'interaction/notification_delivery_test'
+require_relative 'interaction/creation_response_conformance_test'
+
+module SubscriptionsTestKit
+  module SubscriptionsR5BackportR4Server
+    class InteractionGroup < Inferno::TestGroup
+      id :subscriptions_r5_backport_r4_server_interaction
+      title 'Subscription Workflow Interaction'
+      description %(
+        Verify that the Subscription instance the tester provided is conformant, and then demonstrate the ability of the
+        server under test to accept a request for the creation of a FHIR Subscription instance and deliver a notification
+        for that Subscription. Inferno will act as a client, creating the Subscription and waiting for a notification
+        based on it.
+      )
+
+      run_as_group
+
+      test from: :subscriptions_r5_backport_r4_server_subscription_conformance
+      test from: :subscriptions_r5_backport_r4_server_notification_delivery
+      test from: :subscriptions_r5_backport_r4_server_creation_response_conformance
+    end
+  end
+end

data/lib/subscriptions_test_kit/suites/subscriptions_r5_backport_r4_server/common/interaction_verification/notification_conformance_test.rb

@@ -0,0 +1,73 @@
+require_relative '../../../../common/notification_conformance_verification'
+
+module SubscriptionsTestKit
+  module SubscriptionsR5BackportR4Server
+    class NotificationConformanceTest < Inferno::Test
+      include NotificationConformanceVerification
+
+      id :subscriptions_r5_backport_r4_server_notification_conformance
+      title 'Subscription Notification Verification'
+      description %(
+        As described in [Topic-Based Subscription Components](https://hl7.org/fhir/uv/subscriptions-backport/STU1.1/components.html#subscription-notifications),
+        all notifications are enclosed in a Bundle with the type of history. Additionally, the first entry of the bundle
+        SHALL be the SubscriptionStatus information, encoded as a Parameters resource using the
+        [Backport SubscriptionStatus Profile](https://hl7.org/fhir/uv/subscriptions-backport/STU1.1/StructureDefinition-backport-subscription-status-r4.html)
+        in FHIR R4.
+
+        This test takes the received notification bundle and ensures it is conformant to the
+        [R4 Topic-Based Subscription Notification Bundle](https://hl7.org/fhir/uv/subscriptions-backport/STU1.1/StructureDefinition-backport-subscription-notification-r4.html)
+        profle.
+      )
+
+      verifies_requirements 'hl7.fhir.uv.subscriptions_1.1.0@14',
+                            'hl7.fhir.uv.subscriptions_1.1.0@15',
+                            'hl7.fhir.uv.subscriptions_1.1.0@28',
+                            'hl7.fhir.uv.subscriptions_1.1.0@69',
+                            'hl7.fhir.uv.subscriptions_1.1.0@70',
+                            'hl7.fhir.uv.subscriptions_1.1.0@138',
+                            'hl7.fhir.uv.subscriptions_1.1.0@139'
+
+      def subscription_type
+        config.options[:subscription_type]
+      end
+
+      run do
+        if subscription_type.present?
+          requests = load_tagged_requests('subscription_creation', subscription_type)
+          subscription_requests =
+            requests
+              .select { |request| request.status == 201 }
+          skip_if subscription_requests.empty?,
+                  'No successful Subscription creation request was made in the previous test.'
+        else
+          all_requests = load_tagged_requests('subscription_creation')
+          all_subscription_requests =
+            all_requests
+              .select { |request| request.status == 201 }
+          skip_if all_subscription_requests.empty?,
+                  'No successful Subscription creation request was made in the previous test.'
+          subscription_requests = [all_subscription_requests.first]
+        end
+
+        subscription_requests.each do |subscription_request|
+          assert_valid_json(subscription_request.response_body)
+          subscription = JSON.parse(subscription_request.response_body)
+
+          requests = load_tagged_requests('event-notification', subscription['id'])
+          skip_if requests.empty?, 'No event-notification requests were made in a previous test as expected.'
+
+          requests = requests.uniq(&:request_body)
+          requests.each do |request|
+            notification_verification(
+              request.request_body,
+              'event-notification',
+              subscription_id: subscription['id'],
+              status: 'active'
+            )
+          end
+        end
+        no_error_verification('Received event-notifications are not conformant.')
+      end
+    end
+  end
+end

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

@@ -0,0 +1,19 @@
+require_relative 'interaction_verification/notification_conformance_test'
+
+module SubscriptionsTestKit
+  module SubscriptionsR5BackportR4Server
+    class InteractionVerificationGroup < Inferno::TestGroup
+      id :subscriptions_r5_backport_r4_server_interaction_verification
+      title 'Subscription Workflow Interaction Verification'
+      description %(
+        Inferno takes the received event-notification Bundle and verifies that it is conformant to the
+        [R4 Topic-Based Subscription Notification Bundle](https://hl7.org/fhir/uv/subscriptions-backport/STU1.1/StructureDefinition-backport-subscription-notification-r4.html)
+        profle.
+      )
+
+      run_as_group
+
+      test from: :subscriptions_r5_backport_r4_server_notification_conformance
+    end
+  end
+end