Module: Inferno::DSL::Assertions

Included in:
Entities::TestGroup, Entities::TestSuite
Defined in:
lib/inferno/dsl/assertions.rb

Overview

This module contains the assertions used within tests to verify the behavior of the systems under test. Failing an assertion causes a test to immediately stop execution and receive a fail result. Additional assertions added to this module will be available in all tests.

Instance Method Summary collapse

Instance Method Details

#assert(test, message = '') ⇒ void

This method returns an undefined value.

Make an assertion

Parameters:

  • test —

    a value whose truthiness will determine whether the assertion passes or fails

  • message (String) (defaults to: '') —

    failure message

Raises:



16
17
18
 
# File 'lib/inferno/dsl/assertions.rb', line 16

def assert(test, message = '')
  raise Exceptions::AssertionException, message unless test
end

#assert_must_support_elements_present(resources, profile_url, validator_name: :default, metadata: nil, requirement_extension: nil) {|Metadata| ... } ⇒ void

This method returns an undefined value.

Check that all Must Support elements defined on the given profile are present in the given resources. Must Support elements are identified on the profile StructureDefinition and pre-parsed into metadata, which may be customized prior to the check by passing a block. Alternate metadata may be provided directly. Set test suite config flag debug_must_support_metadata: true to log the metadata to a file for debugging.

Parameters:

  • resources (Array<FHIR::Resource>)
  • profile_url (String)
  • validator_name (Symbol) (defaults to: :default) —

    Name of the FHIR Validator that references the IG the profile is in

  • metadata (Hash) (defaults to: nil) —

    MustSupport Metadata (optional), if provided the check will use this instead of re-generating metadata from the profile

  • requirement_extension (String) (defaults to: nil) —

    Extension URL that implies “required” as an alternative to the MS flag

Yields:

  • (Metadata) —

    Customize the metadata before running the test



215
216
217
218
219
220
 
# File 'lib/inferno/dsl/assertions.rb', line 215

def assert_must_support_elements_present(resources, profile_url, validator_name: :default, metadata: nil,
                                         requirement_extension: nil, &)
  missing_elements = missing_must_support_elements(resources, profile_url, validator_name:, metadata:,
                                                                           requirement_extension:, &)
  assert missing_elements.empty?, missing_must_support_elements_message(missing_elements, resources)
end

#assert_resource_type(resource_type, resource: self.resource) ⇒ void

This method returns an undefined value.

Check a FHIR resource’s type

Examples:

# The resource type can be a symbol, String, or FHIR::Model class
assert_resource_type(:capability_statement)
assert_resource_type('CapabilityStatement')
assert_resource_type(FHIR::CapabilityStatement)

Parameters:

  • resource_type (String, Symbol, Class)
  • resource (FHIR::Model) (defaults to: self.resource) 


52
53
54
55
56
57
 
# File 'lib/inferno/dsl/assertions.rb', line 52

def assert_resource_type(resource_type, resource: self.resource)
  resource_type_name = normalize_resource_type(resource_type)

  assert resource&.resourceType == resource_type_name,
         bad_resource_type_message(resource_type_name, resource&.resourceType)
end

#assert_response_content_type(type, request: self.request) ⇒ void

This method returns an undefined value.

Check the Content-Type header of a response. This assertion will fail if the response’s content type does not begin with the provided type.

Parameters:



185
186
187
188
189
190
 
# File 'lib/inferno/dsl/assertions.rb', line 185

def assert_response_content_type(type, request: self.request)
  header = request.response_header('Content-Type')
  assert header.present?, no_content_type_message

  assert header.value.start_with?(type), bad_content_type_message(type, header.value)
end

#assert_response_status(status, request: self.request, response: nil) ⇒ void

This method returns an undefined value.

Check a response’s status

Parameters:

  • status (Integer, Array<Integer>) —

    a single integer or an array of integer status codes

  • request (Inferno::Entities::Request) (defaults to: self.request)
  • response (Hash) (defaults to: nil) 


32
33
34
35
 
# File 'lib/inferno/dsl/assertions.rb', line 32

def assert_response_status(status, request: self.request, response: nil)
  response ||= request&.response
  assert Array.wrap(status).include?(response[:status]), bad_response_status_message(status, response[:status])
end

#assert_valid_bundle_entries(bundle: resource, resource_types: {}) ⇒ void

This method returns an undefined value.

Validate each entry of a Bundle

[String,Symbol,FHIR::Model,Array<String,Symbol,FHIR::Model>,Hash] If a string, symbol, or FHIR::Model is provided, only that resource type will be validated. If an array of strings is provided, only those resource types will be validated. If a hash is provided with resource 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.

Examples:

# Only validate Patient bundle entries
assert_valid_bundle_entries(resource_types: 'Patient')

# Only valiadte Patient and Condition bundle entries
assert_valid_bundle_entries(resource_types: ['Patient', 'Condition'])

# Only validate Patient and Condition bundle entries. Validate Patient
# resources against the given profile, and Codition resources against the
# base FHIR Condition resource.
assert_valid_bundle_entries(
  resource_types: {
    'Patient': 'http://hl7.org/fhir/us/core/StructureDefinition/us-core-patient',
    'Condition': nil
  }
)

Parameters:

  • bundle (FHIR::Bundle) (defaults to: resource)
  • resource_types (defaults to: {}) 


107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
 
# File 'lib/inferno/dsl/assertions.rb', line 107

def assert_valid_bundle_entries(bundle: resource, resource_types: {})
  assert_resource_type('Bundle', resource: bundle)

  types_to_check = normalize_types_to_check(resource_types)

  invalid_resources =
    bundle
      .entry
      .map(&:resource)
      .select { |resource| types_to_check.empty? || types_to_check.include?(resource.resourceType) }
      .reject do |resource|
        validation_params = { resource: }
        profile = types_to_check[resource.resourceType]
        validation_params[:profile_url] = profile if profile

        resource_is_valid?(**validation_params)
      end

  assert invalid_resources.empty?, invalid_bundle_entries_message(invalid_resources)
end

#assert_valid_http_uri(uri, message = '') ⇒ void

This method returns an undefined value.

Check for a valid http/https uri

Parameters:

  • uri (String)
  • message (String) (defaults to: '') —

    custom failure message



174
175
176
177
 
# File 'lib/inferno/dsl/assertions.rb', line 174

def assert_valid_http_uri(uri, message = '')
  error_message = message.presence || "\"#{uri}\" is not a valid URI"
  assert uri =~ /\A#{URI::DEFAULT_PARSER.make_regexp(['http', 'https'])}\z/, error_message
end

#assert_valid_json(maybe_json_string, message = '') ⇒ void

This method returns an undefined value.

Check for valid JSON

Parameters:

  • maybe_json_string (String)
  • message (String) (defaults to: '') —

    extra failure message



163
164
165
166
167
 
# File 'lib/inferno/dsl/assertions.rb', line 163

def assert_valid_json(maybe_json_string, message = '')
  assert JSON.parse(maybe_json_string)
rescue JSON::ParserError
  assert false, "Invalid JSON. #{message}"
end

#assert_valid_resource(resource: self.resource, profile_url: nil, validator: :default) ⇒ void

This method returns an undefined value.

Validate a FHIR resource

Parameters:

  • resource (FHIR::Model) (defaults to: self.resource)
  • profile_url (String) (defaults to: nil) —

    canonical url of the profile to validate against, may include a version separated by a vertical bar (|), and defaults to validating against the base FHIR resource type

  • validator (Symbol) (defaults to: :default) —

    the name of the validator to use



74
75
76
77
 
# File 'lib/inferno/dsl/assertions.rb', line 74

def assert_valid_resource(resource: self.resource, profile_url: nil, validator: :default)
  assert resource_is_valid?(resource:, profile_url:, validator:),
         invalid_resource_message(resource, profile_url)
end