subscriptions_test_kit 0.9.0

data/lib/inferno_requirements_tools/tasks/requirements_coverage.rb

@@ -0,0 +1,264 @@
+# frozen_string_literal: true
+
+require 'CSV'
+require 'roo'
+require_relative '../ext/inferno_core/runnable'
+
+module InfernoRequirementsTools
+  module Tasks
+    # This class manages the mapping of test kit tests to requirements that they verify
+    # and creates a CSV file with the tests that cover each requirement.
+    # It expects a CSV file in the repo at `lib/[test kit id]/requirements/[test kit id]_requirements.csv`
+    # that serves as the source of the requirement set for the test kit. The requirements in
+    # this files are identified by a requirement set and an id and tests, groups, and suites
+    # within in the test kit can claim that they verify a requirement by including a reference
+    # to that requirementin the form <requirement set>@<id> in their `verifies_requirements` field.
+    # Requirements that are out of scope can be listed in a companion file
+    # `lib/[test kit id]/requirements/[test kit id]_out_of_scope_requirements.csv`.
+    #
+    # The `run` method generates a CSV file at
+    # `lib/[test kit id]/requirements/generated/[test kit id]_requirements_coverage.csv``.
+    # This file will be identical to the input spreadsheet, plus an additional column which holds a comma separated
+    # list of inferno test IDs that test each requirement. These test IDs are Inferno short form IDs that represent the
+    # position of the test within its group and suite. For example, the fifth test in the second group will have an ID
+    # of 2.05. This ID is also shown in the Inferno web UI.
+    #
+    # The `run_check` method will check whether the previously generated file is up-to-date.
+    class RequirementsCoverage
+      # Update these constants based on the test kit.
+      TEST_KIT_ID = 'subscriptions-test-kit'
+      TEST_SUITES = [SubscriptionsTestKit::SubscriptionsR5BackportR4Client::SubscriptionsR5BackportR4ClientSuite,
+                     SubscriptionsTestKit::SubscriptionsR5BackportR4Server::SubscriptionsR5BackportR4ServerSuite].freeze
+      SUITE_ID_TO_ACTOR_MAP = {
+        'subscriptions_r5_backport_r4_client' => 'Client',
+        'subscriptions_r5_backport_r4_server' => 'Server'
+      }.freeze
+
+      # Derivative constants
+      TEST_KIT_CODE_FOLDER = TEST_KIT_ID.gsub('-', '_')
+      INPUT_HEADERS = [
+        'Req Set',
+        'ID',
+        'URL',
+        'Requirement',
+        'Conformance',
+        'Actor',
+        'Sub-Requirement(s)',
+        'Conditionality'
+      ].freeze
+      SHORT_ID_HEADER = 'Short ID(s)'
+      FULL_ID_HEADER = 'Full ID(s)'
+      INPUT_FILE_NAME = "#{TEST_KIT_ID}_requirements.csv".freeze
+      INPUT_FILE = File.join('lib', TEST_KIT_CODE_FOLDER, 'requirements', INPUT_FILE_NAME).freeze
+      NOT_TESTED_FILE_NAME = "#{TEST_KIT_ID}_out_of_scope_requirements.csv".freeze
+      NOT_TESTED_FILE = File.join('lib', TEST_KIT_CODE_FOLDER, 'requirements', NOT_TESTED_FILE_NAME).freeze
+      OUTPUT_FILE_NAME = "#{TEST_KIT_ID}_requirements_coverage.csv".freeze
+      OUTPUT_FILE = File.join('lib', TEST_KIT_CODE_FOLDER, 'requirements', 'generated', OUTPUT_FILE_NAME).freeze
+
+      def input_rows
+        @input_rows ||=
+          CSV.parse(File.open(INPUT_FILE, "r:bom|utf-8"), headers: true).map do |row|
+            row.to_h.slice(*INPUT_HEADERS)
+          end
+      end
+
+      def not_tested_requirements_map
+        @not_tested_requirements_map ||= load_not_tested_requirements
+      end
+
+      def load_not_tested_requirements
+        return {} unless File.exists?(NOT_TESTED_FILE)
+
+        not_tested_requirements = {}
+        CSV.parse(File.open(NOT_TESTED_FILE, "r:bom|utf-8"), headers: true).each do |row|
+          row_hash = row.to_h
+          not_tested_requirements[ "#{row_hash['Req Set']}@#{row_hash['ID']}"] = row_hash
+        end
+
+        not_tested_requirements
+      end
+
+      # Of the form:
+      # {
+      #     'req-id-1': [
+      #       { short_id: 'short-id-1', full_id: 'long-id-1', suite_id: 'suite-id-1' },
+      #       { short_id: 'short-id-2', full_id: 'long-id-2', suite_id: 'suite-id-2' }
+      #     ],
+      #     'req-id-2': [{ short_id: 'short-id-3', full_id: 'long-id-3', suite_id: 'suite-id-3' }],
+      #     ...
+      # }
+      def inferno_requirements_map
+        @inferno_requirements_map ||= TEST_SUITES.each_with_object({}) do |suite, requirements_map|
+          serialize_requirements(suite, 'suite', suite.id, requirements_map)
+          suite.groups.each do |group|
+            map_group_requirements(group, suite.id, requirements_map)
+          end
+        end
+      end
+
+      def new_csv
+        @new_csv ||=
+          CSV.generate(+"\xEF\xBB\xBF") do |csv|
+            output_headers = TEST_SUITES.each_with_object(INPUT_HEADERS.dup) do |suite, headers|
+              headers << "#{suite.title} #{SHORT_ID_HEADER}"
+              headers << "#{suite.title} #{FULL_ID_HEADER}"
+            end
+
+            csv << output_headers
+            input_rows.each do |row| # note: use row order from source file
+              next if row['Conformance'] == 'DEPRECATED' # filter out deprecated rows
+              row_actor = row['Actor']
+              TEST_SUITES.each do |suite|
+                suite_actor = SUITE_ID_TO_ACTOR_MAP[suite.id]
+                if row_actor&.include?(suite_actor)
+                  set_and_req_id = "#{row['Req Set']}@#{row['ID']}"
+                  suite_requirement_items = inferno_requirements_map[set_and_req_id]&.filter { |item| item[:suite_id] == suite.id}
+                  short_ids = suite_requirement_items&.map { |item| item[:short_id] }
+                  full_ids = suite_requirement_items&.map { |item| item[:full_id] }
+                  if short_ids.blank? && not_tested_requirements_map.has_key?(set_and_req_id)
+                    row["#{suite.title} #{SHORT_ID_HEADER}"] = 'Not Tested'
+                    row["#{suite.title} #{FULL_ID_HEADER}"] = 'Not Tested'
+                  else
+                    row["#{suite.title} #{SHORT_ID_HEADER}"] = short_ids&.join(', ')
+                    row["#{suite.title} #{FULL_ID_HEADER}"] = full_ids&.join(', ')
+                  end
+                else
+                  row["#{suite.title} #{SHORT_ID_HEADER}"] = 'NA'
+                  row["#{suite.title} #{FULL_ID_HEADER}"] = 'NA'
+                end
+              end
+
+              csv << row.values
+            end
+          end
+      end
+
+      def input_requirement_ids
+        @input_requirement_ids ||= input_rows.map { |row| "#{row['Req Set']}@#{row['ID']}" }
+      end
+
+      # The requirements present in Inferno that aren't in the input spreadsheet
+      def unmatched_requirements_map
+        @unmatched_requirements_map ||= inferno_requirements_map.filter do |requirement_id, _|
+          !input_requirement_ids.include?(requirement_id)
+        end
+      end
+
+      def old_csv
+        @old_csv ||= File.read(OUTPUT_FILE)
+      end
+
+      def run
+        unless File.exist?(INPUT_FILE)
+          puts "Could not find input file: #{INPUT_FILE}. Aborting requirements coverage generation..."
+          exit(1)
+        end
+
+        if unmatched_requirements_map.any?
+          puts "WARNING: The following requirements indicated in the test kit are not present in #{INPUT_FILE_NAME}"
+          output_requirements_map_table(unmatched_requirements_map)
+        end
+
+        if File.exist?(OUTPUT_FILE)
+          if old_csv == new_csv
+            puts "'#{OUTPUT_FILE_NAME}' file is up to date."
+            return
+          else
+            puts 'Requirements coverage has changed.'
+          end
+        else
+          puts "No existing #{OUTPUT_FILE_NAME}."
+        end
+
+        puts "Writing to file #{OUTPUT_FILE}..."
+        File.write(OUTPUT_FILE, new_csv)
+        puts 'Done.'
+      end
+
+      def run_check
+        unless File.exist?(INPUT_FILE)
+          puts "Could not find input file: #{INPUT_FILE}. Aborting requirements coverage check..."
+          exit(1)
+        end
+
+        if unmatched_requirements_map.any?
+          puts "The following requirements indicated in the test kit are not present in #{INPUT_FILE_NAME}"
+          output_requirements_map_table(unmatched_requirements_map)
+        end
+
+        if File.exist?(OUTPUT_FILE)
+          if old_csv == new_csv
+            puts "'#{OUTPUT_FILE_NAME}' file is up to date."
+            return unless unmatched_requirements_map.any?
+          else
+            puts <<~MESSAGE
+              #{OUTPUT_FILE_NAME} file is out of date.
+              To regenerate the file, run:
+
+                  bundle exec rake requirements:generate_coverage
+
+            MESSAGE
+          end
+        else
+          puts <<~MESSAGE
+            No existing #{OUTPUT_FILE_NAME} file.
+            To generate the file, run:
+
+                  bundle exec rake requirements:generate_coverage
+
+          MESSAGE
+        end
+
+        puts 'Check failed.'
+        exit(1)
+      end
+
+      def map_group_requirements(group, suite_id, requirements_map)
+        serialize_requirements(group, group.short_id, suite_id, requirements_map)
+        group.tests&.each { |test| serialize_requirements(test, test.short_id, suite_id, requirements_map) }
+        group.groups&.each { |subgroup| map_group_requirements(subgroup, suite_id, requirements_map) }
+      end
+
+      def serialize_requirements(runnable, short_id, suite_id, requirements_map)
+        runnable.verifies_requirements&.each do |requirement_id|
+          requirement_id_string = requirement_id.to_s
+
+          requirements_map[requirement_id_string] ||= []
+          requirements_map[requirement_id_string] << { short_id:, full_id: runnable.id, suite_id: }
+        end
+      end
+
+      # Output the requirements in the map like so:
+      #
+      # requirement_id | short_id   | full_id
+      # ---------------+------------+----------
+      # req-id-1       | short-id-1 | full-id-1
+      # req-id-2       | short-id-2 | full-id-2
+      def output_requirements_map_table(requirements_map)
+        headers = %w[requirement_id short_id full_id]
+        col_widths = headers.map(&:length)
+        col_widths[0] = [col_widths[0], requirements_map.keys.map(&:length).max].max
+        col_widths[1] = ([col_widths[1]] + requirements_map.values.flatten.map { |item| item[:short_id].length }).max
+        col_widths[2] = ([col_widths[2]] + requirements_map.values.flatten.map { |item| item[:full_id].length }).max
+        col_widths.map { |width| width + 3 }
+
+        puts [
+          headers[0].ljust(col_widths[0]),
+          headers[1].ljust(col_widths[1]),
+          headers[2].ljust(col_widths[2])
+        ].join(' | ')
+        puts col_widths.map { |width| '-' * width }.join('-+-')
+        requirements_map.each do |requirement_id, runnables|
+          runnables.each do |runnable|
+            puts [
+              requirement_id.ljust(col_widths[0]),
+              runnable[:short_id].ljust(col_widths[1]),
+              runnable[:full_id].ljust(col_widths[2])
+            ].join(' | ')
+          end
+        end
+        puts
+      end
+    end
+  end
+end

data/lib/subscriptions_test_kit/common/notification_conformance_verification.rb

@@ -0,0 +1,310 @@
+module SubscriptionsTestKit
+  module NotificationConformanceVerification
+    def no_error_verification(message)
+      assert messages.none? { |msg| msg[:type] == 'error' }, message
+    end
+
+    def find_all_elems(resource_array, param_name)
+      resource_array.select do |param|
+        param.name == param_name
+      end
+    end
+
+    def find_elem(resource_array, param_name)
+      resource_array.find do |param|
+        param.name == param_name
+      end
+    end
+
+    def check_entry_request_and_response(entry, entry_num)
+      if entry.request.blank?
+        add_message('error', %(
+          The `entry.request` field is mandatory for history Bundles, but was not included in entry #{entry_num}))
+      end
+      return unless entry.response.blank?
+
+      add_message('error', %(
+        The `entry.response` field is mandatory for history Bundles, but was not included in entry #{entry_num}))
+    end
+
+    def check_history_bundle_request_response(bundle, subscription_status_entry, subscription_id)
+      check_entry_request_and_response(subscription_status_entry, 1)
+
+      unless subscription_status_entry.request.present? &&
+             (
+               subscription_id ?
+                 subscription_status_entry.request.url.end_with?("Subscription/#{subscription_id}/$status") :
+                 subscription_status_entry.request.url.match?(%r{Subscription/[^/]+/\$status\z})
+             )
+
+        add_message('error',
+                    'The SubscriptionStatus `request` SHALL be filled out to match a request to the $status operation')
+      end
+
+      bundle.entry.drop(1).each_with_index do |entry, index|
+        check_entry_request_and_response(entry, index + 2)
+      end
+    end
+
+    def parameters_verification(subscription_status)
+      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')
+      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)
+      assert_valid_json(notification_bundle)
+      bundle = FHIR.from_contents(notification_bundle)
+      assert bundle.present?, 'Not a FHIR resource'
+      assert_resource_type(:bundle, resource: bundle)
+      unless bundle.type == 'history'
+        add_message('error', "Notification should be a history Bundle, instead was #{bundle.type}")
+      end
+
+      if bundle.entry.empty?
+        add_message('error', 'Notification Bundle is empty.')
+        return
+      end
+      subscription_status_entry = bundle.entry[0]
+
+      check_history_bundle_request_response(bundle, subscription_status_entry, subscription_id)
+
+      subscription_status = subscription_status_entry.resource
+      parameters_verification(subscription_status)
+
+      return unless subscription_status.respond_to?(:parameter)
+
+      subscription_type = find_elem(subscription_status.parameter, 'type')
+
+      unless subscription_type.valueCode == notification_type
+        add_message('error', %(
+            The Subscription resource should have it's `type` set to '#{notification_type}', was
+            '#{subscription_type.valueCode}'))
+      end
+
+      return unless status.present?
+
+      subscription_param_status = find_elem(subscription_status.parameter, 'status')
+      return if subscription_param_status.valueCode == status
+
+      add_message('error', %(
+              The Subscription resource should have it's `status` set to '#{status}', was
+              '#{subscription_param_status.valueCode}'))
+    end
+
+    def empty_notification_event_references(notification_events)
+      empty_req_check = true
+      notification_events.each do |notification_event|
+        empty_req_check = notification_event.part.none? do |part|
+          part.name == 'focus' || part.name == 'additional-context'
+        end
+        break unless empty_req_check
+      end
+      empty_req_check
+    end
+
+    def empty_notification_verification(bundle_entries, notification_events)
+      unless bundle_entries.empty?
+        add_message('error', %(
+        When the content type is empty, notification bundles SHALL not contain Bundle.entry elements other than
+        the SubscriptionStatus for the notification.))
+      end
+
+      if notification_events.empty?
+        add_message('error', %(
+          Events are required for empty notifications, but the SubscriptionStatus does not contain event-notifications
+        ))
+        return
+      end
+
+      empty_req_check = empty_notification_event_references(notification_events)
+      return if empty_req_check
+
+      add_message('error', %(
+            When populating the SubscriptionStatus.notificationEvent structure for a notification with an empty
+            payload, a server SHALL NOT include references to resources))
+    end
+
+    def verify_id_only_notification_bundle_entries(bundle_entries)
+      bundle_entries.each do |entry|
+        if entry.resource.present?
+          add_message('error', 'Each Bundle.entry for id-only notification SHALL not contain the `resource` field')
+        end
+        if entry.fullUrl.blank?
+          add_message('error', %(
+            Each Bundle.entry for id-only notification SHALL contain a relevant resource URL in the fullUrl))
+        end
+      end
+    end
+
+    def verify_full_resource_notification_bundle_entries(bundle_entries)
+      bundle_entries.each do |entry|
+        resource_is_valid?(resource: entry.resource) if entry.resource.present?
+      end
+    end
+
+    def check_bundle_entry_reference(bundle_entries, reference)
+      referenced_entry = bundle_entries.find do |entry|
+        reference.include?("#{entry.resource.resourceType}/#{entry.resource.id}")
+      end
+      referenced_entry.present?
+    end
+
+    def check_notification_event_focus(focus_elem, bundle_entries)
+      if focus_elem.blank?
+        add_message('error', %(
+            When the content type is `full-resource`, notification bundles SHALL include references to
+            the appropriate focus resources in the SubscriptionStatus.notificationEvent.focus element))
+      else
+        unless check_bundle_entry_reference(bundle_entries, focus_elem.valueReference.reference)
+          add_message('error', %(
+            The Notification Bundle does not include a resource entry for the reference found in
+            SubscriptionStatus.notificationEvent.focus with id #{focus_elem.valueReference.reference}))
+        end
+      end
+    end
+
+    def check_notification_event_additional_context(additional_context_list, bundle_entries)
+      return if additional_context_list.empty?
+
+      additional_context_list.each do |additional_context|
+        next if check_bundle_entry_reference(bundle_entries, additional_context.valueReference.reference)
+
+        add_message('error', %(
+            The Notification Bundle does not include a resource entry for the reference found in
+            SubscriptionStatus.notificationEvent.additional-context with id
+            #{additional_context.valueReference.reference}))
+      end
+    end
+
+    def full_resource_notification_event_parameter_verification(notification_events, bundle_entries)
+      notification_events.each do |notification_event|
+        focus_elem = find_elem(notification_event.part, 'focus')
+        additional_context_list = find_all_elems(notification_event.part, 'additional-context')
+
+        check_notification_event_focus(focus_elem, bundle_entries)
+        check_notification_event_additional_context(additional_context_list, bundle_entries)
+      end
+    end
+
+    def id_only_notification_event_parameter_verification(notification_events, criteria_resource_type)
+      notification_events.each do |notification_event|
+        focus_elem = find_elem(notification_event.part, 'focus')
+
+        if focus_elem.blank?
+          add_message('error', %(
+              When the content type is `id-only`, notification bundles SHALL include references to
+              the appropriate focus resources in the SubscriptionStatus.notificationEvent.focus element))
+          break
+        else
+          break unless criteria_resource_type.present?
+
+          unless focus_elem.valueReference.reference.include?(criteria_resource_type)
+            add_message('error', %(
+              The SubscriptionStatus.notificationEvent.focus should include a reference to a #{criteria_resource_type}
+              resource, the resource type the Subscription is focused on))
+            break
+          end
+        end
+      end
+    end
+
+    def full_resource_notification_criteria_resource_check(bundle_entries, criteria_resource_type)
+      relevant_resource = bundle_entries.any? do |entry|
+        entry.resource.resourceType == criteria_resource_type || entry.request.url.include?(criteria_resource_type)
+      end
+      return if relevant_resource
+
+      add_message('error', %(
+          The notification bundle of type `full-resource` must include at least one #{criteria_resource_type}
+          resource in the entry.resource element.))
+    end
+
+    def subscription_criteria(subscription)
+      return unless subscription['_criteria']
+
+      criteria_extension = subscription['_criteria']['extension'].find do |ext|
+        ext['url'].ends_with?('/backport-filter-criteria')
+      end
+      criteria_extension['valueString'].split('?').first
+    end
+
+    def empty_event_notification_verification(notification_bundle)
+      assert_valid_json(notification_bundle)
+      bundle = FHIR.from_contents(notification_bundle)
+      assert bundle.present?, 'Not a FHIR resource'
+
+      subscription_status = bundle.entry[0].resource
+
+      parameter_topic = find_elem(subscription_status.parameter, 'topic')
+      if parameter_topic.present?
+        add_message('warning',
+                    'Parameters.parameter:topic.value[x]: This value SHOULD NOT be present when using empty payloads')
+      end
+
+      notification_events = find_all_elems(subscription_status.parameter, 'notification-event')
+      bundle_entries = bundle.entry.drop(1)
+
+      empty_notification_verification(bundle_entries, notification_events)
+    end
+
+    def full_resource_event_notification_verification(notification_bundle, criteria_resource_type)
+      assert_valid_json(notification_bundle)
+      bundle = FHIR.from_contents(notification_bundle)
+      assert bundle.present?, 'Not a FHIR resource'
+
+      subscription_status = bundle.entry[0].resource
+
+      parameter_topic = find_elem(subscription_status.parameter, 'topic')
+      if parameter_topic.blank?
+        add_message('warning', %(
+              Parameters.parameter:topic.value[x]: This value SHOULD be present when using full-resource payloads))
+      end
+
+      notification_events = find_all_elems(subscription_status.parameter, 'notification-event')
+      bundle_entries = bundle.entry.drop(1)
+
+      if criteria_resource_type.present?
+        full_resource_notification_criteria_resource_check(bundle_entries, criteria_resource_type)
+      end
+
+      if notification_events.empty?
+        add_message('error', %(
+          The notification event parameter must be present in `full-resource` notification bundles.))
+      else
+        full_resource_notification_event_parameter_verification(notification_events, bundle_entries)
+      end
+
+      verify_full_resource_notification_bundle_entries(bundle_entries)
+    end
+
+    def id_only_event_notification_verification(notification_bundle, criteria_resource_type)
+      assert_valid_json(notification_bundle)
+      bundle = FHIR.from_contents(notification_bundle)
+      assert bundle.present?, 'Not a FHIR resource'
+
+      subscription_status = bundle.entry[0].resource
+
+      parameter_topic = find_elem(subscription_status.parameter, 'topic')
+      add_message('info', %(
+        Parameters.parameter:topic.value[x] is #{'not ' if parameter_topic.blank?}populated in `id-only` Notification.
+        This value MAY be present when using id-only payloads))
+
+      notification_events = find_all_elems(subscription_status.parameter, 'notification-event')
+      bundle_entries = bundle.entry.drop(1)
+
+      if notification_events.empty?
+        add_message('error', %(
+            The notification event parameter must be present in `id-only` notification bundles.))
+      else
+        id_only_notification_event_parameter_verification(notification_events, criteria_resource_type)
+      end
+
+      verify_id_only_notification_bundle_entries(bundle_entries)
+    end
+  end
+end

data/lib/subscriptions_test_kit/common/subscription_conformance_verification.rb

@@ -0,0 +1,87 @@
+require_relative '../urls'
+
+module SubscriptionsTestKit
+  module SubscriptionConformanceVerification
+    include URLs
+
+    def no_error_verification(message)
+      assert messages.none? { |msg| msg[:type] == 'error' }, message
+    end
+
+    def channel_field_matches?(subscription_channel, field_name, expected_entry)
+      subscription_channel[field_name].present? && subscription_channel[field_name] == expected_entry
+    end
+
+    def cross_version_extension?(url)
+      url.match?(%r{http://hl7\.org/fhir/[0-9]+\.[0-9]+/StructureDefinition/extension-Subscription\..+})
+    end
+
+    def check_extension(extensions)
+      extensions.each do |extension|
+        next unless cross_version_extension?(extension['url'])
+
+        add_message('warning', %(
+          Cross-version extensions SHOULD NOT be used on R4 subscriptions to describe any elements also described by
+          this guide, but found the #{extension['url']} extension on the Subscription resource
+        ))
+      end
+    end
+
+    def cross_version_extension_check(subscription)
+      subscription.each do |key, value|
+        if value.is_a?(Array) && key == 'extension'
+          check_extension(value)
+        elsif value.is_a?(Hash) || value.is_a?(Array)
+          cross_version_extension_check(value)
+        end
+      end
+    end
+
+    def subscription_verification(subscription_resource)
+      assert_valid_json(subscription_resource)
+      subscription = JSON.parse(subscription_resource)
+
+      subscription_channel = subscription['channel']
+      assert(channel_field_matches?(subscription_channel, 'type', 'rest-hook'), %(
+        The `type` field on the Subscription resource must be set to `rest-hook`, the `#{subscription_channel['type']}`
+        channel type is unsupported.))
+
+      subscription_resource = FHIR.from_contents(subscription.to_json)
+      assert_resource_type('Subscription', resource: subscription_resource)
+      assert_valid_resource(resource: subscription_resource,
+                            profile_url: 'http://hl7.org/fhir/uv/subscriptions-backport/StructureDefinition/backport-subscription')
+
+      cross_version_extension_check(subscription)
+      subscription
+    end
+
+    def server_check_channel(subscription, access_token)
+      subscription_channel = subscription['channel']
+      unless channel_field_matches?(subscription_channel, 'endpoint', subscription_channel_url)
+        add_message('warning', %(
+                  The subscription url was changed from #{subscription_channel['endpoint']} to
+                  #{subscription_channel_url}))
+        subscription_channel['endpoint'] = subscription_channel_url
+      end
+
+      unless channel_field_matches?(subscription_channel, 'payload', 'application/json')
+        add_message('warning', %(
+          The `type` field on the Subscription resource should be set to `application/json`. Inferno will only accept
+          resources in requests with this content type.
+        ))
+      end
+
+      unless subscription_channel['header'].present? &&
+             subscription_channel['header'].include?("Authorization: Bearer #{access_token}")
+        add_message('warning', %(
+          Added the Authorization header field with a Bearer token set to #{access_token} to the `header` field on the
+          Subscription resource in order to connect successfully with the Inferno subscription channel.
+        ))
+        subscription['header'] = [] unless subscription['header'].present?
+        subscription['header'].append("Authorization: Bearer #{access_token}")
+      end
+      subscription['channel'] = subscription_channel
+      subscription
+    end
+  end
+end