davinci_pas_test_kit 0.15.2 → 0.16.0

data/lib/davinci_pas_test_kit/client/client_bundle_validation_helper.rb

@@ -0,0 +1,245 @@
+require_relative 'request_count_gating'
+
+module DaVinciPASTestKit
+  module ClientBundleValidationHelper
+    include RequestCountGating
+
+    ###########################################################################
+    # Tags and Request Loading
+    ###########################################################################
+    def request_type_tag
+      case operation_name
+      when 'inquire'
+        INQUIRE_TAG
+      when 'submit'
+        SUBMIT_TAG
+      else
+        raise Inferno::Exceptions::TestSuiteImplementationException.new(
+          'PAS Client Bundle Validation Test',
+          "invalid operation name #{operation_name}"
+        )
+      end
+    end
+
+    def workflow_tag
+      config.options[:workflow_tag]
+    end
+
+    # workflow_tag may be a single tag or an Array of tags; normalized to an Array so fetch_requests
+    # doesn't need its own is_a?(Array) check.
+    def workflow_tags
+      Array(workflow_tag)
+    end
+
+    def fetch_requests
+      tags = workflow_tags.presence || [nil]
+      tags.flat_map { |tag| load_tagged_requests(*[request_type_tag, tag].compact) }
+    end
+
+    ###########################################################################
+    # Request Count
+    ###########################################################################
+
+    # Raises if there are multiple requests and the test doesn't allow that.
+    # Skips if there are no requests and the test doesn't allow that.
+    # @param requests [Array<Inferno::Entities::Request>] the requests loaded for this test.
+    # @param description [String] identifies the requests in the raised message, e.g.
+    #   "submit requests".
+    def check_request_count(requests, description)
+      if requests.length > 1 && !multiple_requests_ok?
+        raise Inferno::Exceptions::TestSuiteImplementationException.new(
+          'multiple request handling',
+          "#{requests.length} #{description} were tagged for validation by this test, which does not expect " \
+          'more than one.'
+        )
+      elsif requests.empty?
+        if no_requests_ok?
+          pass "No #{description} analyzed."
+        else
+          skip "No #{description} received."
+        end
+      end
+    end
+
+    ###########################################################################
+    # Extraction logic
+    ###########################################################################
+
+    def message_contents(request)
+      case message_direction_name
+      when 'request'
+        request.request_body
+      when 'response'
+        request.response_body
+      else
+        raise Inferno::Exceptions::TestSuiteImplementationException.new(
+          'PAS Client Bundle Validation Test',
+          "invalid message direction name #{message_direction_name}"
+        )
+      end
+    end
+
+    def parameters_target_parameter_name
+      case message_direction_name
+      when 'request'
+        'resource'
+      when 'response'
+        'return'
+      else
+        raise Inferno::Exceptions::TestSuiteImplementationException.new(
+          'PAS Client Bundle Validation Test',
+          "invalid message direction name #{message_direction_name}"
+        )
+      end
+    end
+
+    ###########################################################################
+    # Validation logic
+    ###########################################################################
+
+    # Finds Bundles in the requests and determines which ones are non-conformant.
+    #
+    # Assumes this is the only thing logging to `messages` during this run and that it's
+    # called at most once, so every message present afterward is one it logged itself.
+    def non_conformant_bundles
+      requests = fetch_requests
+      check_request_count(requests, "$#{operation_name} #{message_direction_name}s")
+      requests.each_with_index { |request, index| validate_request(request, index) }
+
+      messages
+        .select { |message| message[:type] == 'error' }
+        .map { |message| message[:message].split(':', 2).first }
+        .uniq
+    end
+
+    # Validates one request/response, extracting and checking the Bundle(s) it contains and
+    # logging any problem found along the way - this only logs, callers determine what failed
+    # from `messages` afterward (see non_conformant_bundles).
+    def validate_request(request, index)
+      message_label = entity_label("#{message_direction_name.capitalize} #{index + 1}")
+      contents = message_contents(request)
+      message_resource = resource_from_message_contents(contents, message_label)
+      return if message_resource.blank?
+
+      # extraction varies - provided by test class if not using the default. May contain nil
+      # placeholders for positions that held something other than a Bundle (already reported),
+      # so Bundle labels keep their original position.
+      bundles = bundles_from_message_resource(message_resource, message_label)
+      parameters_has_errors?(message_resource, message_label) if response_parameters?(message_resource)
+      echoed_from = echo_source_bundle(request)
+
+      if bundles.length > 1
+        bundles.each_with_index do |bundle, bundle_index|
+          next if bundle.nil?
+
+          bundle_label = entity_label("#{message_label.delete_suffix(':')} Bundle #{bundle_index + 1}")
+          bundle_has_errors?(bundle, bundle_label, echoed_from)
+        end
+      else
+        bundles.compact.each { |bundle| bundle_has_errors?(bundle, message_label, echoed_from) }
+      end
+    end
+
+    # A label identifying one request/response, or a Bundle within one, for use as a message
+    # prefix. Always ends in ':' so a logged message's entity can be recovered by splitting on
+    # its first ':' - see non_conformant_bundles.
+    def entity_label(description)
+      "#{description}:"
+    end
+
+    def resource_from_message_contents(contents, label)
+      resource = FHIR.from_contents(contents)
+      messages << { type: 'error', message: "#{label} Not a FHIR resource." } unless resource.present?
+      resource
+    rescue StandardError
+      messages << { type: 'error', message: "#{label} Invalid JSON." }
+      nil
+    end
+
+    # standard Bundle extraction: 1 Bundle, not wrapped in Parameters
+    def bundles_from_message_resource(message_resource, message_label)
+      case message_resource
+      when FHIR::Bundle
+        [message_resource]
+      when FHIR::Parameters
+        messages << { type: 'error',
+                      message: "#{message_label} expected a Bundle resource, got Parameters." }
+        target_parameter_name = parameters_target_parameter_name
+        matching_resources = extract_resources_from_parameters(message_resource, target_parameter_name)
+
+        if matching_resources.empty?
+          messages << { type: 'error',
+                        message: "#{message_label} Parameters resource had no Bundle " \
+                                 "in a '#{target_parameter_name}' entry." }
+          []
+        elsif matching_resources.length > 1
+          messages << { type: 'error',
+                        message: "#{message_label} Parameters resource had multiple '#{target_parameter_name}' " \
+                                 'entries, but only one allowed (Bundles not validated).' }
+          []
+        elsif matching_resources.first.is_a?(FHIR::Bundle)
+          [matching_resources.first]
+        else
+          messages << { type: 'error',
+                        message: "#{message_label} Parameters resource '#{target_parameter_name}' entry expected to " \
+                                 "contain a Bundle, got #{matching_resources.first&.resourceType}" }
+          []
+        end
+
+      else
+        messages << { type: 'error',
+                      message: "#{message_label} expected a Bundle resource, got #{message_resource.resourceType}." }
+        []
+      end
+    end
+
+    # The request Bundle a response answers, so resources the response echoes back from it may keep
+    # the extensions they had in it - see PasBundleValidation#perform_no_custom_extensions_validation. Unwraps
+    # Parameters-wrapped requests (v2.2.1 $inquire). Nil when validating requests, or when the
+    # request has no Bundle.
+    def echo_source_bundle(request)
+      return unless message_direction_name == 'response'
+
+      request_resource = FHIR.from_contents(request.request_body)
+      if request_resource.is_a?(FHIR::Parameters)
+        request_resource = extract_resources_from_parameters(request_resource, 'resource').first
+      end
+      request_resource if request_resource.is_a?(FHIR::Bundle)
+    rescue StandardError
+      nil
+    end
+
+    # A Parameters wrapper Inferno sends around the response Bundles (v2.2.1 $inquire), which may be
+    # tester-provided, so it is checked for custom extensions too.
+    def response_parameters?(message_resource)
+      message_direction_name == 'response' && message_resource.is_a?(FHIR::Parameters)
+    end
+
+    def parameters_has_errors?(parameters, label)
+      parameters_messages = perform_no_custom_extensions_parameters_validation(parameters)
+      parameters_messages.each { |m| messages << { type: m[:type], message: "#{label} #{m[:message]}" } }
+      parameters_messages.any? { |m| m[:type] == 'error' }
+    rescue NoMethodError, TypeError, ArgumentError => e
+      messages << { type: 'error', message: "#{label} Parameters could not be validated: #{e.message}" }
+      true
+    end
+
+    def bundle_has_errors?(bundle, label, echoed_from = nil)
+      # Responses are sent by Inferno and may be tester-provided, so custom extensions aren't allowed.
+      bundle_messages =
+        if message_direction_name == 'response'
+          perform_no_custom_extensions_validation(bundle, operation_name, message_direction_name, ig_version,
+                                                  echoed_from:)
+        else
+          perform_bundle_validation(bundle, operation_name, message_direction_name, ig_version)
+        end
+      bundle_messages.each { |m| messages << { type: m[:type], message: "#{label} #{m[:message]}" } }
+      bundle_messages.any? { |m| m[:type] == 'error' }
+    rescue NoMethodError, TypeError, ArgumentError => e
+      # a malformed Bundle (e.g., an entry with no resource) shouldn't stop the remaining
+      # requests/Bundles from being validated
+      messages << { type: 'error', message: "#{label} could not be validated: #{e.message}" }
+      true
+    end
+  end
+end

data/lib/davinci_pas_test_kit/client/client_input_descriptions.rb

@@ -2,38 +2,104 @@
 
 module DaVinciPASTestKit
   INPUT_CLIENT_ID_LOCKED =
-    'The client\'s registered Client Id for use in obtaining access tokens. ' \
+    'The PAS client\'s registered Client Id for use in obtaining access tokens. ' \
     'Run the **1** Client Registration group to configure this input.'
   INPUT_SESSION_URL_PATH_LOCKED =
     'The additional path used to create session-specific endpoints. Run the ' \
     '**1** Client Registration group to configure this input.'
 
-  # Shared documentation for the must support response inputs, which differ only
-  # in the operation whose responses they configure ('$submit' or '$inquire').
+  # Shared text for the "Demonstrate Must Support Coverage" group and its combined $submit/$inquire
+  # response_attest test, identical across PAS versions in each client/vX/pas_client_must_support_group.rb
+  # other than the requirement each version's attest test verifies.
+  MUST_SUPPORT_RECEIVE_GROUP_TITLE = 'Demonstrate Must Support Coverage'
+  MUST_SUPPORT_RECEIVE_GROUP_DESCRIPTION =
+    %(
+      During this group, Inferno will wait while the tester uses the PAS client to
+      make `$submit` and `$inquire` operation requests to Inferno demonstrating coverage
+      of must support elements not yet demonstrated.
+
+      Inferno then asks for confirmation that all responses were handled
+      without error and verifies the conformance of all requests and responses.
+    )
+  MUST_SUPPORT_SUBMIT_INQUIRE_ATTEST_TITLE =
+    'PAS client handled the $submit and $inquire responses without erroring'
+  MUST_SUPPORT_SUBMIT_INQUIRE_ATTEST_DESCRIPTION =
+    %(
+      During this test, the tester will verify that the PAS client handled
+      the `$submit` and `$inquire` operation responses, making the result available to
+      the user without failing or erroring.
+    )
+  MUST_SUPPORT_SUBMIT_INQUIRE_ATTEST_MESSAGE =
+    'I attest that the PAS client correctly handled the `$submit` and `$inquire` ' \
+    'operation responses received from Inferno during this test, making the details ' \
+    'available to users without errors.'
+
+  # Text for the v2.2.1 must support group, where the analysis is a separate group from the receive group
+  MUST_SUPPORT_COVERAGE_GROUP_TITLE = 'Must Support Coverage'
+  MUST_SUPPORT_COVERAGE_GROUP_DESCRIPTION =
+    %(
+      During this group, Inferno checks that the requests and responses exchanged during the
+      PAS scenario group and the most recent run of the "Demonstrate Must Support Coverage" group
+      include all required profiles and must support elements.
+
+      This group can be re-run on its own, for example after re-running another group, without
+      repeating the "Demonstrate Must Support Coverage" group or losing the requests made
+      during it.
+    )
+  MUST_SUPPORT_SEPARATE_GROUPS_DESCRIPTION =
+    <<~DESCRIPTION
+      The "Demonstrate Must Support Coverage" and "Must Support Coverage" groups can be run
+      separately. Re-running "Demonstrate Must Support Coverage" replaces the requests made during
+      its previous run, while "Must Support Coverage" can be re-run on its own to re-evaluate
+      coverage without making those requests again.
+    DESCRIPTION
+
+  def self.must_support_group_description(ig_version, wiki_anchor)
+    <<~DESCRIPTION
+      During these tests, Inferno will check that the PAS client demonstrates support for
+      all required profiles and must support elements. When looking for demonstration of
+      these profiles and elements, Inferno will consider requests and responses from
+      interactions performed during the PAS scenario group as well as additional ones
+      made when executing this group.
+
+      For additional details on these tests, what they check for, and the requirements
+      underlying them, see the ["Client Must Support Tests" section](https://github.com/inferno-framework/davinci-pas-test-kit/wiki/Client-Must-Support)
+      of the Da Vinci PAS Test Kit wiki, specifically
+      - [Which messages Inferno considers when looking for demonstration of must support elements](https://github.com/inferno-framework/davinci-pas-test-kit/wiki/Client-Must-Support#evaluated-messages).
+      - [What PAS clients must demonstrate to pass these #{ig_version} client must support tests](https://github.com/inferno-framework/davinci-pas-test-kit/wiki/Client-Must-Support##{wiki_anchor}).
+    DESCRIPTION
+  end
+
   def self.ms_responses_input_description(operation)
     <<~DESCRIPTION
-      An optional JSON value specifying response Bundles for Inferno to return when
-      responding to #{operation} requests during must support testing. Provide a single entry
-      or a list of entries, where each entry is either a FHIR Bundle or a wrapper object
-      of the form `{"criteria": {...}, "bundle": {...}}` pairing a FHIR Bundle with the
-      selection criteria that a request must meet for that Bundle to be returned.
-
-      For each request, Inferno will respond with the Bundle of the first entry whose
-      criteria are all met. An entry with no criteria (including a bare Bundle) matches
-      any request, and an entry with multiple criteria must meet all of them. If no entry
-      matches, or none are provided, Inferno will generate a default response. Supported
-      `criteria` keys:
-
-      - `requestRange`: a string of comma-separated request numbers or ranges, e.g.,
-        `"1-2,4"`. Met when the number of #{operation} requests received during this test,
-        counting this one, is among the listed values.
-      - `fhirpath`: a FHIRPath expression evaluated against the incoming request Bundle.
-        Met when the expression evaluates to a single truthy value.
-
-      A Bundle may also contain tokens of the form `{{fhirpath}}`, e.g.,
-      `{{Bundle.entry.first().resource.id}}`. Inferno replaces each token in the returned
-      Bundle with the result of evaluating the FHIRPath expression against the incoming
-      request Bundle.
+      A JSON list of objects ([format](https://github.com/inferno-framework/davinci-pas-test-kit/wiki/Controlling-Simulated-Responses#response-option-format))
+      that Inferno will use to respond to #{operation} requests during the
+      *Demonstrate Must Support Coverage* group. For each request, Inferno will
+      [select](https://github.com/inferno-framework/davinci-pas-test-kit/wiki/Controlling-Simulated-Responses#response-option-evaluation)
+      and [instantiate](https://github.com/inferno-framework/davinci-pas-test-kit/wiki/Controlling-Simulated-Responses#response-instantiation)
+      a response to return from this list. If no entries match or instantiation fails, Inferno will
+      [mock](https://github.com/inferno-framework/davinci-pas-test-kit/wiki/Controlling-Simulated-Responses#mocked-responses)
+      a response.
+    DESCRIPTION
+  end
+
+  def self.user_response_input_description(operation, workflow, group_name)
+    timing_description = "during the *#{group_name}* group to indicate that the request has been #{workflow}"
+    user_response_input_description_base(operation, workflow, timing_description)
+  end
+
+  def self.user_response_input_description_for_update_tests(operation, default_decision, test_name)
+    timing_description = "during the *#{test_name}* test in the *Claim Updates* group"
+    user_response_input_description_base(operation, default_decision, timing_description)
+  end
+
+  def self.user_response_input_description_base(operation, workflow, timing_description)
+    <<~DESCRIPTION
+      If provided, this JSON will be [instantiated](https://github.com/inferno-framework/davinci-pas-test-kit/wiki/Controlling-Simulated-Responses#response-instantiation)
+      and sent in response to the #{operation} request received #{timing_description}.
+      If not provided or if instantiation fails, Inferno will [mock](https://github.com/inferno-framework/davinci-pas-test-kit/wiki/Controlling-Simulated-Responses#mocked-responses)
+      the response based on the submitted Claim and indicate it has been #{workflow}. In either
+      case, the response will be validated against the PAS Response Bundle profile.
     DESCRIPTION
   end
 end

data/lib/davinci_pas_test_kit/client/endpoints/claim_endpoint.rb

@@ -1,7 +1,9 @@
 require_relative '../user_input_response'
+require_relative 'endpoint_session_identification'
+require_relative 'expired_token'
 require_relative '../response_generator'
+require_relative '../subscription_notification_trigger'
 require_relative '../client_urls'
-require_relative '../jobs/send_pas_subscription_notification'
 require_relative '../../cross_suite/fhirpath_utils'
 require_relative '../../cross_suite/response_selection_utils'
 require 'subscriptions_test_kit'
@@ -11,24 +13,25 @@ module DaVinciPASTestKit
   class ClaimEndpoint < Inferno::DSL::SuiteEndpoint
     include SubscriptionsTestKit::SubscriptionsR5BackportR4Client::SubscriptionSimulationUtils
     include ResponseGenerator
+    include SubscriptionNotificationTrigger
     include ClientURLs
     include FhirpathUtils
     include ResponseSelectionUtils
+    include EndpointSessionIdentification
+    include ExpiredToken
 
     # override the one from URLs to make it version specific
     def suite_id
       request.path.split('/custom/')[1].split('/')[0] # request.path = {base inferno path}/custom/{suite_id}/...
     end
 
-    def test_run_identifier
-      return request.params[:session_path] if request.params[:session_path].present?
-
-      UDAPSecurityTestKit::MockUDAPServer.issued_token_to_client_id(
-        request.headers['authorization']&.delete_prefix('Bearer ')
-      )
-    end
+    error_response_format :operation_outcome
 
     def tags
+      # Requests rejected for an expired token or a rejected $inquire are not treated as
+      # submissions of any workflow.
+      return [] if expired_token? || !operation_enabled?
+
       operation_tag = operation == 'submit' ? SUBMIT_TAG : INQUIRE_TAG
       workflow_tag = WORKFLOW_TAG_MAP[workflow]
 
@@ -52,6 +55,13 @@ module DaVinciPASTestKit
       test.config.options[:suppress_notifications] == true
     end
 
+    # Tests must opt in to each operation with the submit_enabled and inquire_enabled options. Inferno responds
+    # to every request for an operation that is not enabled with an OperationOutcome, without tagging the
+    # request or continuing the test.
+    def operation_enabled?
+      %w[inquire submit].include?(operation) && test.config.options[:"#{operation}_enabled"] == true
+    end
+
     def workflow
       case test.id
       when /.*pended.*/
@@ -70,7 +80,7 @@ module DaVinciPASTestKit
     end
 
     def must_support_workflow?
-      test.id =~ /.*must_support.*/ || test.id =~ /.*gather_must_support.*/
+      test.id =~ /.*must_support.*/
     end
 
     WORKFLOW_TAG_MAP = {
@@ -87,6 +97,11 @@ module DaVinciPASTestKit
 
       response.format = :json
 
+      unless operation_enabled?
+        make_rejected_operation_response
+        return
+      end
+
       # Handle the operation failure and processing error workflows, which require a user-provided response.
       if workflow == :operation_failure
         make_operation_failure_response
@@ -136,10 +151,11 @@ module DaVinciPASTestKit
     end
 
     def update_result
-      if UDAPSecurityTestKit::MockUDAPServer.request_has_expired_token?(request)
+      if expired_token?
         UDAPSecurityTestKit::MockUDAPServer.update_response_for_expired_token(response, 'Bearer token')
         return
       end
+      return unless operation_enabled? # keep waiting for the request that the test is looking for
 
       results_repo.update_result(result.id, 'pass') unless test.config.options[:accepts_multiple_requests]
     end
@@ -152,19 +168,29 @@ module DaVinciPASTestKit
     private
 
     # Resolves the user-provided response, using criteria-based selection for must support
-    # workflows or the single-response approach for other workflows.
+    # workflows or the single-response approach for other workflows
+    # and replaces {{fhirpath}} tokens with values from the request.
     def resolve_user_response(req_bundle)
-      if must_support_workflow?
-        select_must_support_response(req_bundle)
-      else
-        UserInputResponse.user_inputted_response(test, operation, result)
-      end
+      user_response = if must_support_workflow?
+                        select_must_support_response(req_bundle)
+                      else
+                        UserInputResponse.user_inputted_response(test, operation, result)
+                      end
+
+      return nil unless user_response.present?
+
+      replace_tokens(user_response, req_bundle)
+    rescue FhirpathUtils::FhirpathServiceError => e
+      add_result_warning(
+        'Unable to instantiate a tester-provided response, so Inferno will generate a default response: ' \
+        "#{e.message}"
+      )
+      nil
     end
 
     # Selects the first tester-provided response candidate whose selection criteria all
     # match the incoming request, extracts its response Bundle (unwrapping it when the
-    # candidate pairs the Bundle with criteria), and replaces {{fhirpath}} tokens with
-    # values from the request. Returns nil, causing Inferno to generate a default
+    # candidate pairs the Bundle with criteria). Returns nil, causing Inferno to generate a default
     # response, if no candidates are provided or none match. Problems with the
     # tester-provided input or the FHIRPath service also result in nil, with a warning
     # on the waiting test so that the tester can see what went wrong.
@@ -188,20 +214,22 @@ module DaVinciPASTestKit
         "Selected tester-provided response bundle #{selected_index + 1} of #{candidates.length} " \
         "for #{operation_url_suffix} request ##{request_number}."
       )
-      replace_tokens(entity_bundle(candidates[selected_index]), req_bundle)
+      entity_response(candidates[selected_index])
     rescue UserInputResponse::InvalidInputError, FhirpathUtils::FhirpathServiceError => e
       add_result_warning(
-        "Unable to select a tester-provided response, so Inferno will generate a default response. #{e.message}"
+        'Unable to select a tester-provided response, so Inferno will generate a default response: ' \
+        "#{e.message}"
       )
       nil
     end
 
     # Replaces {{fhirpath}} tokens using values from the incoming request, round-tripping
-    # the result through the FHIR model to normalize it. If a replaced value breaks the
-    # JSON structure, the result cannot be returned as a FHIR response, so nil is returned
-    # with a warning on the waiting test and Inferno generates a default response.
+    # the result through the FHIR model to normalize it. The response may be a parsed hash
+    # (must support workflow) or the raw JSON string of a single input. If a replaced value
+    # breaks the JSON structure, the result cannot be returned as a FHIR response, so nil is
+    # returned with a warning on the waiting test and Inferno generates a default response.
     def replace_tokens(bundle_hash, req_bundle)
-      bundle_json = bundle_hash.to_json
+      bundle_json = bundle_hash.is_a?(String) ? bundle_hash : bundle_hash.to_json
       replaced = replace_tokens_in_string(bundle_json, req_bundle)
       return bundle_json if replaced.equal?(bundle_json)
 
@@ -252,68 +280,80 @@ module DaVinciPASTestKit
     end
 
     def make_processing_error_response
-      user_provided_bundle = UserInputResponse.user_inputted_response(test, operation, result)
-      unless user_provided_bundle.present?
-        response.status = 400
-        response.body = FHIR::OperationOutcome.new(
-          issue: FHIR::OperationOutcome::Issue.new(
-            severity: 'fatal', code: 'required',
-            details: FHIR::CodeableConcept.new(
-              text: 'The processing_error_response input is required for this test and was not provided.'
-            )
-          )
-        ).to_json
+      unless UserInputResponse.user_inputted_response(test, operation, result).present?
+        error_outcome_response('The processing_error_response input is required for this test and was not provided.')
         return
       end
 
+      req_bundle = FHIR.from_contents(request.body.string)
+      if req_bundle.blank?
+        handle_missing_required_elements(nil, response)
+        return
+      end
+
+      # Unlike other workflows, there is no mocked response to fall back to when instantiation fails.
+      instantiated_response = resolve_user_response(req_bundle)
+      if instantiated_response.blank?
+        error_outcome_response('The processing_error_response input could not be instantiated. ' \
+                               'See the warnings on the waiting test for details.')
+        return
+      end
+
+      claim_entry = req_bundle.entry&.find { |e| e&.resource&.resourceType == 'Claim' }
       response.status = 200
-      response.body = user_provided_bundle
+      response.body = update_tester_provided_response(instantiated_response, claim_entry&.fullUrl, operation,
+                                                      ig_version)
+    end
+
+    def make_rejected_operation_response
+      response.status = 501
+      response.body = FHIR::OperationOutcome.new(
+        issue: FHIR::OperationOutcome::Issue.new(
+          severity: 'error', code: 'not-supported',
+          details: FHIR::CodeableConcept.new(
+            text: "Inferno does not support the $#{operation} operation during this test."
+          )
+        )
+      ).to_json
+    end
+
+    def error_outcome_response(text)
+      response.status = 400
+      response.body = FHIR::OperationOutcome.new(
+        issue: FHIR::OperationOutcome::Issue.new(
+          severity: 'fatal', code: 'required', details: FHIR::CodeableConcept.new(text:)
+        )
+      ).to_json
     end
 
     def operation
       request.path.split('$').last
     end
 
-    def start_notification_job(response_bundle_json, decision, generated_claim_response_uuid)
-      notification_bearer_token = client_access_token_input(result)
-      notification_contents = notification_json(response_bundle_json, decision, generated_claim_response_uuid)
+    # Helper methods for SubscriptionNotificationTrigger
 
-      Inferno::Jobs.perform(Jobs::SendPASSubscriptionNotification, test_run.id, test_run.test_session_id, result.id,
-                            notification_bearer_token, notification_contents, test_run_identifier, suite_id,
-                            ig_version)
+    def notification_test_run_id
+      test_run.id
     end
 
-    def notification_json(response_bundle_json, decision, generated_claim_response_uuid)
-      user_inputted_notification_json =
-        JSON.parse(result.input_json).find { |i| i['name'] == 'notification_bundle' }['value']
+    def notification_test_session_id
+      test_run.test_session_id
+    end
 
-      if user_inputted_notification_json.present?
-        update_tester_provided_notification(user_inputted_notification_json, generated_claim_response_uuid)
-      else
-        generate_notification(response_bundle_json, decision)
-      end
+    def notification_result_id
+      result.id
     end
 
-    def generate_notification(response_bundle_json, decision)
-      subscription = find_subscription(test_run.test_session_id, as_json: true)
-      subscription_reference = "#{fhir_subscription_url}/#{subscription['id']}"
-      subscription_topic = subscription['criteria']
-
-      if find_subscription_content_type(subscription) == 'full-resource'
-        mock_full_resource_notification_bundle(response_bundle_json, subscription_reference, subscription_topic,
-                                               decision, ig_version)
-      else # assume id-only since empty not allowed - if asked for empty, other failures will occur
-        mock_id_only_notification_bundle(response_bundle_json, subscription_reference, subscription_topic,
-                                         ig_version)
-      end
+    def notification_bearer_token
+      client_access_token_input(result)
+    end
+
+    def tester_notification_bundle
+      notification_bundle_input(result)
     end
 
-    def find_subscription_content_type(subscription)
-      content_ext = subscription.dig('channel', '_payload', 'extension')
-        &.find do |ext|
-          ext['url'] == 'http://hl7.org/fhir/uv/subscriptions-backport/StructureDefinition/backport-payload-content'
-        end
-      content_ext&.dig('valueCode')
+    def client_subscription_json
+      find_subscription(test_run.test_session_id, as_json: true)
     end
   end
 end