testscript_engine 0.0.0

data/lib/testscript_engine/message_handler.rb

@@ -0,0 +1,332 @@
+module MessageHandler
+  attr_accessor :debug_mode, :modify_report
+
+  def space
+    @space ||= ''
+  end
+
+  def unit_of_space
+    "   "
+  end
+
+  def increase_space
+    space << unit_of_space
+  end
+
+  def decrease_space
+    @space.chomp!(unit_of_space)
+  end
+
+  def newline
+    puts
+  end
+
+  def print_out(message)
+    if message.start_with?("START")
+      newline
+      increase_space
+    elsif message.start_with?("FINISH")
+    else
+      print unit_of_space
+    end
+    print space
+    puts message
+
+    if message.start_with?("FINISH")
+      decrease_space
+    end
+    nil
+  end
+
+  def info(message_type, *options)
+    print_out messages(message_type, *options)
+  end
+
+  def cascade_skips(message_type, actions, *options)
+    print_out "#{outcome_symbol("SKIP")} #{messages(message_type, *options)}"
+    increase_space
+    counter = 0
+    while counter < actions.length
+      action = actions[counter]
+      if action.operation
+        id = "Operation: [#{(action.operation.id || action.operation.label || 'unlabeled')}]"
+      else
+        id = "Assert: [#{(action.assert.id || action.assert.label || 'unlabeled')}]" if action.assert
+      end
+      skip(:eval_assert_result, "#{id} skipped.")
+      counter += 1
+    end
+    decrease_space
+  end
+
+  def load_scripts
+    print_out messages(:begin_loading_scripts, testscript_path)
+    super
+    print_out messages(:finish_loading_scripts)
+  end
+
+  def make_runnables
+    print_out messages(:begin_creating_runnables)
+    increase_space
+    super
+    decrease_space
+    print_out messages(:finish_creating_runnables)
+  end
+
+  def run(*args)
+    print_out messages(:begin_runnable_execution, script.id)
+    result = super
+    puts
+    print_out messages(:finish_runnable_execution)
+    result
+  end
+
+  def preprocess
+    print_out messages(:begin_preprocess)
+    super
+    print_out messages(:finish_preprocess)
+  end
+
+  def setup
+    print_out messages(:begin_setup)
+    super
+    print_out messages(:finish_setup)
+  end
+
+  def test
+    print_out messages(:begin_test)
+    super
+    print_out messages(:finish_test)
+  end
+
+  def teardown
+    print_out messages(:begin_teardown)
+    super
+    print_out messages(:finish_teardown)
+  end
+
+  def postprocessing
+  end
+
+  def load_fixtures
+    increase_space
+    super
+    decrease_space
+  end
+
+  def pass(message_type, *options)
+    message = messages(message_type, *options)
+    super()
+    print_out "#{outcome_symbol("INFO")} #{message}"
+  end
+
+  def fail(message_type, *options)
+    message = messages(message_type, *options)
+    super(message) if modify_report
+    print_out "#{outcome_symbol("FAIL")} #{message}"
+  end
+
+  def skip(message_type, *options)
+    message = messages(message_type, *options)
+    super(message) if modify_report
+    print_out "#{outcome_symbol("SKIP")} #{message}"
+  end
+
+  def warning(message_type, *options)
+    message = messages(message_type, *options)
+    super(message) if modify_report
+    print_out "#{outcome_symbol("WARN")} #{message}"
+  end
+
+  def error(message_type, *options)
+    message = messages(message_type, *options)
+    super(message) if modify_report
+    print_out "#{outcome_symbol("ERROR")} #{message}"
+  end
+
+  def print_action_header(action_type)
+    return false if @previous_action_type == action_type
+
+    @previous_action_type = action_type
+    true
+  end
+
+  # < ---- TO REVIEW ---- >
+  def client(*args)
+    client = super
+    FHIR.logger.formatter = logger_formatter_with_spacing
+    client
+  end
+
+  def logger_formatters_with_spacing
+    @logger_formatters_with_spacing ||= {}
+  end
+
+  def logger_formatter_with_spacing
+    logger_formatters_with_spacing[space.length] || begin
+      new_logger_formatter = proc do |severity, datetime, progname, msg|
+        "#{space}#{unit_of_space}#{msg}\n"
+      end
+      logger_formatters_with_spacing[space.length] = new_logger_formatter
+      new_logger_formatter
+    end
+  end
+
+  def outcome_symbol(outcome)
+    symbol = begin
+      case outcome
+      when "UNKNOWN"
+        "?¿?"
+      when "FATAL"
+        [023042].pack("U*")
+      when "ERROR"
+        [10071].pack("U*")
+      when "WARN"
+        [023220].pack("U*")
+      when "INFO"
+        [10003].pack("U*")
+      when "DEBUG"
+        [0372415].pack("U*")
+      when "FAIL"
+        [10007].pack("U*")
+      when "SKIP"
+        "\u21BB".encode('utf-8')
+      end
+    end
+
+    "(#{symbol})"
+  end
+
+  def begin_symbol
+    [10551].pack("U*")
+  end
+
+  def finish_symbol
+    [024465].pack("U*")
+  end
+
+  def messages(message, *options)
+    message_text = case message
+    when :abort_test
+      "Due to an unsuccessful action in the [#{options[0]}] phase, remaining actions in this test will be skipped. Skipping the next #{options[1]} action(s)."
+    when :bad_script
+      "Given non-TestScript resource. Can not create runnable."
+    when :bad_serialized_script
+      "Can not deserialize resource into TestScript: [#{options[0]}]."
+    when :begin_initialize_client
+      start_message_format("INITIALIZE CLIENT")
+    when :begin_creating_runnables
+      start_message_format("MAKE RUNNABLE(S)")
+    when :created_runnable
+      "Created runnable from TestScript: [#{options[0]}]."
+    when :finish_creating_runnables
+      finish_message_format("MAKING RUNNABLE(S)")
+    when :finish_initialize_client
+      finish_message_format("INITIALIZING CLIENT")
+    when :invalid_script
+      "Can not load TestScript. Invalid resource: [#{options[0]}]."
+    when :invalid_script
+      "Given invalid TestScript resource. Can not create runnable."
+    when :loaded_script
+      "Loaded TestScript: [#{options[0]}]."
+    when :loaded_static_fixture
+      "Loaded static fixture [#{options[0]}]."
+    when :no_postprocess
+      "Nothing to postprocess."
+    when :no_preprocess
+      "Nothing to preprocess."
+    when :no_setup
+      "Nothing to setup."
+    when :no_teardown
+      "Nothing to teardown."
+    when :overwrite_existing_script
+      "Overwriting previously loaded TestScript: [#{options[0]}]."
+    when :skip_on_fail
+      "Due to the preceeding unsuccessful action, skipping the next #{options[0]} action(s)."
+    when :unable_to_create_runnable
+      "Can not create runnable from TestScript: [#{options[0]}]."
+    when :unable_to_locate_runnable
+      "Can not locate runnable with id: [#{options[0]}]. Can not execute."
+    when :assertion_error
+      "ERROR: Unable to process assertion: #{options[0]}"
+    when :assertion_exception
+      "#{options[0]}"
+    when :bad_reference
+      "Unable to read contents of reference: [#{options[0]}]. No reference extracted."
+    when :bad_request
+      "Unable to create a request from operation."
+    when :bad_static_fixture_reference
+      "Static fixture included unresolvable reference. Can not load fixture. Moving on."
+    when :begin_loading_scripts
+      start_message_format("LOAD TESTSCRIPTS", options[0])
+    when :begin_preprocess
+      start_message_format("PREPROCESS", options[0])
+    when :begin_runnable_execution
+      start_message_format("EXECUTE RUNNABLE", options[0])
+    when :begin_setup
+      start_message_format("SETUP")
+    when :begin_teardown
+      start_message_format("TEARDOWN")
+    when :begin_test
+      start_message_format("TEST")
+    when :eval_assert_result
+      "#{options[0]}"
+    when :evaluate_assert
+      "EVALUATING ASSERTION"
+    when :execute_operation
+      "OPERATION EXECUTION"
+    when :execute_operation_error
+      "Unable to execute operation. ERROR: [#{options[0]}]. [#{options[1]}]"
+    when :finish_loading_scripts
+      finish_message_format("LOADING SCRIPTS")
+    when :finish_preprocess
+      finish_message_format("PREPROCESS")
+    when :finish_runnable_execution
+      finish_message_format("EXECUTING RUNNABLE. FINAL EXECUTION SCORE: [#{testreport.score}]")
+    when :finish_setup
+      finish_message_format("SETUP")
+    when :finish_teardown
+      finish_message_format("TEARDOWN")
+    when :finish_test
+      finish_message_format("TEST")
+    when :invalid_assert
+      "Invalid assert. Can not evaluate."
+    when :invalid_dump
+      "Validation error: [#{options[0]}]"
+    when :invalid_operation
+      "Invalid operation. Can not execute."
+    when :invalid_request
+      "Unable to create a request using operation: [#{options[0]}]. Can not execute."
+    when :no_contained_resource
+      "Reference [#{options[0]}] refers to a contained resource that does not exist. Moving on."
+    when :no_path
+      "Unable to extract path from operation."
+    when :no_reference
+      "Reference element of reference object is nil. Can not get resource from reference."
+    when :no_static_fixture_id
+      "No ID for static fixture. Can not load."
+    when :no_static_fixture_reference
+      "No reference for static fixture. Can not load."
+    when :no_static_fixture_resource
+      "No resource for static fixture. Can not load."
+    when :pass_execute_operation
+      "Executed Operation: [#{options[0]}]"
+    when :resource_extraction
+      "Unable to extract resource referenced by [#{options[0]}]. Encountered: [#{options[1]}]."
+    when :uncaught_error
+      "Uncaught error: [#{options[0]}]."
+    when :unsupported_ref
+      "Remote reference: [#{options[0]}] not supported. No reference extracted."
+    else
+      "! unknown message type !"
+    end
+  end
+end
+
+def start_message_format(phase, *options)
+  "STARTING TO #{phase}" + (options[0] ? ": [#{options[0]}]" : '')
+end
+
+def finish_message_format(phase)
+  "FINISHED #{phase}."
+end

data/lib/testscript_engine/operation.rb

@@ -0,0 +1,160 @@
+# frozen_string_literal: true
+module Operation
+  class OperationException < StandardError
+    attr_reader :details
+
+    def initialize(details)
+      @details = details
+			super()
+    end
+  end
+
+  OPERATION_NEEDS_RESOURCE_TYPE = %w[
+    put
+    patch
+    delete
+    read
+    vread
+    update
+    create
+  ].freeze
+
+  INTERACTION_NEEDS_PAYLOAD = %w[
+    patch
+    post
+    put
+  ].freeze
+
+  def execute(operation)
+    request = build_request(operation)
+
+    begin
+      client.send(*request)
+    rescue
+      raise OperationException, :bad_request
+    end
+
+    storage(operation)
+    pass(:pass_execute_operation, operation.label || 'unlabeled')
+  end
+
+  def build_request(operation)
+    path = get_path(operation)
+    headers = get_headers(operation)
+    interaction = get_interaction(operation)
+    payload = get_payload(operation, interaction)
+
+    [interaction, path, payload, headers].compact
+  end
+
+  def get_path(operation)
+    return replace_variables(operation.url) if operation.url
+
+    if operation.params
+      # [type]/[params]
+      "#{get_resource_type(operation)}#{replace_variables(operation.params)}"
+    elsif operation.targetId
+      resource = get_resource(operation.targetId)
+      # TODO: Move this exception into the get_resource method in runnable/utilities
+      # just need to make sure that raising this exception is always going to be acceptbale i.e. in any action ever,
+      # if the resource isn't available, we should dip
+      (raise OperationException, :noResource) unless resource
+      path = resource.resourceType
+      id = get_id(operation, resource)
+      vid = get_vid(operation, resource)
+      "#{path}#{id}" + (operation.type&.code == 'history' ? '/_history' : vid)
+    elsif operation.sourceId
+      resource = get_resource(operation.sourceId)
+      raise OperationException, :noResource unless resource
+
+      %w[batch transaction].include?(operation.type&.code) ? '' : resource.resourceType
+    else
+      raise OperationException, :no_path
+    end
+  end
+
+  def get_headers(operation)
+    headers = {
+      'Content-Type' => get_format(operation.contentType),
+      'Accept' => get_format(operation.accept)
+    }
+
+		operation.requestHeader.each_with_object(headers) do |header|
+			headers[header.field] = header.value
+		end
+	end
+
+  def get_interaction(operation)
+    interaction = operation.local_method || operation_to_interaction(operation.type&.code)
+    interaction || (raise OperationException, :noInteraction)
+  end
+
+  def get_payload(operation, interaction)
+    return unless INTERACTION_NEEDS_PAYLOAD.include?(interaction)
+
+    payload = get_resource(operation.sourceId)
+    raise OperationException, :noPayload if INTERACTION_NEEDS_PAYLOAD.include?(interaction) && !payload
+    payload
+  end
+
+  def get_resource_type(operation)
+    operation_type = operation.local_method || operation.type.code
+
+    if OPERATION_NEEDS_RESOURCE_TYPE.include?(operation_type) && operation.resource.nil?
+      raise OperationException, :noResourceType
+    end
+
+    operation.resource
+  end
+
+  def get_id(operation, resource)
+    id = resource.id
+    (raise OperationException, :noId) ['read', 'vread'].include?(operation.type&.code) if id.nil?
+    "/#{id}"
+  end
+
+  def get_vid(operation, resource)
+    vid = resource.meta&.versionId
+    if operation.type&.code == 'vread'
+      (raise OperationException, :noVid) unless vid
+      "/_history/#{vid}"
+    else
+      ''
+    end
+  end
+
+  def get_format(format)
+    return 'application/fhir+xml' if format == 'xml'
+
+    'application/fhir+json'
+  end
+
+  def operation_to_interaction(interaction)
+    case interaction
+    when 'read', 'vread', 'search', 'search-type', 'search-system', 'capabilities', 'history', 'history-instance', 'history-type', 'history-system', 'operation'
+      'get'
+    when 'create', 'batch', 'transaction'
+      'post'
+    when 'update'
+      'put'
+    when 'patch'
+      'patch'
+    when 'delete'
+      'delete'
+    end
+  end
+
+  def create_operation(source_id)
+    FHIR::TestScript::Setup::Action::Operation.new({
+                                                     sourceId: source_id,
+                                                     method: 'post'
+                                                   })
+  end
+
+  def delete_operation(source_id)
+    FHIR::TestScript::Setup::Action::Operation.new({
+                                                     targetId: id_map[source_id],
+                                                     method: 'delete'
+                                                   })
+  end
+end