inferno_core 0.4.22 → 0.4.24

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: e753e1e6cd4a9ef5d59e0bf3c8f53338a7149e5c4735f13d3f135fe8266bdf05
-  data.tar.gz: 7187514e9564bcd45e98ba7fe490b29448a2897293c63b251ac08137c2ba2717
+  metadata.gz: ab9c01a985f9ceb43cc9ad79ddb604cc246b19dfa39f09b323c7677ed347aa88
+  data.tar.gz: 05aa6e68ea46177b1fab155052e1c84fe7c09368eca5ada5f9a5d933ff270a07
 SHA512:
-  metadata.gz: 389ba88c3e2954a713d5caf2092445b72c724c7d1f4544939c41f465ad41e8319d1168f4552a66e4b95280d2eb273ce268af56dc3d317a66510378e9e96870c6
-  data.tar.gz: 2cddf92c61b4f4cc373b86f4b2c028db1ce4f5e5d1da7026b3ec4c6380080a0617ddba5ae32520f2df72bdbceadc5422d15266a52e190f34915f0722264217de
+  metadata.gz: f2879c429dea880db81928b84a0b17afbc06dab2dc2dae2bd088918ac0e25e594b13b12b1bd4f01943c698c382acd1f85ae07a2b14b0b8eea07484e23cc0eb8e
+  data.tar.gz: 5bc9bcf0b1006acf2fd46962d0e69609f343b480c88b832f1465382001029dc5b97353fb80ae3dd22c9c32e375012a290b585f9064eabb2e22816855b9d51612

data/lib/inferno/apps/cli/services.rb

@@ -3,7 +3,7 @@ module Inferno
     class Services < Thor
       no_commands do
         def base_command
-          'docker-compose -f docker-compose.background.yml'
+          'docker compose -f docker-compose.background.yml'
         end
       end
 

data/lib/inferno/config/boot/validator.rb

@@ -0,0 +1,19 @@
+Inferno::Application.boot(:validator) do
+  init do
+    use :suites
+
+    # This process should only run once, to start one job per validator,
+    # so skipping it on workers will start it only once from the "web" process
+    next if Sidekiq.server?
+
+    Inferno::Repositories::TestSuites.new.all.each do |suite|
+      suite.fhir_validators.each do |name, validators|
+        validators.each_with_index do |validator, index|
+          if validator.is_a? Inferno::DSL::FHIRResourceValidation::Validator
+            Inferno::Jobs.perform(Inferno::Jobs::InvokeValidatorSession, suite.id, name.to_s, index)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/inferno/db/migrations/009_add_request_tags.rb

@@ -0,0 +1,18 @@
+Sequel.migration do
+  change do
+    create_table :tags do
+      column :id, String, primary_key: true, null: false, size: 36
+      column :name, String, size: 255, null: false
+
+      index :name, unique: true
+    end
+
+    create_table :requests_tags do
+      foreign_key :tags_id, :tags, index: true, type: String, null: false, size: 36, key: [:id]
+      foreign_key :requests_id, :requests, index: true, type: Integer, null: false, key: [:index]
+
+      index [:tags_id, :requests_id], unique: true
+      index [:requests_id, :tags_id], unique: true
+    end
+  end
+end

data/lib/inferno/db/schema.rb

@@ -4,6 +4,15 @@ Sequel.migration do
       Integer :version, :default=>0, :null=>false
     end
     
+    create_table(:tags, :ignore_index_errors=>true) do
+      String :id, :size=>36, :null=>false
+      String :name, :size=>255, :null=>false
+      
+      primary_key [:id]
+      
+      index [:name], :unique=>true
+    end
+    
     create_table(:test_sessions) do
       String :id, :size=>36, :null=>false
       String :test_suite_id, :size=>255, :null=>false
@@ -121,5 +130,15 @@ Sequel.migration do
       index [:requests_id]
       index [:results_id]
     end
+    
+    create_table(:requests_tags, :ignore_index_errors=>true) do
+      foreign_key :tags_id, :tags, :type=>String, :size=>36, :null=>false, :key=>[:id]
+      foreign_key :requests_id, :requests, :null=>false, :key=>[:index]
+      
+      index [:requests_id]
+      index [:requests_id, :tags_id], :unique=>true
+      index [:tags_id]
+      index [:tags_id, :requests_id], :unique=>true
+    end
   end
 end

data/lib/inferno/dsl/fhir_client.rb

@@ -101,9 +101,18 @@ module Inferno
       #   other tests
       # @param headers [Hash] custom headers for this operation
       # @param operation_method [Symbol] indicates which request type to use for the operation
+      # @param tags [Array<String>] a list of tags to assign to the request
       # @return [Inferno::Entities::Request]
-      def fhir_operation(path, body: nil, client: :default, name: nil, headers: {}, operation_method: :post)
-        store_request_and_refresh_token(fhir_client(client), name) do
+      def fhir_operation(
+        path,
+        body: nil,
+        client: :default,
+        name: nil,
+        headers: {},
+        operation_method: :post,
+        tags: []
+      )
+        store_request_and_refresh_token(fhir_client(client), name, tags) do
           tcp_exception_handler do
             operation_headers = fhir_client(client).fhir_headers
             operation_headers.merge!('Content-Type' => 'application/fhir+json') if body.present?
@@ -127,9 +136,10 @@ module Inferno
       # @param client [Symbol]
       # @param name [Symbol] Name for this request to allow it to be used by
       #   other tests
+      # @param tags [Array<String>] a list of tags to assign to the request
       # @return [Inferno::Entities::Request]
-      def fhir_get_capability_statement(client: :default, name: nil)
-        store_request_and_refresh_token(fhir_client(client), name) do
+      def fhir_get_capability_statement(client: :default, name: nil, tags: [])
+        store_request_and_refresh_token(fhir_client(client), name, tags) do
           tcp_exception_handler do
             fhir_client(client).conformance_statement
             fhir_client(client).reply
@@ -143,9 +153,10 @@ module Inferno
       # @param client [Symbol]
       # @param name [Symbol] Name for this request to allow it to be used by
       #   other tests
+      # @param tags [Array<String>] a list of tags to assign to the request
       # @return [Inferno::Entities::Request]
-      def fhir_create(resource, client: :default, name: nil)
-        store_request_and_refresh_token(fhir_client(client), name) do
+      def fhir_create(resource, client: :default, name: nil, tags: [])
+        store_request_and_refresh_token(fhir_client(client), name, tags) do
           tcp_exception_handler do
             fhir_client(client).create(resource)
           end
@@ -159,9 +170,10 @@ module Inferno
       # @param client [Symbol]
       # @param name [Symbol] Name for this request to allow it to be used by
       #   other tests
+      # @param tags [Array<String>] a list of tags to assign to the request
       # @return [Inferno::Entities::Request]
-      def fhir_read(resource_type, id, client: :default, name: nil)
-        store_request_and_refresh_token(fhir_client(client), name) do
+      def fhir_read(resource_type, id, client: :default, name: nil, tags: [])
+        store_request_and_refresh_token(fhir_client(client), name, tags) do
           tcp_exception_handler do
             fhir_client(client).read(fhir_class_from_resource_type(resource_type), id)
           end
@@ -176,9 +188,10 @@ module Inferno
       # @param client [Symbol]
       # @param name [Symbol] Name for this request to allow it to be used by
       #   other tests
+      # @param tags [Array<String>] a list of tags to assign to the request
       # @return [Inferno::Entities::Request]
-      def fhir_vread(resource_type, id, version_id, client: :default, name: nil)
-        store_request_and_refresh_token(fhir_client(client), name) do
+      def fhir_vread(resource_type, id, version_id, client: :default, name: nil, tags: [])
+        store_request_and_refresh_token(fhir_client(client), name, tags) do
           tcp_exception_handler do
             fhir_client(client).vread(fhir_class_from_resource_type(resource_type), id, version_id)
           end
@@ -192,9 +205,10 @@ module Inferno
       # @param client [Symbol]
       # @param name [Symbol] Name for this request to allow it to be used by
       #   other tests
+      # @param tags [Array<String>] a list of tags to assign to the request
       # @return [Inferno::Entities::Request]
-      def fhir_update(resource, id, client: :default, name: nil)
-        store_request_and_refresh_token(fhir_client(client), name) do
+      def fhir_update(resource, id, client: :default, name: nil, tags: [])
+        store_request_and_refresh_token(fhir_client(client), name, tags) do
           tcp_exception_handler do
             fhir_client(client).update(resource, id)
           end
@@ -209,9 +223,10 @@ module Inferno
       # @param client [Symbol]
       # @param name [Symbol] Name for this request to allow it to be used by
       #   other tests
+      # @param tags [Array<String>] a list of tags to assign to the request
       # @return [Inferno::Entities::Request]
-      def fhir_patch(resource_type, id, patchset, client: :default, name: nil)
-        store_request_and_refresh_token(fhir_client(client), name) do
+      def fhir_patch(resource_type, id, patchset, client: :default, name: nil, tags: [])
+        store_request_and_refresh_token(fhir_client(client), name, tags) do
           tcp_exception_handler do
             fhir_client(client).partial_update(fhir_class_from_resource_type(resource_type), id, patchset)
           end
@@ -225,9 +240,10 @@ module Inferno
       # @param client [Symbol]
       # @param name [Symbol] Name for this request to allow it to be used by
       #   other tests
+      # @param tags [Array<String>] a list of tags to assign to the request
       # @return [Inferno::Entities::Request]
-      def fhir_history(resource_type = nil, id = nil, client: :default, name: nil)
-        store_request_and_refresh_token(fhir_client(client), name) do
+      def fhir_history(resource_type = nil, id = nil, client: :default, name: nil, tags: [])
+        store_request_and_refresh_token(fhir_client(client), name, tags) do
           tcp_exception_handler do
             if id
               fhir_client(client).resource_instance_history(fhir_class_from_resource_type(resource_type), id)
@@ -248,8 +264,16 @@ module Inferno
       # @param name [Symbol] Name for this request to allow it to be used by
       #   other tests
       # @param search_method [Symbol] Use `:post` to search via POST
+      # @param tags [Array<String>] a list of tags to assign to the request
       # @return [Inferno::Entities::Request]
-      def fhir_search(resource_type = nil, client: :default, params: {}, name: nil, search_method: :get)
+      def fhir_search(
+        resource_type = nil,
+        client: :default,
+        params: {},
+        name: nil,
+        search_method: :get,
+        tags: []
+      )
         search =
           if search_method == :post
             { body: params }
@@ -257,7 +281,7 @@ module Inferno
             { parameters: params }
           end
 
-        store_request_and_refresh_token(fhir_client(client), name) do
+        store_request_and_refresh_token(fhir_client(client), name, tags) do
           tcp_exception_handler do
             if resource_type
               fhir_client(client)
@@ -276,9 +300,10 @@ module Inferno
       # @param client [Symbol]
       # @param name [Symbol] Name for this request to allow it to be used by
       #   other tests
+      # @param tags [Array<String>] a list of tags to assign to the request
       # @return [Inferno::Entities::Request]
-      def fhir_delete(resource_type, id, client: :default, name: nil)
-        store_request('outgoing', name) do
+      def fhir_delete(resource_type, id, client: :default, name: nil, tags: [])
+        store_request('outgoing', name:, tags:) do
           tcp_exception_handler do
             fhir_client(client).destroy(fhir_class_from_resource_type(resource_type), id)
           end
@@ -291,9 +316,10 @@ module Inferno
       # @param client [Symbol]
       # @param name [Symbol] Name for this request to allow it to be used by
       #   other tests
+      # @param tags [Array<String>] a list of tags to assign to the request
       # @return [Inferno::Entities::Request]
-      def fhir_transaction(bundle = nil, client: :default, name: nil)
-        store_request('outgoing', name) do
+      def fhir_transaction(bundle = nil, client: :default, name: nil, tags: [])
+        store_request('outgoing', name:, tags:) do
           tcp_exception_handler do
             fhir_client(client).transaction_bundle = bundle if bundle.present?
             fhir_client(client).end_transaction
@@ -312,8 +338,8 @@ module Inferno
       # expired. It's combined with `store_request` so that all of the fhir
       # request methods don't have to be wrapped twice.
       # @private
-      def store_request_and_refresh_token(client, name, &block)
-        store_request('outgoing', name) do
+      def store_request_and_refresh_token(client, name, tags, &block)
+        store_request('outgoing', name:, tags:) do
           perform_refresh(client) if client.need_to_refresh? && client.able_to_refresh?
           block.call
         end

data/lib/inferno/dsl/fhir_resource_validation.rb

@@ -0,0 +1,299 @@
+require_relative '../ext/fhir_models'
+module Inferno
+  module DSL
+    # This module contains the methods needed to configure a validator to
+    # perform validation of FHIR resources. The actual validation is performed
+    # by an external FHIR validation service. Tests will typically rely on
+    # `assert_valid_resource` for validation rather than directly calling
+    # methods on a validator.
+    #
+    # @example
+    #
+    #   validator do
+    #     url 'http://example.com/validator'
+    #     exclude_message { |message| message.type == 'info' }
+    #     perform_additional_validation do |resource, profile_url|
+    #       if something_is_wrong
+    #         { type: 'error', message: 'something is wrong' }
+    #       else
+    #         { type: 'info', message: 'everything is ok' }
+    #       end
+    #     end
+    #   end
+    module FHIRResourceValidation
+      def self.included(klass)
+        klass.extend ClassMethods
+      end
+
+      class Validator
+        attr_reader :requirements
+        attr_accessor :session_id
+
+        # @private
+        def initialize(requirements = nil, &)
+          instance_eval(&)
+          @requirements = requirements
+        end
+
+        # @private
+        def default_validator_url
+          ENV.fetch('FHIR_RESOURCE_VALIDATOR_URL')
+        end
+
+        # Set the url of the validator service
+        #
+        # @param validator_url [String]
+        def url(validator_url = nil)
+          @url = validator_url if validator_url
+
+          @url
+        end
+
+        # Set the IGs that the validator will need to load
+        # Example: ["hl7.fhir.us.core#4.0.0"]
+        # @param igs [Array<String>]
+        def igs(validator_igs = nil)
+          @igs = validator_igs if validator_igs
+
+          @igs
+        end
+
+        # @private
+        def additional_validations
+          @additional_validations ||= []
+        end
+
+        # Perform validation steps in addition to FHIR validation.
+        #
+        # @example
+        #   perform_additional_validation do |resource, profile_url|
+        #     if something_is_wrong
+        #       { type: 'error', message: 'something is wrong' }
+        #     else
+        #       { type: 'info', message: 'everything is ok' }
+        #     end
+        #   end
+        # @yieldparam resource [FHIR::Model] the resource being validated
+        # @yieldparam profile_url [String] the profile the resource is being
+        #   validated against
+        # @yieldreturn [Array<Hash<Symbol, String>>,Hash<Symbol, String>] The
+        #   block should return a Hash or an Array of Hashes if any validation
+        #   messages should be added. The Hash must contain two keys: `:type`
+        #   and `:message`. `:type` can have a value of `'info'`, `'warning'`,
+        #   or `'error'`. A type of `'error'` means the resource is invalid.
+        #   `:message` contains the message string itself.
+        def perform_additional_validation(&block)
+          additional_validations << block
+        end
+
+        # @private
+        def additional_validation_messages(resource, profile_url)
+          additional_validations
+            .flat_map { |step| step.call(resource, profile_url) }
+            .select { |message| message.is_a? Hash }
+        end
+
+        # Filter out unwanted validation messages. Any messages for which the
+        # block evalutates to a truthy value will be excluded.
+        #
+        # @example
+        #   validator do
+        #     exclude_message { |message| message.type == 'info' }
+        #   end
+        # @yieldparam message [Inferno::Entities::Message]
+        def exclude_message(&block)
+          @exclude_message = block if block_given?
+          @exclude_message
+        end
+
+        # @see Inferno::DSL::FHIRResourceValidation#resource_is_valid?
+        def resource_is_valid?(resource, profile_url, runnable)
+          profile_url ||= FHIR::Definitions.resource_definition(resource.resourceType).url
+
+          begin
+            response = call_validator(resource, profile_url)
+          rescue StandardError => e
+            # This could be a complete failure to connect (validator isn't running)
+            # or a timeout (validator took too long to respond).
+            runnable.add_message('error', e.message)
+            raise Inferno::Exceptions::ErrorInValidatorException, "Unable to connect to validator at #{url}."
+          end
+          outcome = operation_outcome_from_validator_response(response, runnable)
+
+          message_hashes = message_hashes_from_outcome(outcome, resource, profile_url)
+
+          message_hashes
+            .each { |message_hash| runnable.add_message(message_hash[:type], message_hash[:message]) }
+
+          unless response.status == 200
+            raise Inferno::Exceptions::ErrorInValidatorException,
+                  'Error occurred in the validator. Review Messages tab or validator service logs for more information.'
+          end
+
+          message_hashes
+            .none? { |message_hash| message_hash[:type] == 'error' }
+        rescue Inferno::Exceptions::ErrorInValidatorException
+          raise
+        rescue StandardError => e
+          runnable.add_message('error', e.message)
+          raise Inferno::Exceptions::ErrorInValidatorException,
+                'Error occurred in the validator. Review Messages tab or validator service logs for more information.'
+        end
+
+        # @private
+        def filter_messages(message_hashes)
+          message_hashes.reject! { |message| exclude_message.call(Entities::Message.new(message)) } if exclude_message
+        end
+
+        # @private
+        def message_hashes_from_outcome(outcome, resource, profile_url)
+          message_hashes = outcome.issue&.map { |issue| message_hash_from_issue(issue, resource) } || []
+
+          message_hashes.concat(additional_validation_messages(resource, profile_url))
+
+          filter_messages(message_hashes)
+
+          message_hashes
+        end
+
+        # @private
+        def message_hash_from_issue(issue, resource)
+          {
+            type: issue_severity(issue),
+            message: issue_message(issue, resource)
+          }
+        end
+
+        # @private
+        def issue_severity(issue)
+          case issue.severity
+          when 'warning'
+            'warning'
+          when 'information'
+            'info'
+          else
+            'error'
+          end
+        end
+
+        # @private
+        def issue_message(issue, resource)
+          location = if issue.respond_to?(:expression)
+                       issue.expression&.join(', ')
+                     else
+                       issue.location&.join(', ')
+                     end
+
+          location_prefix = resource.id ? "#{resource.resourceType}/#{resource.id}" : resource.resourceType
+
+          "#{location_prefix}: #{location}: #{issue&.details&.text}"
+        end
+
+        # @private
+        def wrap_resource_for_hl7_wrapper(resource, profile_url)
+          wrapped_resource = {
+            cliContext: {
+              # TODO: these should be configurable as well
+              sv: '4.0.1',
+              # displayWarnings: true,  # -display-issues-are-warnings
+              # txServer: nil,          # -tx n/a
+              igs: @igs || [],
+              # NOTE: this profile must be part of a loaded IG,
+              # otherwise the response is an HTTP 500 with no content
+              profiles: [profile_url]
+            },
+            filesToValidate: [
+              {
+                fileName: "#{resource.resourceType}/#{resource.id}.json",
+                fileContent: resource.to_json,
+                fileType: 'json'
+              }
+            ],
+            sessionId: @session_id
+          }
+          wrapped_resource.to_json
+        end
+
+        # Post a resource to the validation service for validating.
+        #
+        # @param resource [FHIR::Model]
+        # @param profile_url [String]
+        # @return [String] the body of the validation response
+        def validate(resource, profile_url)
+          call_validator(resource, profile_url).body
+        end
+
+        # @private
+        def call_validator(resource, profile_url)
+          request_body = wrap_resource_for_hl7_wrapper(resource, profile_url)
+          Faraday.new(
+            url,
+            request: { timeout: 600 }
+          ).post('validate', request_body, content_type: 'application/json')
+        end
+
+        # @private
+        def operation_outcome_from_hl7_wrapped_response(response)
+          res = JSON.parse(response)
+
+          @session_id = res['sessionId']
+
+          # assume for now that one resource -> one request
+          issues = res['outcomes'][0]['issues']&.map do |i|
+            { severity: i['level'].downcase, expression: i['location'], details: { text: i['message'] } }
+          end
+          # this is circuitous, ideally we would map this response directly to message_hashes
+          FHIR::OperationOutcome.new(issue: issues)
+        end
+
+        # @private
+        def operation_outcome_from_validator_response(response, runnable)
+          if response.body.start_with? '{'
+            operation_outcome_from_hl7_wrapped_response(response.body)
+          else
+            runnable.add_message('error', "Validator Response: HTTP #{response.status}\n#{response.body}")
+            raise Inferno::Exceptions::ErrorInValidatorException,
+                  'Validator response was an unexpected format. '\
+                  'Review Messages tab or validator service logs for more information.'
+          end
+        end
+      end
+
+      module ClassMethods
+        # @private
+        def fhir_validators
+          @fhir_validators ||= {}
+        end
+
+        # Define a validator
+        # @example
+        #   fhir_resource_validator do
+        #     url 'http://example.com/validator'
+        #     exclude_message { |message| message.type == 'info' }
+        #     perform_additional_validation do |resource, profile_url|
+        #       if something_is_wrong
+        #         { type: 'error', message: 'something is wrong' }
+        #       else
+        #         { type: 'info', message: 'everything is ok' }
+        #       end
+        #     end
+        #   end
+        #
+        # @param name [Symbol] the name of the validator, only needed if you are
+        #   using multiple validators
+        # @param required_suite_options [Hash] suite options that must be
+        #   selected in order to use this validator
+        def fhir_resource_validator(name = :default, required_suite_options: nil, &block)
+          current_validators = fhir_validators[name] || []
+
+          new_validator = Inferno::DSL::FHIRResourceValidation::Validator.new(required_suite_options, &block)
+
+          current_validators.reject! { |validator| validator.requirements == required_suite_options }
+          current_validators << new_validator
+
+          fhir_validators[name] = current_validators
+        end
+      end
+    end
+  end
+end

data/lib/inferno/dsl/http_client.rb

@@ -68,9 +68,10 @@ module Inferno
       # @param name [Symbol] Name for this request to allow it to be used by
       #   other tests
       # @param headers [Hash] Input headers here
+      # @param tags [Array<String>] a list of tags to assign to the request
       # @return [Inferno::Entities::Request]
-      def get(url = '', client: :default, name: nil, headers: nil)
-        store_request('outgoing', name) do
+      def get(url = '', client: :default, name: nil, headers: nil, tags: [])
+        store_request('outgoing', name:, tags:) do
           tcp_exception_handler do
             client = http_client(client)
 
@@ -103,9 +104,10 @@ module Inferno
       # @param name [Symbol] Name for this request to allow it to be used by
       #   other tests
       # @param headers [Hash] Input headers here
+      # @param tags [Array<String>] a list of tags to assign to the request
       # @return [Inferno::Entities::Request]
-      def post(url = '', body: nil, client: :default, name: nil, headers: nil)
-        store_request('outgoing', name) do
+      def post(url = '', body: nil, client: :default, name: nil, headers: nil, tags: [])
+        store_request('outgoing', name:, tags:) do
           tcp_exception_handler do
             client = http_client(client)
 
@@ -129,9 +131,10 @@ module Inferno
       # @param name [Symbol] Name for this request to allow it to be used by
       #   other tests
       # @param headers [Hash] Input headers here
+      # @param tags [Array<String>] a list of tags to assign to the request
       # @return [Inferno::Entities::Request]
-      def delete(url = '', client: :default, name: :nil, headers: nil)
-        store_request('outgoing', name) do
+      def delete(url = '', client: :default, name: :nil, headers: nil, tags: [])
+        store_request('outgoing', name:, tags:) do
           tcp_exception_handler do
             client = http_client(client)
 
@@ -159,8 +162,9 @@ module Inferno
       # @param name [Symbol] Name for this request to allow it to be used by
       #   other tests
       # @param headers [Hash] Input headers here
+      # @param tags [Array<String>] a list of tags to assign to the request
       # @return [Inferno::Entities::Request]
-      def stream(block, url = '', limit = 100, client: :default, name: nil, headers: nil)
+      def stream(block, url = '', limit = 100, client: :default, name: nil, headers: nil, tags: [])
         streamed = []
 
         collector = proc do |chunk, bytes|
@@ -169,7 +173,7 @@ module Inferno
           block.call(chunk, bytes)
         end
 
-        store_request('outgoing', name) do
+        store_request('outgoing', name:, tags:) do
           tcp_exception_handler do
             client = http_client(client)
 

data/lib/inferno/dsl/request_storage.rb

@@ -36,24 +36,36 @@ module Inferno
         request&.resource
       end
 
+      # Returns requests which match all of the given tags
+      #
+      # @param tags [String]
+      # @return [Inferno::Entities::Request]
+      def load_tagged_requests(*tags)
+        return [] if tags.blank?
+
+        Repositories::Requests.new.tagged_requests(test_session_id, tags).tap do |tagged_requests|
+          requests.concat(tagged_requests)
+        end
+      end
+
       # @private
       def named_request(name)
         requests.find { |request| request.name == self.class.config.request_name(name.to_sym) }
       end
 
       # @private
-      def store_request(direction, name = nil, &block)
+      def store_request(direction, name: nil, tags: [], &block)
         response = block.call
 
         name = self.class.config.request_name(name)
         request =
           if response.is_a? FHIR::ClientReply
             Entities::Request.from_fhir_client_reply(
-              response, direction:, name:, test_session_id:
+              response, direction:, name:, test_session_id:, tags:
             )
           else
             Entities::Request.from_http_response(
-              response, direction:, name:, test_session_id:
+              response, direction:, name:, test_session_id:, tags:
             )
           end