class Crucible::Tests::BaseTestScript

Constants

CODE_MAP
FORMAT_MAP
OPERATOR_MAP

Public Class Methods

new(testscript, client, client2=nil) click to toggle source
Calls superclass method Crucible::Tests::BaseTest::new
# File lib/tests/testscripts/base_testscript.rb, line 38
def initialize(testscript, client, client2=nil)
  super(client, client2)
  @category = {id: 'testscript', title: 'TestScript'}
  @id_map = {}
  @response_map = {}
  @autocreate = []
  @autodelete = []
  @testscript = testscript
  @preprocessed_vars = {}
  define_tests
  load_fixtures
end

Public Instance Methods

action_failed?(action) click to toggle source
# File lib/tests/testscripts/base_testscript.rb, line 239
def action_failed?(action)
  return true if action.nil?
  if action.operation
    ['fail','error'].include?(action.operation.result)
  elsif action.assert
    ['fail','error'].include?(action.assert.result)
  else
    true
  end
end
author() click to toggle source
# File lib/tests/testscripts/base_testscript.rb, line 51
def author
  @testscript.name
end
call_assertion(method, *params) click to toggle source
# File lib/tests/testscripts/base_testscript.rb, line 563
def call_assertion(method, *params)
  FHIR.logger.debug "Assertion: #{method}"
  self.method(method).call(*params)
end
collect_metadata(_methods_only=nil) click to toggle source
# File lib/tests/testscripts/base_testscript.rb, line 119
def collect_metadata(_methods_only=nil)
  metadata = {}
  metadata['links'] = []
  metadata['requires'] = nil
  metadata['validates'] = nil

  if @testscript.metadata
    @testscript.metadata.link.each do |link|
      metadata['links'] << link.url
    end
    @testscript.metadata.capability.each do |capability|
      capability.link.each{|url| metadata['links'] << url }
      metadata['links'] << capability.capabilities.reference if capability.capabilities.reference
    end
  end

  {
    @testscript.id => @testscript.test.map do |test|
      {
        "key" => "#{test.id} #{test.name} test".downcase.tr(' ', '_'),
        "id" =>  "#{test.id} #{test.name} test".downcase.tr(' ', '_'),
        "description" => test.description,
        :test_method=> "#{test.id} #{test.name} test".downcase.tr(' ', '_').to_sym

      }.merge(metadata)
    end
  }

end
containsRuleAssertions?() click to toggle source
# File lib/tests/testscripts/base_testscript.rb, line 71
def containsRuleAssertions?
  has_declared_rule = !@testscript.rule.empty? || !@testscript.ruleset.empty?
  return true if has_declared_rule

  if @testscript.setup
    has_setup_rule = @testscript.setup.action.find{ |action| action.assert && (action.assert.rule || action.assert.ruleset) }
    return true if has_setup_rule
  end

  has_test_rule = @testscript.test.find do |test|
    test.action.find{ |action| action.assert && (action.assert.rule || action.assert.ruleset) }
  end
  return true if has_test_rule

  false
end
debug_prefix() click to toggle source
# File lib/tests/testscripts/base_testscript.rb, line 92
def debug_prefix
  "[TESTSCRIPT]:\t"
end
define_tests() click to toggle source
# File lib/tests/testscripts/base_testscript.rb, line 102
def define_tests
  @testscript.test.each do |test|
    test_method = "#{test.id} #{test.name} test".downcase.tr(' ', '_').to_sym
    define_singleton_method test_method, -> { process_test(test) }
  end
end
description() click to toggle source
# File lib/tests/testscripts/base_testscript.rb, line 55
def description
  @testscript.description
end
execute_operation(operation) click to toggle source

Returns a FHIR::TestReport::Setup::Action::Operation

# File lib/tests/testscripts/base_testscript.rb, line 318
def execute_operation(operation)
  return nil if @client.nil?
  result = FHIR::TestReport::Setup::Action::Operation.new({
    'result' => 'pass',
    'message' => operation.description
    })

  requestHeaders = Hash[(operation.requestHeader || []).map{|u| [u.field, u.value]}] #Client needs upgrade to support
  format = FHIR::Formats::ResourceFormat::RESOURCE_XML
  format = FORMAT_MAP[operation.contentType] unless operation.contentType.nil?
  format = FORMAT_MAP[operation.accept] unless operation.accept.nil?

  operationCode = 'empty'
  operationCode = operation.type.code unless operation.type.nil?

  case operationCode
  when 'read'
    if operation.targetId
      @last_response = @client.read @fixtures[operation.targetId].class, @id_map[operation.targetId], format
    elsif operation.url
      @last_response = @client.get replace_variables(operation.url), @client.fhir_headers({ format: format})
      @last_response.resource = FHIR.from_contents(@last_response.body)
      @last_response.resource_class = @last_response.resource.class
    else
      resource_type = replace_variables(operation.resource)
      resource_id = replace_variables(operation.params)
      @last_response = @client.read "FHIR::#{resource_type}".constantize, id_from_path(resource_id), format
    end
  when 'vread'
    if operation.url
      @last_response = @client.get replace_variables(operation.url), @client.fhir_headers({ format: format})
      @last_response.resource = FHIR.from_contents(@last_response.body)
      @last_response.resource_class = @last_response.resource.class
    else
      resource_type = replace_variables(operation.resource)
      resource_id = replace_variables(operation.params)
      @last_response = @client.read "FHIR::#{resource_type}".constantize, resource_id, format
    end
  when 'search'
    if operation.url.nil?
      params = extract_operation_parameters(operation)
      @last_response = @client.search "FHIR::#{operation.resource}".constantize, {search: {parameters: params}}, format
    else
      url = replace_variables(operation.url)
      @last_response = @client.search "FHIR::#{operation.resource}".constantize, url: url #todo implement URL
    end
  when 'history'
    target_id = @id_map[operation.targetId]
    fixture = @fixtures[operation.targetId]
    @last_response = @client.resource_instance_history(fixture.class,target_id)
  when 'create'
    @last_response = @client.base_create(@fixtures[operation.sourceId], requestHeaders, format)
    @id_map[operation.sourceId] = @last_response.id
  when 'update','updateCreate'
    target_id = nil
    
    if !operation.targetId.nil? 
      target_id = @id_map[operation.targetId]
    elsif !operation.params.nil?
      target_id = id_from_path(replace_variables(operation.params))
    end

    fixture = @fixtures[operation.sourceId]
    fixture.id = replace_variables(target_id) if fixture.id.nil?
    @last_response = @client.update fixture, replace_variables(target_id), format
  when 'transaction'
    result.result = 'error'
    result.message = 'transaction not implemented'
  when 'conformance'
    result.result = 'error'
    result.message = 'conformance not implemented'
  when 'delete'
    if operation.targetId.nil?
      params = replace_variables(operation.params)
      @last_response = @client.destroy "FHIR::#{operation.resource}".constantize, nil, params: params
    else
      @last_response = @client.destroy @fixtures[operation.targetId].class, @id_map[operation.targetId]
      @id_map.delete(operation.targetId)
    end
  when '$expand'
    result.result = 'error'
    result.message = '$expand not supported'
    # @last_response = @client.value_set_expansion( extract_operation_parameters(operation) )
  when '$validate'
    result.result = 'error'
    result.message = '$validate not supported'
    # @last_response = @client.value_set_code_validation( extract_operation_parameters(operation) )
  when '$validate-code'
    result.result = 'error'
    result.message = '$validate-code not supported'
    # options = {
    #   :operation => {
    #     :method => 'GET',
    #     :parameters => {
    #       'code' => { type: 'Code', value: params['code'] },
    #       'identifier' => { type: 'Uri', value: params['system'] }
    #     }
    #   }
    # }
    # @last_response = @client.value_set_code_validation(options)
  when 'empty'
    if !operation.params.nil? && !operation.resource.nil?
      resource = "FHIR::#{operation.resource}".constantize 
      @last_response = @client.read resource, nil, FORMAT_MAP[operation.accept], nil, params: replace_variables(operation.params)
    end
  else
    result.result = 'error'
    result.message = "Undefined operation #{operation.type.to_json}"
    FHIR.logger.error(result.message)
  end
  handle_response(operation)
  result
end
execute_test_methods() click to toggle source

This overrides a method of the same name in the Crucible::Tests::BaseTest base class, to handle differences in the structure of the FHIR TestReport resource than Crucible's internal TestResult class.

# File lib/tests/testscripts/base_testscript.rb, line 175
def execute_test_methods
  @testreport = testreport_template
  begin
    @testreport.setup = setup if respond_to? :setup and not @metadata_only
  rescue AssertionException => e
    FHIR.logger.error "Setup Error #{id}: #{e.message}\n#{e.backtrace}"
    @setup_failed = e
    @testreport.status = 'error'
    if @testreport.setup.action.last.operation
      @testreport.setup.action.last.operation.message = "#{e.message}\n#{e.backtrace}"
    elsif @testreport.setup.action.last.assert
      @testreport.setup.action.last.assert.message = "#{e.message}\n#{e.backtrace}"
    end
  end
  prefix = if @metadata_only then 'generating metadata' else 'executing' end
  methods = tests
  methods = tests & @tests_subset unless @tests_subset.blank?
  methods.each do |test_method|
    @client.requests = [] if @client
    FHIR.logger.info "[#{title}#{('_' + @resource_class.name.demodulize) if @resource_class}] #{prefix}: #{test_method}..."
    begin
      @testreport.test << self.method(test_method).call
    rescue => e
      FHIR.logger.error "Fatal Error executing #{id} #{test_method}: #{e.message}\n#{e.backtrace}"
      @testreport.status = 'error'
      if @testreport.test.last.action.last.operation
        @testreport.test.last.action.last.operation.message = "#{e.message}\n#{e.backtrace}"
      elsif @testreport.test.last.action.last.assert
        @testreport.test.last.action.last.assert.message = "#{e.message}\n#{e.backtrace}"
      end
    end
  end
  begin
    @testreport.teardown = teardown if respond_to? :teardown and not @metadata_only
  rescue
  end
  @testreport
end
extract_operation_parameters(operation) click to toggle source
# File lib/tests/testscripts/base_testscript.rb, line 617
def extract_operation_parameters(operation)
  parameters = {}
  return parameters if operation.params.nil?
  params = operation.params
  params = operation.params[1..-1] if operation.params.length > 0 && operation.params[0] == "?"
  params.split("&").each do |param|
    key, value = param.split("=")
    parameters[key.to_sym] = replace_variables(value)
  end unless operation.params.blank?
  parameters
end
extract_value_by_path(resource, path) click to toggle source
# File lib/tests/testscripts/base_testscript.rb, line 637
def extract_value_by_path(resource, path)
  result = nil
  begin
    # First, try xpath
    result = extract_xpath_value(resource.to_xml, path)
  rescue
    # If xpath fails, see if JSON path will work...
    result = JsonPath.new(path).first(resource.to_json)
  end
  result
end
extract_xpath_value(resource_xml, resource_xpath) click to toggle source
# File lib/tests/testscripts/base_testscript.rb, line 649
def extract_xpath_value(resource_xml, resource_xpath)
  # Massage the xpath if it doesn't have fhir: namespace or if doesn't end in @value
  # Also make it look in the entire xml document instead of just starting at the root
  xpath = resource_xpath.split("/").map{|s| if s.starts_with?('fhir:') || s.length == 0 || s.starts_with?('@') then s else "fhir:#{s}" end}.join('/')
  xpath = "#{xpath}/@value" unless xpath.ends_with? '@value'
  xpath = "//#{xpath}"

  resource_doc = Nokogiri::XML(resource_xml)
  resource_doc.root.add_namespace_definition('fhir', 'http://hl7.org/fhir')
  resource_element = resource_doc.xpath(xpath)

  # This doesn't work on warningOnly; consider putting back in place
  # raise AssertionException.new("[#{resource_xpath}] resolved to multiple values instead of a single value", resource_element.to_s) if resource_element.length>1
  resource_element.first.try(:value)
end
generate_mock_data(type, length) click to toggle source
# File lib/tests/testscripts/base_testscript.rb, line 708
def generate_mock_data(type, length)
  choices = []
  choices << ('a'..'z') << ('A'..'Z') if type.downcase.include?('c') #add uppercase and lowercase characters as a choice
  choices << (0..9) if type.downcase.include?('d') #add digits as a choice
  (choices * length).map(&:to_a).flatten.shuffle[0,length].join #generate a random string based on all the choices
end
get_reference(reference) click to toggle source
# File lib/tests/testscripts/base_testscript.rb, line 669
def get_reference(reference)
  resource = nil
  if reference.start_with?('#')
    contained_id = reference[1..-1]
    resource = @testscript.contained.select{|r| r.id == contained_id}.first
  elsif reference.start_with?('http')
    raise "Remote references not supported: #{reference}"
  else 
    filepath = File.expand_path reference, File.dirname(File.absolute_path(@testscript.url))
    return nil unless File.exist? filepath
    file = File.open(filepath, 'r:UTF-8', &:read)
    file.encode!('UTF-8', 'binary', invalid: :replace, undef: :replace, replace: '')
    file = preprocess(file) if file.include?('${')
    resource = FHIR.from_contents(file)
  end

  resource
end
handle_assertion(assertion) click to toggle source

Returns a FHIR::TestReport::Setup::Action::Assert

# File lib/tests/testscripts/base_testscript.rb, line 433
def handle_assertion(assertion)
  result = FHIR::TestReport::Setup::Action::Assert.new({
    'result' => 'pass',
    'message' => assertion.label || assertion.description
    })

  operator = :equals
  operator = OPERATOR_MAP[assertion.operator] unless assertion.operator.nil?

  warningOnly = false
  warningOnly = assertion.warningOnly unless assertion.warningOnly.nil?

  begin
    case
    when !assertion.contentType.nil?
      call_assertion(:assert_resource_content_type, @last_response, assertion.contentType)

    when !assertion.headerField.nil?
      if assertion.direction && assertion.direction=='request'
        header_value = @last_response.request[:headers][assertion.headerField]
        msg_prefix = 'Request'
      else
        header_value = @last_response.response[:headers][assertion.headerField.downcase]
        msg_prefix = 'Response'
      end
      call_assertion(:assert_operator, operator, replace_variables(assertion.value), header_value, "#{msg_prefix} Header field #{assertion.headerField}")
    when !assertion.minimumId.nil?
      call_assertion(:assert_minimum, @last_response, @fixtures[assertion.minimumId])

    when !assertion.navigationLinks.nil?
      call_assertion(:assert_navigation_links, @last_response.resource)

    when !assertion.path.nil?
      actual_value = nil
      resource = nil
      if assertion.sourceId.nil?
        resource = @last_response.try(:resource) || FHIR.from_contents(@last_response.body)
      else
        resource = @fixtures[assertion.sourceId]
        resource = @response_map[assertion.sourceId].try(:resource) || FHIR.from_contents(@response_map[assertion.sourceId].body) if resource.nil?
      end
      actual_value = extract_value_by_path(resource, assertion.path)

      expected_value = replace_variables(assertion.value)
      unless assertion.compareToSourceId.nil?
        resource = @fixtures[assertion.compareToSourceId]
        resource = @response_map[assertion.compareToSourceId].try(:resource) || FHIR.from_contents(@response_map[assertion.compareToSourceId].body) if resource.nil?
        expected_value = extract_value_by_path(resource, assertion.path)
      end

      call_assertion(:assert_operator, operator, expected_value, actual_value)
    when !assertion.compareToSourcePath.nil?
      actual_value = nil
      resource = nil
      if assertion.sourceId
        resource = @fixtures[assertion.sourceId]
        resource = @response_map[assertion.sourceId].try(:resource) || FHIR.from_contents(@response_map[assertion.sourceId].body) if resource.nil?
      else
        raise AssertionException.new("compareToSourcePath requires sourceId: #{assertion.to_json}")
      end
      actual_value = extract_value_by_path(resource, assertion.compareToSourcePath)

      expected_value = replace_variables(assertion.value)
      unless assertion.compareToSourceId.nil?
        resource = @fixtures[assertion.compareToSourceId]
        resource = @response_map[assertion.compareToSourceId].try(:resource) || FHIR.from_contents(@response_map[assertion.compareToSourceId].body) if resource.nil?
        expected_value = extract_value_by_path(resource, assertion.compareToSourcePath)
      end

      call_assertion(:assert_operator, operator, expected_value, actual_value)
    when !assertion.resource.nil?
      call_assertion(:assert_resource_type, @last_response, "FHIR::#{assertion.resource}".constantize)

    when !assertion.responseCode.nil?
      call_assertion(:assert_operator, operator, assertion.responseCode, @last_response.response[:code].to_s)

    when !assertion.response.nil?
      call_assertion(:assert_response_code, @last_response, CODE_MAP[assertion.response])

    when !assertion.validateProfileId.nil?
      profile_uri = @testscript.profile.first{|p| p.id = assertion.validateProfileId}.reference
      reply = @client.validate(@last_response.resource,{profile_uri: profile_uri})
      call_assertion(:assert_valid_profile, reply.response, @last_response.resource.class)

    when !assertion.expression.nil?
      resource = nil
      if assertion.sourceId.nil?
        resource = @last_response.try(:resource) || FHIR.from_contents(@last_response.body)
      else
        resource = @fixtures[assertion.sourceId]
        resource = @response_map[assertion.sourceId].try(:resource) || FHIR.from_contents(@response_map[assertion.sourceId].body) if resource.nil?
      end
      begin
        unless FluentPath.evaluate(assertion.expression, resource.to_hash)
          raise AssertionException.new("Expression did not evaluate to true: #{assertion.expression}", assertion.expression)
        end
      rescue => fpe
        raise "Invalid Expression: #{assertion.expression}"
      end
    when !assertion.compareToSourceExpression.nil?
      resource = nil
      if assertion.sourceId
        resource = @fixtures[assertion.sourceId]
        resource = @response_map[assertion.sourceId].try(:resource) || FHIR.from_contents(@response_map[assertion.sourceId].body) if resource.nil?
      else
        raise AssertionException.new("compareToSourceExpression requires sourceId: #{assertion.to_json}")
      end
      begin
        unless FluentPath.evaluate(assertion.compareToSourceExpression, resource.to_hash)
          raise AssertionException.new("Expression did not evaluate to true: #{assertion.compareToSourceExpression}", assertion.compareToSourceExpression)
        end
      rescue => fpe
        raise "Invalid Expression: #{assertion.compareToSourceExpression}"
      end
    else
      result.result = 'error'
      result.message = "Unhandled Assertion: #{assertion.to_json}"
    end
  rescue AssertionException => ae
    result.result = 'fail'
    result.result = 'warning' if warningOnly
    result.message = ae.message
  rescue => e
    result.result = 'error'
    result.message = "#{e.message}\n#{e.backtrace}"
  end

  result
end
handle_response(operation) click to toggle source
# File lib/tests/testscripts/base_testscript.rb, line 629
def handle_response(operation)
  if !operation.responseId.blank? && operation.type.code != 'delete'
    log "Overwriting response #{operation.responseId}..." if @response_map.keys.include?(operation.responseId)
    log "Storing response #{operation.responseId}..."
    @response_map[operation.responseId] = @last_response
  end
end
id() click to toggle source
# File lib/tests/testscripts/base_testscript.rb, line 59
def id
  @testscript.id
end
id_from_path(path) click to toggle source
# File lib/tests/testscripts/base_testscript.rb, line 665
def id_from_path(path)
  path[1..-1]
end
load_fixtures() click to toggle source
# File lib/tests/testscripts/base_testscript.rb, line 109
def load_fixtures
  @fixtures = {}
  @testscript.fixture.each do |fixture|
    @fixtures[fixture.id] = get_reference(fixture.resource.reference)
    @fixtures[fixture.id].id = nil unless @fixtures[fixture.id].nil? #fixture resources cannot have an ID
    @autocreate << fixture.id if fixture.autocreate
    @autodelete << fixture.id if fixture.autodelete
  end
end
log(message) click to toggle source
# File lib/tests/testscripts/base_testscript.rb, line 96
def log(message)
  output = "#{debug_prefix}#{message}"
  puts output
  FHIR.logger.info(output)
end
multiserver() click to toggle source
# File lib/tests/testscripts/base_testscript.rb, line 67
def multiserver
  @testscript.origin.length >= 2 || @testscript.destination.length >= 2
end
perform_action(action) click to toggle source

Returns a FHIR::TestReport::Setup::Action containing either a FHIR::TestReport::Setup::Action::Operation

or a FHIR::TestReport::Setup::Action::Assert
# File lib/tests/testscripts/base_testscript.rb, line 307
def perform_action(action)
  result = FHIR::TestReport::Setup::Action.new
  if action.operation
    result.operation = execute_operation(action.operation)
  elsif action.assert
    result.assert = handle_assertion(action.assert)
  end
  result
end
preprocess(input) click to toggle source
# File lib/tests/testscripts/base_testscript.rb, line 688
def preprocess(input)
  # ${C4}: generates a 4 character string
  # ${D5}: generates a 5 digit number
  # ${CD6}: generates a 6 character string with digits and characters
  output = input;
  input.scan(/\${(\w+)}/).each do |match| 
    if @preprocessed_vars.key?(match[0])
      output.sub!("${#{match[0]}}", @preprocessed_vars[match[0]])
    else
      code_matches = /^(C|c|D|d|CD|cd)(\d+)$/.match(match[0])
      next unless code_matches && code_matches.size == 3
      mock_data = generate_mock_data(code_matches[1], code_matches[2].to_i)
      output.sub!("${#{match[0]}}", mock_data)
      @preprocessed_vars[match[0]] = mock_data
    end
  end

  output
end
process_test(test) click to toggle source

Returns a FHIR::TestReport::Test

# File lib/tests/testscripts/base_testscript.rb, line 215
def process_test(test)
  result = FHIR::TestReport::Test.new({
      'name' => test.id,
      'description' => test.description,
      'action' => []
    })
  @current_test = test
  @last_response = nil # clear out any responses from previous tests
  @test_failed = false
  begin
    test.action.each do |action|
      if !@test_failed
        @current_action = action
        result.action << perform_action(action)
        @test_failed = true if action_failed?(result.action.last)
      end
    end unless @metadata_only
  rescue => e
    @testreport.status = 'error'
    FHIR.logger.error "Fatal Error processing TestScript #{test.id} Action: #{e.message}\n#{e.backtrace}"
  end
  result
end
replace_variables(input) click to toggle source
# File lib/tests/testscripts/base_testscript.rb, line 568
def replace_variables(input)
  return nil if input.nil?
  return input unless input.include?('${')

  @testscript.variable.each do |var|
    if input.include? "${#{var.name}}"
      variable_value = nil

      if !var.headerField.nil?
        variable_source_response = @response_map[var.sourceId]
        headers = variable_source_response.response[:headers]
        headers.each do |key,value|
          variable_value = value if key.downcase == var.headerField.downcase
        end
      elsif !var.path.nil?

        resource = nil
        variable_source_response = @response_map[var.sourceId]
        unless variable_source_response.nil?
          resource = variable_source_response.try(:resource) || FHIR.from_contents(variable_source_response.body)
        else
          resource = @fixtures[var.sourceId]
        end

        variable_value = extract_value_by_path(resource, var.path)
      end

      unless variable_value
        if var.defaultValue
          variable_value = var.defaultValue
        else
          variable_value = ''
        end
      end

      input.gsub!("${#{var.name}}", variable_value)
    end
  end

  if input.include? '${'
    unknown_variables = input.scan(/(\$\{)([A-Za-z0-9\_]+)(\})/).map{|x|x[1]}
    message = "Unknown variables: #{unknown_variables.join(', ')}"
    log message
    warning {  assert unknown_variables.empty?, message }
  end

  input
end
setup() click to toggle source

Returns a FHIR::TestReport::Setup

# File lib/tests/testscripts/base_testscript.rb, line 251
def setup
  return nil if @testscript.setup.blank? && @autocreate.empty?
  report_setup = FHIR::TestReport::Setup.new
  @current_test = :setup
  @setup_failed = false
  # Run any autocreates
  @autocreate.each do |fixture_id|
    if !@setup_failed
      @current_action = "Autocreate Fixture #{fixture_id}"
      @last_response = @client.create @fixtures[fixture_id]
      @id_map[fixture_id] = @last_response.id
      report_setup.action << FHIR::TestReport::Setup::Action.new({
          'operation' => {
            'result' => ( [200,201].include?(@last_response.code) ? 'pass' : 'fail' ),
            'message' => @current_action
          }
        })
      @setup_failed = true unless [200,201].include?(@last_response.code)
    end
  end unless @client.nil?
  # Run setup actions if any
  @testscript.setup.action.each do |action|
    if !@setup_failed
      @current_action = action
      report_setup.action << perform_action(action) 
      @setup_failed = true if action_failed?(report_setup.action.last)
    end
  end unless @testscript.setup.blank?
  report_setup
end
teardown() click to toggle source

Returns a FHIR::TestReport::Teardown

# File lib/tests/testscripts/base_testscript.rb, line 283
def teardown
  return nil if @testscript.teardown.blank? && @autodelete.empty?
  report_teardown = FHIR::TestReport::Teardown.new
  # First run teardown as normal
  @testscript.teardown.action.each do |action|
    report_teardown.action << perform_action(action)
  end unless @testscript.teardown.blank?
  # Next autodelete any auto fixtures
  @autodelete.each do |fixture_id|
    @last_response = @client.destroy @fixtures[fixture_id].class, @id_map[fixture_id]
    @id_map.delete(fixture_id)
    report_teardown.action << FHIR::TestReport::Setup::Action.new({
        'operation' => {
          'result' => ( [200,204].include?(@last_response.code) ? 'pass' : 'fail' ),
          'message' => "Autodelete Fixture #{fixture_id}"
        }
      })
  end unless @client.nil?
  report_teardown
end
testreport_template() click to toggle source
# File lib/tests/testscripts/base_testscript.rb, line 149
def testreport_template
  report = FHIR::TestReport.new(
        {
          'identifier' => { 'system' => 'http://projectcrucible.org', 'value' => id },
          'status' => 'complete',
          'TestScript' => { 'display' => id },
          'issued' => Time.now.to_s.sub(' ','T').sub(' ','').insert(-3,':'),
          'participant' => [
            {
              'type' => 'test-engine',
              'uri' => 'http://projectcrucible.org',
              'display' => 'plan_executor'
            },
            {
              'type' => 'server',
              'uri' => (@client ? @client.full_resource_url({}) : nil )
            }
          ]
        })
  report.participant.pop if @client.nil?
  report
end
tests() click to toggle source
# File lib/tests/testscripts/base_testscript.rb, line 88
def tests
  @testscript.test.map { |test| "#{test.id} #{test.name} test".downcase.tr(' ', '_').to_sym }
end
title() click to toggle source
# File lib/tests/testscripts/base_testscript.rb, line 63
def title
  "TS-#{id}"
end