inferno_core 1.1.0 → 1.1.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 11e324b2bb99be1f0100e0b37829fa92668feab98fe2424f301a73ca70a82542
-  data.tar.gz: 074fce8e9975dad0acebad6276c029016ffb219dcedc4e056970f8cadc7e63f6
+  metadata.gz: cc9addf71b6ea91eb5aa426eabe24df9a2cbdb3199271e3f60d8e66f1cacd8cc
+  data.tar.gz: 16fd0eaf84e1c2a391ba90efcedbeae1a24f82ad45dcc9b7a8b5e2365ed3d53d
 SHA512:
-  metadata.gz: 303453ddfa0ecaedf8f68359f2cc90041372f74736917e3313bcde9c1f9c90edae4b271cbd422f3e875e373e32177a9ab814d12e65fa5214c13a4262b71e5d27
-  data.tar.gz: 06eac23eb184c16cce19b5a6dceac53d73f87bd77baea45c8f138a384414cf683aff7ea9a5233cc254a8effdce3144b5b9bcee18468110977a6cbe43be445c93
+  metadata.gz: 0eed6f34c2f0cfd4a78f12d7dc4ce853480520d740e4af6da052ec4b4eb2d3551ff4208e99516990438a957dcccf8a0ad38f01aaae34224b5286086fb88d4095
+  data.tar.gz: 0fc841b4d2ad71f098061277d9041caa6633e36679276ca6db2db8553c22a383d63c950196aacb661b9175b398aa8e80da5f5e8cd9b90d377019afb8b14d04b9

data/lib/inferno/apps/web/serializers/test.rb

@@ -21,6 +21,7 @@ module Inferno
         field :input_instructions
         field :user_runnable?, name: :user_runnable
         field :optional?, name: :optional
+        field :simulation_verification?, name: :is_simulation_verification
         field :verifies_requirements, if: :field_present?, extractor: RequirementsFilteringExtractor
       end
     end

data/lib/inferno/dsl/assertions.rb

@@ -1,4 +1,5 @@
 require_relative '../exceptions'
+require_relative 'messages'
 
 module Inferno
   module DSL
@@ -7,6 +8,7 @@ module Inferno
     # immediately stop execution and receive a `fail` result. Additional
     # assertions added to this module will be available in all tests.
     module Assertions
+      include Messages
       # Make an assertion
       #
       # @param test a value whose truthiness will determine whether the
@@ -59,6 +61,7 @@ module Inferno
       # @private
       def invalid_resource_message(resource, profile_url)
         return "Resource does not conform to the profile: #{profile_url}" if profile_url.present?
+        return 'No resource to validate.' unless resource.present?
 
         "Resource does not conform to the base #{resource&.resourceType} profile."
       end
@@ -70,12 +73,31 @@ module Inferno
       #   may include a version separated by a vertical bar (|),
       #   and defaults to validating against the base FHIR resource type
       # @param validator [Symbol] the name of the validator to use
+      # @param message_prefix [String] Prefix to add to the start of logged messages
       # @return [void]
-      def assert_valid_resource(resource: self.resource, profile_url: nil, validator: :default)
-        assert resource_is_valid?(resource:, profile_url:, validator:),
+      def assert_valid_resource(resource: self.resource, profile_url: nil, validator: :default, message_prefix: '')
+        assert resource_is_valid?(resource:, profile_url:, validator:, message_prefix:),
                invalid_resource_message(resource, profile_url)
       end
 
+      # @private
+      def invalid_object_message(model_url)
+        "Object does not conform to the logical model: #{model_url}"
+      end
+
+      # Validate an object against a logical model
+      #
+      # @param object [Hash]
+      # @param model_url [String] canonical url of the model to validate against,
+      #   may include a version separated by a vertical bar (|),
+      # @param validator [Symbol] the name of the validator to use
+      # @param message_prefix [String] Prefix to add to the start of logged messages
+      # @return [void]
+      def assert_conformance_to_logical_model(object, model_url, validator: :default, message_prefix: '')
+        assert conforms_to_logical_model?(object, model_url, validator:, message_prefix:),
+               invalid_object_message(model_url)
+      end
+
       # Validate each entry of a Bundle
       #
       # @param bundle [FHIR::Bundle]
@@ -87,6 +109,7 @@ module Inferno
       #   types as keys and profile urls (or nil) as values, only those resource
       #   types will be validated against the provided profile url or the base
       #   resource if nil.
+      # @param message_prefix [String] Prefix to add to the start of logged messages
       # @example
       #   # Only validate Patient bundle entries
       #   assert_valid_bundle_entries(resource_types: 'Patient')
@@ -104,7 +127,7 @@ module Inferno
       #     }
       #   )
       # @return [void]
-      def assert_valid_bundle_entries(bundle: resource, resource_types: {})
+      def assert_valid_bundle_entries(bundle: resource, resource_types: {}, message_prefix: '')
         assert_resource_type('Bundle', resource: bundle)
 
         types_to_check = normalize_types_to_check(resource_types)
@@ -115,7 +138,7 @@ module Inferno
             .map(&:resource)
             .select { |resource| types_to_check.empty? || types_to_check.include?(resource.resourceType) }
             .reject do |resource|
-              validation_params = { resource: }
+              validation_params = { resource:, message_prefix: }
               profile = types_to_check[resource.resourceType]
               validation_params[:profile_url] = profile if profile
 
@@ -161,9 +184,25 @@ module Inferno
       # @param message [String] extra failure message
       # @return [void]
       def assert_valid_json(maybe_json_string, message = '')
-        assert JSON.parse(maybe_json_string)
+        parsed_json_if_valid(maybe_json_string, message, continue: false)
+      end
+
+      # Return parsed json Hash if valid, or indicate an error with an error message or a failed assert
+      #
+      # @param maybe_json_string [String]
+      # @param message [String] extra failure message
+      # @param continue [Boolean] if true will log an error message and continue,
+      #        otherwise will raise an assert exception
+      # @return [void]
+      def parsed_json_if_valid(maybe_json_string, message = '', continue: true)
+        JSON.parse(maybe_json_string)
       rescue JSON::ParserError
-        assert false, "Invalid JSON. #{message}"
+        if continue
+          add_message(:error, "Invalid JSON. #{message}")
+          nil
+        else
+          assert false, "Invalid JSON. #{message}"
+        end
       end
 
       # Check for a valid http/https uri
@@ -224,6 +263,16 @@ module Inferno
         "Could not find #{missing_elements.join(', ')} in the #{resources.length} " \
           'provided resource(s)'
       end
+
+      # Check that there are no messages associated with the current runnable with a type of 'error'
+      #
+      # @param message [String] failure message
+      # @param message_list [Array] (optional) list of messages to check for errors,
+      #        if different from the runnable's messages
+      # @return [void]
+      def assert_no_error_messages(message = '', message_list: messages)
+        assert !error_messages?(message_list:), message.present? ? message : 'Errors found - see Messages for details.'
+      end
     end
   end
 end

data/lib/inferno/dsl/fhir_client.rb

@@ -1,6 +1,7 @@
 require_relative 'fhir_client_builder'
 require_relative 'request_storage'
 require_relative 'tcp_exception_handler'
+require_relative 'messages'
 
 module Inferno
   module DSL
@@ -37,6 +38,8 @@ module Inferno
     # @see Inferno::DSL::FHIRClientBuilder Documentation for the client
     #   configuration DSL
     module FHIRClient
+      include Messages
+
       # @private
       def self.included(klass)
         klass.extend ClassMethods

data/lib/inferno/dsl/fhir_resource_validation.rb

@@ -1,5 +1,6 @@
 require_relative '../ext/fhir_models'
 require_relative '../feature'
+require_relative '../exceptions'
 module Inferno
   module DSL
     # This module contains the methods needed to configure a validator to
@@ -159,6 +160,37 @@ module Inferno
           @exclude_message
         end
 
+        # Validate a FHIR resource and determine if it's valid.
+        # Adds validation messages to the runnable if add_messages_to_runnable is true.
+        def conforms_to_logical_model?(object, model_url, runnable, add_messages_to_runnable: true,
+                                       message_prefix: '', validator_response_details: nil)
+
+          unless model_url.present?
+            raise Inferno::Exceptions::TestSuiteImplementationException.new(
+              'Logical Model Validation',
+              'The profile of the logical model must be provided.'
+            )
+          end
+
+          unless object.present?
+            if add_messages_to_runnable
+              runnable.add_message(:error,
+                                   "#{message_prefix}No object to check for conformance.")
+            end
+            return false
+          end
+
+          unless object.is_a?(Hash)
+            raise Inferno::Exceptions::TestSuiteImplementationException.new(
+              'Logical Model Validation',
+              "Expected a Hash, got a #{object.class}."
+            )
+          end
+
+          conformant?(object, model_url, runnable, add_messages_to_runnable:, message_prefix:,
+                                                   validator_response_details:)
+        end
+
         # Validate a FHIR resource and determine if it's valid.
         # Adds validation messages to the runnable if add_messages_to_runnable is true.
         #
@@ -167,29 +199,51 @@ module Inferno
         # @param profile_url [String] the profile URL to validate against
         # @param runnable [Object] the runnable context (test/group/suite)
         # @param add_messages_to_runnable [Boolean] whether to add messages to the runnable
+        # @param message_prefix [String] Prefix to add to the start of logged messages
         # @param validator_response_details [Array, nil] if not nil, the service will populate this array with
         #   the detailed response message from the validator service. Can be used by test kits to perform custom
         #   handling of error messages.
         # @return [Boolean] true if the resource is valid
         def resource_is_valid?(resource, profile_url, runnable, add_messages_to_runnable: true,
-                               validator_response_details: nil)
+                               message_prefix: '', validator_response_details: nil)
+
+          unless resource.present?
+            runnable.add_message(:error, "#{message_prefix}No resource to validate.") if add_messages_to_runnable
+            return false
+          end
+
+          unless resource.is_a?(FHIR::Model)
+            raise Inferno::Exceptions::TestSuiteImplementationException.new(
+              'FHIR Resource Validation',
+              "Expected a FHIR::Model, got a #{resource.class}."
+            )
+
+          end
           profile_url ||= FHIR::Definitions.resource_definition(resource.resourceType).url
 
+          conformant?(resource, profile_url, runnable, add_messages_to_runnable:, message_prefix:,
+                                                       validator_response_details:)
+        end
+
+        # @private
+        def conformant?(target, profile_url, runnable, add_messages_to_runnable: true,
+                        message_prefix: '', validator_response_details: nil)
+
           # 1. Get raw content from validator
-          response = get_raw_validator_content(resource, profile_url, runnable)
+          response = get_raw_validator_content(target, profile_url, runnable)
 
           # 2. Convert to validation issues
-          issues = get_issues_from_validator_response(response, resource)
+          issues = get_issues_from_validator_response(response, target)
 
           # 3. Add additional validation messages
-          issues = join_additional_validation_messages(issues, resource, profile_url)
+          issues = join_additional_validation_messages(issues, target, profile_url)
 
           # 4. Mark resources as filtered
           mark_issues_for_filtering(issues)
 
           # 5. Add error messages to runnable
           filtered_issues = issues.reject(&:filtered)
-          add_validation_messages_to_runnable(runnable, filtered_issues) if add_messages_to_runnable
+          add_validation_messages_to_runnable(runnable, filtered_issues, message_prefix:) if add_messages_to_runnable
           validator_response_details&.concat(issues)
 
           # 6. Return validity
@@ -204,12 +258,12 @@ module Inferno
 
         # @private
         # Gets raw content from validator including error handling
-        # @param resource [FHIR::Model] the resource to validate
+        # @param target [FHIR::Model, Hash] the object to validate
         # @param profile_url [String] the profile URL to validate against
         # @param runnable [Object] the runnable context
         # @return [Faraday::Response] the HTTP response from the validator
-        def get_raw_validator_content(resource, profile_url, runnable)
-          response = call_validator(resource, profile_url)
+        def get_raw_validator_content(target, profile_url, runnable)
+          response = call_validator(target, profile_url)
 
           unless response.status == 200
             raise Inferno::Exceptions::ErrorInValidatorException,
@@ -225,19 +279,19 @@ module Inferno
 
         # @private
         # Adds validation messages to the runnable
-        def add_validation_messages_to_runnable(runnable, filtered_issues)
+        def add_validation_messages_to_runnable(runnable, filtered_issues, message_prefix: '')
           filtered_issues.each do |issue|
-            runnable.add_message(issue.severity, issue.message)
+            runnable.add_message(issue.severity, "#{message_prefix}#{issue.message}")
           end
         end
 
         # Warm up the validator session by sending a test validation request.
         # This initializes the validator session and persists it for future use.
         #
-        # @param resource [FHIR::Model] the resource to validate
+        # @param target [FHIR::Model, Hash] the object to validate
         # @param profile_url [String] the profile URL to validate against
-        def warm_up(resource, profile_url)
-          response_body = validate(resource, profile_url)
+        def warm_up(target, profile_url)
+          response_body = validate(target, profile_url)
           res = JSON.parse(response_body)
           session_id = res['sessionId']
           validator_session_repo.save(test_suite_id:, validator_session_id: session_id,
@@ -253,9 +307,9 @@ module Inferno
         # Recursively processes slice information.
         #
         # @param response [Faraday::Response] the HTTP response from the validator
-        # @param resource [FHIR::Model] the resource being validated
+        # @param target [FHIR::Model, Hash] the object being validated
         # @return [Array<ValidatorIssue>] list of validator issues
-        def get_issues_from_validator_response(response, resource)
+        def get_issues_from_validator_response(response, target)
           response_body = remove_invalid_characters(response.body)
           response_hash = JSON.parse(response_body)
 
@@ -268,7 +322,7 @@ module Inferno
           raw_issues = response_hash.dig('outcomes', 0, 'issues') || []
 
           raw_issues.map do |raw_issue|
-            convert_raw_issue_to_validator_issue(raw_issue, resource)
+            convert_raw_issue_to_validator_issue(raw_issue, target)
           end
         end
 
@@ -277,28 +331,28 @@ module Inferno
         # Recursively processes sliceInfo if present.
         #
         # @param raw_issue [Hash] the raw issue from validator response
-        # @param resource [FHIR::Model] the resource being validated
+        # @param target [FHIR::Model, Hash] the object being validated
         # @return [ValidatorIssue] the converted validator issue
-        def convert_raw_issue_to_validator_issue(raw_issue, resource)
+        def convert_raw_issue_to_validator_issue(raw_issue, target)
           # Recursively process sliceInfo
           slice_info = []
           if raw_issue['sliceInfo']&.any?
             slice_info = raw_issue['sliceInfo'].map do |slice_issue|
-              convert_raw_issue_to_validator_issue(slice_issue, resource)
+              convert_raw_issue_to_validator_issue(slice_issue, target)
             end
           end
 
           ValidatorIssue.new(
             raw_issue: raw_issue,
-            resource: resource,
+            target: target,
             slice_info: slice_info,
             filtered: false
           )
         end
 
         # @private
-        def call_validator(resource, profile_url)
-          request_body = wrap_resource_for_hl7_wrapper(resource, profile_url)
+        def call_validator(target, profile_url)
+          request_body = wrap_target_for_hl7_wrapper(target, profile_url)
           Faraday.new(
             url,
             request: { timeout: 600 }
@@ -306,14 +360,14 @@ module Inferno
         end
 
         # @private
-        # Post a resource to the validation service for validating.
+        # Post an object to the validation service for validating.
         # Returns the raw validator response body.
         #
-        # @param resource [FHIR::Model]
+        # @param target [FHIR::Model, Hash]
         # @param profile_url [String]
         # @return [String] the body of the validation response
-        def validate(resource, profile_url)
-          call_validator(resource, profile_url).body
+        def validate(target, profile_url)
+          call_validator(target, profile_url).body
         end
 
         # Add a specific error message for specific network problems to help the user
@@ -351,11 +405,11 @@ module Inferno
         # Joins additional validation messages to the issues list
         #
         # @param issues [Array<ValidatorIssue>] the list of validator issues
-        # @param resource [FHIR::Model] the resource being validated
+        # @param target [FHIR::Model] the object being validated
         # @param profile_url [String] the profile URL being validated against
         # @return [Array<ValidatorIssue>] the complete list of issues including additional messages
-        def join_additional_validation_messages(issues, resource, profile_url)
-          additional_issues = additional_validation_messages(resource, profile_url)
+        def join_additional_validation_messages(issues, target, profile_url)
+          additional_issues = additional_validation_messages(target, profile_url)
           issues + additional_issues
         end
 
@@ -376,12 +430,12 @@ module Inferno
         # Gets additional validation messages from custom validation blocks.
         # Converts the message hashes to ValidatorIssue objects.
         #
-        # @param resource [FHIR::Model] the resource being validated
+        # @param target [FHIR::Model, Hash] the object being validated
         # @param profile_url [String] the profile URL being validated against
         # @return [Array<ValidatorIssue>] list of additional validator issues
-        def additional_validation_messages(resource, profile_url)
+        def additional_validation_messages(target, profile_url)
           additional_validations
-            .flat_map { |step| step.call(resource, profile_url) }
+            .flat_map { |step| step.call(target, profile_url) }
             .select { |message| message.is_a? Hash }
             .map do |message_hash|
               # Create a synthetic raw_issue for additional validation messages
@@ -392,7 +446,7 @@ module Inferno
               }
               ValidatorIssue.new(
                 raw_issue: synthetic_raw_issue,
-                resource: resource,
+                target: target,
                 slice_info: [],
                 filtered: false
               )
@@ -536,7 +590,7 @@ module Inferno
         end
 
         # @private
-        def wrap_resource_for_hl7_wrapper(resource, profile_url)
+        def wrap_target_for_hl7_wrapper(target, profile_url)
           validator_session_id =
             validator_session_repo.find_validator_session_id(test_suite_id,
                                                              name.to_s, requirements)
@@ -547,6 +601,13 @@ module Inferno
           # This allows backward compatibility until the validator-wrapper is updated.
           context_key = Feature.use_validation_context_key? ? :validationContext : :cliContext
 
+          file_contents =
+            if target.is_a?(Hash)
+              target.to_json
+            else
+              target.source_contents
+            end
+
           wrapped_resource = {
             context_key => {
               **validation_context.definition,
@@ -554,8 +615,8 @@ module Inferno
             },
             filesToValidate: [
               {
-                fileName: "#{resource.resourceType}/#{resource.id}.json",
-                fileContent: resource.source_contents,
+                fileName: "#{profile_url.split('/').last}.json",
+                fileContent: file_contents,
                 fileType: 'json'
               }
             ],
@@ -598,16 +659,16 @@ module Inferno
       # ValidatorIssue represents a single validation issue returned from the FHIR validator
       class ValidatorIssue
         attr_accessor :filtered, :raw_issue, :slice_info
-        attr_reader :resource
+        attr_reader :target
 
         # Creates a new ValidatorIssue
         # @param raw_issue [Hash] the raw issue hash from the validator response
-        # @param resource [FHIR::Model] the resource being validated
+        # @param target [FHIR::Model, Hash] the object being validated
         # @param slice_info [Array<ValidatorIssue>] nested slice information as ValidatorIssue objects
         # @param filtered [Boolean] whether this issue has been filtered out
-        def initialize(raw_issue:, resource:, slice_info: [], filtered: false)
+        def initialize(raw_issue:, target:, slice_info: [], filtered: false)
           @raw_issue = raw_issue
-          @resource = resource
+          @target = target
           @slice_info = slice_info
           @filtered = filtered
         end
@@ -641,8 +702,15 @@ module Inferno
           # Don't add prefix for additional validation messages
           return details_text if location_value == 'additional_validation'
 
-          location_prefix = resource.id ? "#{resource.resourceType}/#{resource.id}" : resource.resourceType
-          "#{location_prefix}: #{location_value}: #{details_text}"
+          "#{location_prefix}#{location_value}: #{details_text}"
+        end
+
+        def location_prefix
+          if target.is_a?(Hash)
+            ''
+          else
+            "#{target.id ? "#{target.resourceType}/#{target.id}" : target.resourceType}: "
+          end
         end
 
         # Converts the validator's severity level to our standard format

data/lib/inferno/dsl/fhir_validation.rb

@@ -1,4 +1,5 @@
 require_relative '../ext/fhir_models'
+require_relative '../exceptions'
 module Inferno
   module DSL
     # This module contains the methods needed to configure a validator to
@@ -32,19 +33,42 @@ module Inferno
       # @param profile_url [String]
       # @param validator [Symbol] the name of the validator to use
       # @param add_messages_to_runnable [Boolean] whether to add validation messages to runnable or not
+      # @param message_prefix [String] Prefix to add to the start of logged messages
       # @param validator_response_details [Array, nil] if not nil, the service will populate this array with
       #   the detailed response message from the validator service
       # @return [Boolean] whether the resource is valid
       def resource_is_valid?(
         resource: self.resource, profile_url: nil,
-        validator: :default, add_messages_to_runnable: true,
+        validator: :default, add_messages_to_runnable: true, message_prefix: '',
         validator_response_details: nil
       )
         find_validator(validator).resource_is_valid?(resource, profile_url, self,
                                                      add_messages_to_runnable:,
+                                                     message_prefix:,
                                                      validator_response_details:)
       end
 
+      # Perform validation, and add validation messages to the runnable
+      #
+      # @param object [Hash] json to verify against the model, as a Hash
+      # @param model_url [String]
+      # @param validator [Symbol] the name of the validator to use
+      # @param add_messages_to_runnable [Boolean] whether to add validation messages to runnable or not
+      # @param message_prefix [String] Prefix to add to the start of logged messages
+      # @param validator_response_details [Array, nil] if not nil, the service will populate this array with
+      #   the detailed response message from the validator service
+      # @return [Boolean] whether the resource is valid
+      def conforms_to_logical_model?(
+        object, model_url,
+        validator: :default, add_messages_to_runnable: true, message_prefix: '',
+        validator_response_details: nil
+      )
+        find_validator(validator).conforms_to_logical_model?(object, model_url, self,
+                                                             add_messages_to_runnable:,
+                                                             message_prefix:,
+                                                             validator_response_details:)
+      end
+
       # Find a particular validator. Looks through a runnable's parents up to
       # the suite to find a validator with a particular name
       def find_validator(validator_name)
@@ -122,10 +146,21 @@ module Inferno
           @exclude_message
         end
 
+        # rubocop:disable Lint/UnusedMethodArgument
+        def conforms_to_logical_model?(resource, profile_url, runnable, add_messages_to_runnable: true,
+                                       message_prefix: '', validator_response_details: nil)
+
+          raise Exceptions::TestSuiteImplementationException.new(
+            'Logical Model Validation',
+            'Logical model validation not implemented for legacy fhir_validation.'
+          )
+        end
+        # rubocop:enable Lint/UnusedMethodArgument
+
         # @see Inferno::DSL::FHIRValidation#resource_is_valid?
         # rubocop:disable Metrics/CyclomaticComplexity, Lint/UnusedMethodArgument
         def resource_is_valid?(resource, profile_url, runnable, add_messages_to_runnable: true,
-                               validator_response_details: nil)
+                               message_prefix: '', validator_response_details: nil)
           profile_url ||= FHIR::Definitions.resource_definition(resource.resourceType).url
 
           begin

data/lib/inferno/dsl/http_client.rb

@@ -126,6 +126,34 @@ module Inferno
         end
       end
 
+      # Perform an HTTP PUT request
+      #
+      # @param url [String] if this request is using a defined client, this will
+      #   be appended to the client's url. Must be an absolute url for requests
+      #   made without a defined client
+      # @param body [String]
+      # @param client [Symbol]
+      # @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 put(url = '', body: nil, client: :default, name: nil, headers: nil, tags: [])
+        store_request('outgoing', name:, tags:) do
+          tcp_exception_handler do
+            client = http_client(client)
+
+            if client
+              client.put(url, body, headers)
+            elsif url.match?(%r{\Ahttps?://})
+              connection.put(url, body, headers)
+            else
+              raise StandardError, 'Must use an absolute url or define an HTTP client with a base url'
+            end
+          end
+        end
+      end
+
       # Perform an HTTP DELETE request
       #
       # @param url [String] if this request is using a defined client, this will

data/lib/inferno/dsl/messages.rb

@@ -1,4 +1,5 @@
 require_relative '../utils/markdown_formatter'
+require_relative '../exceptions'
 
 module Inferno
   module DSL
@@ -10,6 +11,15 @@ module Inferno
         @messages ||= []
       end
 
+      # Returns true if an error message was logged to the runnable
+      #
+      # @param message_list [Array] (optional) list of messages to check for error,
+      #        if not provided, the runnable's current list of messages will be checked
+      # @return [Boolean]
+      def error_messages?(message_list: messages)
+        message_list.any? { |msg| msg[:type] == 'error' }
+      end
+
       # Add a message to the result.
       #
       # @param type [String] error, warning, or info

data/lib/inferno/dsl/runnable.rb

@@ -309,6 +309,21 @@ module Inferno
         !optional?
       end
 
+      # Mark as simulation verification. Tests are not simulation verification by default.
+      #
+      # @param simulation_verification [Boolean]
+      # @return [void]
+      def simulation_verification(simulation_verification = true) # rubocop:disable Style/OptionalBooleanParameter
+        @is_simulation_verification = simulation_verification
+      end
+
+      # The test is simulation verification if true
+      #
+      # @return [Boolean]
+      def simulation_verification?
+        !!@is_simulation_verification
+      end
+
       # @private
       def default_id
         to_s

data/lib/inferno/exceptions.rb

@@ -137,5 +137,12 @@ module Inferno
         super("Could not find a child with an ID ending in '#{id}' for '#{runnable}'.")
       end
     end
+
+    class TestSuiteImplementationException < StandardError
+      def initialize(feature, details)
+        super("This test suite incorrectly used the #{feature}. " \
+              "Contact the developer with the following details: #{details}")
+      end
+    end
   end
 end