framework_gem 0.1.0

data/lib/lib/test_case/performance_test_case.rb

@@ -0,0 +1,29 @@
+require './lib/test_case/test_case'
+
+# PerformanceTestCase manages test flow for performance tests
+
+class PerformanceTestCase < TestCase
+
+  # Public: Initializes a performance test case. NOT FOR USE IN TESTS.
+  #
+  # Returns nothing.
+  def initialize(*args)
+    super
+    @sword_report_error = false
+  end
+
+  private
+
+  # Public: Defines test case flow for performance tests.
+  #
+  # Returns nothing.
+  def perform
+    begin
+      super
+    rescue Exception => e
+      # swallow all exceptions, we have already logged/reported them at this point
+    end
+  end
+
+end
+

data/lib/lib/test_case/test_case.rb

@@ -0,0 +1,1055 @@
+require './lib/test_data'
+require './lib/logger/tmc_logger'
+require './lib/logger/tmc_dut_logger'
+require './lib/helpers/helpers'
+require './lib/helpers/tmc_helpers/tmc_helpers'
+require './lib/prereqs/prereqs_for_test'
+require './lib/prereqs/prereqs_for_dut'
+require './lib/test_case/test_error'
+require './lib/test_case/test_exception'
+require './lib/test_case/test_step'
+require './lib/test_case/test_status'
+require './dsllib/performance/perf_lib'
+require './dsllib/common/utils/tmc_utils'
+require './lib/test_case/ci_test'
+require './lib/test_case/monitoring/monitoring_test'
+require 'minitest/test'
+begin
+  require './lib/data_services/data_services'
+rescue LoadError # TODO: remove rescue once data_services code is stabilized
+end
+
+# The TestCase class manages test flow
+
+class TestCase < MiniTest::Test
+  include Helpers
+  include TmcHelpers
+  include TmcUtils
+  include PerfLib
+  include LegacyLogging
+  alias :orig_backticks :'`'
+  private :orig_backticks
+
+  @@not_valid_for = {}
+  @@valid_for = []
+  @@prereqs_for_test = []
+  @@prereqs_for_dut = []
+
+  # Public: Assigns device types for which the test case is not valid.
+  #
+  # device_types - Splat Array of device types for which the test case is not valid.
+  #
+  # Returns nothing.
+  def self.not_valid_for(*device_types)
+    if device_types.empty?
+      nil
+    elsif device_types.first.is_a?(Hash)
+      @@not_valid_for.update(device_types.first)
+    else
+      device_types.each { |d| @@not_valid_for[d] = nil }
+    end
+  end
+
+  # Public: Assigns device types for which the test case is valid.
+  #
+  # device_types - Splat Array of device types for which the test case is valid.
+  #
+  # Returns nothing.
+  def self.valid_for(*device_types)
+    @@valid_for += device_types
+  end
+
+  # Public: Assigns prerequisites for the test.
+  #
+  # prereqs_for_test - Splat Array of Symbol prereqs required for the test.
+  #
+  # Returns nothing.
+  def self.prereqs_for_test(*prereqs_for_test)
+    @@prereqs_for_test = prereqs_for_test
+  end
+
+  # Public: Assigns prerequisites for the DUT.
+  #
+  # prereqs_for_dut - Splat Array of Symbol prereqs required for the DUT.
+  #
+  # Returns nothing.
+  def self.prereqs_for_dut(*prereqs_for_dut)
+    @@prereqs_for_dut = prereqs_for_dut
+  end
+
+  attr_reader(:id, :job, :iteration, :start_time, :stop_time, :logger, :host, :identity, :ssh)
+  attr_writer(:device_ids, :reported_result)
+
+  # Public: Initializes a new TestCase. NOT FOR USE IN TESTS.
+  #
+  # Returns nothing.
+  def initialize(id, device_ids, iteration, host, job, log_file, log_level, data: nil, auth: nil, workspace: nil)
+    super(nil)
+    @status = TestStatus.new(self, nil)
+    # Set attributes from parameters
+    @id = id
+    @device_ids = device_ids || [] # needed for syntax eval
+    @primary_device_id = @device_ids.empty? ? nil : @device_ids.first
+    @identity = job
+    @iteration = iteration
+    @host = host
+    @job = job
+    @workspace = workspace
+    # Set remaining attributes
+    @type = nil
+    @start_time = nil
+    @stop_time = nil
+    @teardowns = []
+    @steps = []
+    @errors = []
+    @current_step = nil
+    @data = nil
+    @duts = {}
+    @loaded_libs = false
+    @recording_video_id = nil
+    @video_recording_ids = {}
+    @audio_recording_ids = {}
+    @locked_resources = {}
+    @reported_results = false
+    @test_steps_ignore_errors = false
+    @ignore_errors = false
+    @no_log_trace = false
+    # Set these attributes last as they may depend on others
+    # Create base logger
+    base_logger = TmcLogger.new(log_file, log_level)
+    @loggers = {}
+    if device?
+      # Create DUT logger for each device
+      @device_ids.each_with_index do |d, i|
+        @loggers[d] = TmcDutLogger.new(i + 1, base_logger, self)
+      end
+    else
+      # Create a non-device logger
+      @loggers[0] = TmcDutLogger.new(nil, base_logger, self)
+    end
+    @logger = @loggers.values.first
+    @test_data = TestData.new(self, job: @job, data: data)
+    @ssh = TmcSsh.new(self)
+    # Anything that logs should go here
+    unless auth.nil?
+      # Log in using base-64 auth
+      resp = tmc_post('/api/login', json: { value: auth })
+      @identity = resp['guid']
+    end
+    @ignore_interrupt = false
+    @canceled = false
+    trap_signals
+  end
+
+  # Public: Gets test status.
+  #
+  # Returns String status.
+  def status
+    @status.status
+  end
+
+  # Public: Block probes.
+  def `(_)
+    probe_fail('`')
+  end
+
+  # Public: Block probes.
+  def exec(*_c)
+    probe_fail('exec')
+  end
+
+  # Public: Block probes.
+  def system(*_c)
+    probe_fail('system')
+  end
+
+  # Public: Get test name.
+  def name
+    if @name.nil?
+      resp = tmc_get("/api/jobs/#{@job}/tests/#{@id}") || {}
+      @name = test_info['name'] || self.class.name.split('::').last.gsub(/(?<!^)([A-Z]|[0-9]+)/, ' \0')
+    end
+    @name
+  end
+
+  # Public: Gets test step errors behavior.
+  #
+  # Returns a Boolean indicating test steps ignore errors.
+  def test_steps_ignore_errors?
+    @test_steps_ignore_errors
+  end
+
+  # Public: Sets test step errors behavior.
+  #
+  # val - A Boolean indicating whether test steps should ignore errors.
+  #
+  # Returns nothing.
+  def test_steps_ignore_errors(val)
+    @test_steps_ignore_errors = val
+    @steps.each {|s| s.instance_variable_set(:@raising, !val)}
+  end
+
+  # Public: Gets test case errors behavior.
+  #
+  # Returns a Boolean indicating the test case ignores errors in determining the result,
+  # when test steps are also configured to ignore errors.
+  def ignore_errors?
+    @ignore_errors
+  end
+
+  # Public: Sets test case errors behavior.
+  #
+  # val - A Boolean indicating whether the test case should ignore errors in determining the result,
+  #       when test steps are also configured to ignore errors.
+  #
+  # Returns nothing.
+  def ignore_errors(val)
+    @ignore_errors = val
+  end
+
+  # Public: Gets test errors.
+  #
+  # Returns an Array of errors in format:
+  #   [{:message => 'oh no!', :file => 'foo.rb', :line => 22, :method => 'foo', :line_in_method => 3, :step_id => 1, :step_name => 'Baz'}]
+  def errors
+    @errors.map {|e| e.to_h}
+  end
+
+  # Public: Locks the specified resource(s) to perform an action.
+  #
+  # resource        - String or Array of String resources to lock.
+  # timeout         - Integer lock activity timeout in milliseconds.
+  # block           - Block to perform.
+  # device          - Integer device to lock (default: nil).
+  # concurrent      - Integer concurrent locks allowed (default: 1).
+  # acquire_timeout - Integer lock acquisition timeout in milliseconds (default: nil).
+  #                   If nil, 16 * the lock activity timeout will be used.
+  #
+  # Returns the result of the specified block.
+  def lock(resource, timeout, device: nil, concurrent: 1, acquire_timeout: nil)
+    ret = nil
+    locked_resources = []
+    uri = '/api/lock'
+    uri += "/#{device}" unless device.nil?
+    acquire_timeout ||= (timeout * 16)
+    resource = [resource] unless resource.is_a?(Array)
+    begin
+      resource.each do |res|
+        # only lock if not already locked
+        next if @locked_resources.key?(res)
+
+        logger.debug("Attempting to lock TMC resource [#{res}] at #{timestamp}")
+        resp = tmc_post(uri, json: { resource: res, timeout: timeout, concurrent: concurrent }, timeout: acquire_timeout)
+        id = resp['id']
+        locked_resources << id
+        @locked_resources[res] = id
+        add_teardown(nil, device, id) do |dev, lid|
+          release_lock(dev, lid) if @locked_resources.value?(lid)
+        end
+      end
+      begin
+        Timeout.timeout(timeout.to_f / 1.sec) do
+          ret = yield
+        end
+      rescue Timeout::Error
+        raise "Lock activity timed out after #{timeout} ms!"
+      end
+    ensure
+      locked_resources.each do |id|
+        release_lock(device, id)
+        logger.debug("TMC resource [#{id}] unlocked at #{timestamp}")
+      end
+    end
+    ret
+  end
+
+  # Public: Gets an ISO 8601-formatted timestamp.
+  #
+  # at - DateTime or Time object (default: nil).
+  #
+  # Returns the String timestamp.
+  def timestamp(at: nil)
+    at ||= DateTime.now
+    at.strftime(TmcLogger::DATETIME_FORMAT)
+  end
+
+  # Public: Gets an ISO 8601-formatted timestamp safe for use in a filename.
+  #
+  # at - DateTime or Time object (default: nil).
+  #
+  # Returns the String timestamp.
+  def safe_timestamp(at: nil)
+    at ||= DateTime.now
+    at.strftime(TmcLogger::DATETIME_FORMAT).delete(':')
+  end
+
+  # Public: Sleeps. TODO: We really should not be clobbering built-ins like this.
+  #
+  # delay - Integer or Range of milliseconds to sleep.
+  #         If a Range, will sleep a random number of milliseconds within the Range.
+  #
+  # Returns nothing.
+  alias builtin_sleep sleep # preserve the built-in sleep method so we can use it
+  def sleep(delay)
+    if delay.is_a?(Range)
+      min = delay.first
+      range = delay.last - min
+      delay = min + rand(range + 1)
+    end
+    logger.debug("Sleep for: [#{delay.to_i}] ms")
+    builtin_sleep(delay.to_i / 1000.0)
+  end
+
+  # Public: Gets test data.
+  #
+  # Examples:
+  #
+  #   test_data[:foo] = 'bar'
+  #   #=> 'bar'
+  #
+  #   test_data.refresh
+  #   #=> nil
+  #
+  #   val = test_data[:foo]
+  #   #=> 'bar'
+  #
+  #   val = test_data.fetch(:foo)
+  #   #=> 'bar'
+  #
+  #   val = test_data.update(nums: {int: 1, float: 3.5})
+  #   #=> {:foo => 'bar', :nums => {:int => 1, :float => 3.5}}
+  #
+  #   val = test_data.dig(:nums, :float)
+  #   #=> 3.5
+  #
+  #   val = test_data.dig(:nums, :decimal)
+  #   #=> nil
+  #
+  # Returns test data hash.
+  def test_data
+    @test_data.refresh if !@test_data.promiscuous? && @test_data.empty?
+    @test_data
+  end
+  alias options test_data
+
+  # Public: Pings the given host.
+  #
+  # host - String host name or IP to ping.
+  #
+  # Returns true if the host could be pinged, otherwise false.
+  def ping?(host)
+    failed = orig_backticks("ping -n 1 #{host}").match(/(?i)Received\s*=\s*1/).nil?
+    !failed
+  end
+
+  # Public: Gets delta between the specified times.
+  #
+  # t1 - Time, DateTime, Integer, Float, or String T1 time value.
+  # t2 - Time, DateTime, Integer, Float, or String T2 time value.
+  #
+  # Returns the Float delta in milliseconds.
+  def get_time_delta(t1, t2)
+    (to_time(t2) - to_time(t1)) * 1000.0 # convert to ms
+  end
+  alias time_diff_milli get_time_delta
+
+  # Public: Performs a test step.
+  #
+  # id    - Integer test step id.
+  # name  - String name of the test step (default: nil).
+  # block - Block that performs the test step.
+  #
+  # Returns nothing.
+  def test_step(id, name: nil, &block)
+    if id.nil?
+      id = @steps.empty? ? 1 : @steps.last.id + 1
+    end
+    # Look up the step
+    update = false
+    step = @steps.find { |step| step.id == id && step.device == @primary_device_id }
+    if step.nil?
+      # Create the step if it does not exist
+      step = TestStep.new(self, id, name, @primary_device_id, @iteration)
+      @steps << step
+      update = true
+    elsif !name.nil? && name != step.name
+      step.instance_variable_set(:@name, name)
+      update = true
+    end
+    @current_step = step
+    step.perform(update: update, &block)
+    @current_step = nil
+  end
+
+  # Public: Indicates whether the test has a device.
+  #
+  # Returns a Boolean indicating if the test has a device.
+  def device?
+    !@device_ids.empty?
+  end
+
+  # Public: Reports a measurement to the designated system.
+  #
+  # return_value     - Integer or Float return value (default: nil).
+  #                    If default, return value will be calculated from start and stop time.
+  # start_time       - Time measurement started (default: start_time).
+  # stop_time        - Time measurement stopped (default: stop_time).
+  # message          - String details about measurement (default: nil).
+  #                    If default, a generic message will be used.
+  # execution_metric - Execution metric for which to report (default: nil).
+  #                    If default, will not report for a specific execution metric.
+  # return_title     - Return title to report (default: nil).
+  #                    If default, will not report for a specific return title.
+  # result           - Symbol result to report (default: nil).
+  #                    Should be :passed, :failed, :error, or :done. If default, current test status will be used.
+  #
+  # Returns nothing.
+  def report_result(args = {})
+    start = args.fetch(:start_time, start_time || Time.now)
+    stop = args.fetch(:stop_time, stop_time || Time.now)
+    args[:tcr_auto_detail_text] = args.delete(:message)
+    result = args.delete(:result)
+    logger.info("Reporting #{args[:message] || args[:execution_metric] || args[:return_title] || 'result'}: " \
+                    "#{result.nil? ? '' : "#{result.to_s.capitalize} in "}#{args[:return_value] || (stop - start)} s")
+    report_to_sword(result, start, stop, args) if is_sword?
+    @reported_results = true
+  end
+
+  # Public: Gets the data service.
+  #
+  # Returns the <data> instance.
+  def data
+    @data = DataServices.new(@logger) if @data.nil?
+    @data
+  end
+
+  # Public: Fails the test or step.
+  #
+  # reason - String message describing the reason for failure.
+  #
+  # Returns nothing.
+  def fail(reason = 'Unknown failure')
+    sword_attach_screenshot reason
+    backtrace = caller
+    if @current_step.nil?
+      @status = TestStatus.new(self, TestStatus::FAILED, reason: reason, backtrace: backtrace)
+      raise TestException.new
+    else
+      @current_step.fail(reason, backtrace: backtrace)
+    end
+  end
+
+  # Public: Passes the test or step.
+  #
+  # reason - String message describing the reason for passing.
+  #
+  # Returns nothing.
+  def pass(reason = nil)
+    is_perf = is_a?(PerformanceTestCase)
+    if @current_step.nil?
+      @status = TestStatus.new(self, is_perf ? TestStatus::DONE : TestStatus::PASSED, reason: reason)
+    else
+      @current_step.pass(reason)
+    end
+  end
+
+  # Public: Quits the test.
+  #
+  # reason - String message describing the reason for error.
+  #
+  # Returns nothing.
+  def error(reason = 'Unknown error')
+    raise reason
+  end
+
+  # Public: Adds a teardown with the given method and arguments.
+  #
+  # msg   - String message to log when the teardown runs.
+  # args  - Array of parameters to send (default: []).
+  # block - Block method the teardown should run.
+  #
+  # Returns nothing.
+  def add_teardown(msg, *args, &block)
+    logger.debug("Adding teardown: #{method_to_str(block)}")
+    @teardowns << { message: msg, method: block, args: args }
+  end
+
+  # Public: Records a test error.
+  #
+  # msg       - String error message.
+  # log       - Boolean indicating whether to log the error immediately (default: false).
+  # log_opts  - Hash of options to pass to `logger.error', if log is enabled (default: nil).
+  # backtrace - Array containing error backtrace (default: {}).
+  #             If default, caller will be used.
+  #
+  # Returns the TestError instance.
+  def record_error(msg, log: false, log_opts: {}, backtrace: nil)
+    err = TestError.new(self, msg, backtrace || caller, step: @current_step)
+    @errors << err
+    if log
+      msg += " #{err}"
+      logger.error(msg, log_opts)
+    end
+    err
+  end
+
+  # Public: Gets server name.
+  #
+  # Returns the String name of the TMC server.
+  def server_name
+    server_info['name']
+  end
+
+  # Public: Gets server market.
+  #
+  # Returns the String market of the TMC server.
+  def server_market
+    server_info['market']
+  end
+
+  # Public: Gets job name.
+  #
+  # Returns the String name of the current job.
+  def job_name
+    job_status['name']
+  end
+
+  # Public: Gets job start time.
+  #
+  # Returns the String start time of the current job in ISO 8601 format, local to the TMC, with a timezone offset.
+  def job_start_time
+    job_status['startedAt'].to_time
+  end
+
+  # Public: Gets the device under test, initializing it first if necessary.
+  #
+  # Returns the dut.
+  def dut
+    dut1
+  end
+
+  # Public: Gets the 1st device under test, initializing it first if necessary.
+  #
+  # Returns the 1st dut.
+  def dut1
+    get_dut(1)
+  end
+
+  # Public: Gets the 2nd device under test, initializing it first if necessary.
+  #
+  # Returns the 2nd dut.
+  def dut2
+    get_dut(2)
+  end
+
+  # Public: Gets the 3rd device under test, initializing it first if necessary.
+  #
+  # Returns the 3rd dut.
+  def dut3
+    get_dut(3)
+  end
+
+  # Public: Gets a web browser.
+  #
+  # browser - Symbol browser to launch, can be :firefox or :chrome (default: :chrome).
+  #
+  # Returns the browser Object.
+  def browser(browser: :firefox)
+    if @browser.nil? || @browser.send(:closed?)
+      require './lib/platform/web/web'
+      @browser = Web.new(browser, self)
+    end
+    @browser
+  end
+
+  # Public: Gets the local UTC offset.
+  #
+  # Returns the local time offset in Integer milliseconds.
+  def local_utc_offset
+    local_offset_str = Time.now.getlocal.to_s.match(/([\+-]\d{4})/).to_s
+    local_offset = local_offset_str[1..2].to_i.hr + local_offset_str[3..4].to_i.min
+    local_offset_str[0..0].eql?('-') ? local_offset * -1 : local_offset
+  end
+
+  # Public: Converts the specified object to a time.
+  #
+  # obj - Object to convert.
+  #
+  # Returns a Time object.
+  def to_time(obj)
+    if obj.is_a?(Time)
+      obj
+    elsif obj.is_a?(DateTime)
+      obj.to_time
+    elsif obj.is_a?(Numeric)
+      # This expects seconds since the epoch
+      Time.at(obj)
+    elsif obj.is_a?(String)
+      obj.to_time
+    else
+      raise "#{obj.class.name} cannot be converted to time!"
+    end
+  end
+
+  private
+
+  # Internal: Get test path.
+  def path
+    test_info['path']
+  end
+
+  # Internal: Get test info.
+  def test_info
+    if @test_info.nil?
+      resp = tmc_get("/api/jobs/#{@job}/tests/#{@id}") || {}
+      @test_info = resp['testCase']
+    end
+    @test_info
+  end
+
+  # Internal: Executes teardowns.
+  def teardown
+    unless @recording_video_id.nil?
+      api_stop_video(@recording_video_id)
+      @recording_video_id = nil
+    end
+    logger.send(:set_tag, 'TEARDOWN')
+    logger.info("Doing #{@teardowns.count} teardowns")
+    until @teardowns.empty?
+      this_teardown = @teardowns.pop
+      msg = this_teardown[:message]
+      meth = this_teardown[:method]
+      logger.debug("Executing teardown: #{method_to_str(meth)}")
+      logger.info(msg, tag: 'TEARDOWN') unless msg.nil?
+      begin
+        meth.call(*this_teardown[:args])
+      rescue Exception => e # signals handled by `trap_signals'
+        logger.error("Teardown error: #{e.message}\n\t#{e.backtrace.join("\n\t")}")
+      end
+    end
+    logger.send(:unset_tag)
+  end
+
+  # Internal: Get logger for specified dut.
+  def logger_for_device(id)
+    @loggers[id]
+  end
+
+  # Internal: Block probes.
+  def probe_fail(meth)
+    raise "Method `#{meth}' not allowed. Further attempts to execute commands on this server will result in more restrictions."
+  end
+
+  # Internal: Release the given lock.
+  def release_lock(device, id)
+    res, id = @locked_resources.find { |_, i| i == id }
+    return if id.nil?
+
+    uri = '/api/lock'
+    uri += "/#{device}" unless device.nil?
+    tmc_delete("#{uri}/#{id}")
+    @locked_resources.delete(res)
+  end
+
+  # Internal: Indicates whether the test is running from SWORD.
+  def is_sword?
+    !test_data[:sword_data].nil?
+  end
+
+  # Internal: Hook that executes each time test status is set.
+  #
+  # Returns nothing.
+  def set_status(status, device: nil)
+    logger.info("Test #{status.status}", tag: 'STATUS')
+    @status = status
+    json = jsonify({device: device || @primary_device_id, iteration: @iteration}.merge(@status.to_h))
+    tmc_put("/api/jobs/#{@job}/tests/#{@id}/status", json: json)
+  end
+
+  # Internal: Gets the job status.
+  def job_status
+    if @job_status.nil?
+      @job_status = tmc_get("/api/jobs/#{@job}/status")['testJobStatus']
+    end
+    @job_status
+  end
+
+  # Internal: Hook that executes test.
+  #
+  # Returns nothing.
+  def wrap_run
+    set_status(TestStatus.new(self, TestStatus::RUNNING))
+    max_timeout_h = 48
+    max_timeout_m = 60 * max_timeout_h
+    timeout_m = test_data.fetch(:script_timeout, max_timeout_m)  # optional timeout, specified in min
+    timeout_m = max_timeout_m if timeout_m == 0                  # disallow infinite timeout
+    if timeout_m > max_timeout_m
+      raise "Script timeout cannot be greater than #{max_timeout_h} hours!"
+    end
+    timeout_s = timeout_m * 60
+    logger.info("Timeout in: #{get_readable_time(timeout_s)}") if timeout_s != 0
+    Timeout.timeout(timeout_s) do
+      @start_time = Time.now
+      run
+      @stop_time = Time.now
+    end
+  end
+
+  # Internal: Defines how the test case should run. Inheriting classes may extend this behavior.
+  #
+  # Returns nothing.
+  def perform
+    before_run
+    wrap_run
+    get_result
+  rescue Exception => e # signals handled by `trap_signals'
+    if @canceled && !RUBY_PLATFORM.include?('linux')
+      Thread.new do
+        # "acknowledge" interrupt
+        dir = File.join('c:', 'temp')
+        Dir.mkdir(dir) unless Dir.exist?(dir)
+        File.open(File.join(dir, "SIGINT-#{Process.pid}.pid"), 'w') { |_| }
+        @ignore_interrupt = true
+      end
+    end
+    @stop_time = Time.now
+    @start_time ||= @stop_time
+    if @current_step.nil?
+      if e.is_a?(Minitest::Assertion)
+        @status = TestStatus.new(self, TestStatus::FAILED, exception: e)
+      elsif !e.is_a?(TestException)
+        @status = TestStatus.new(self, TestStatus::ERROR, exception: e)
+      end
+    else
+      # avoid logging the stacktrace twice
+      @no_log_trace = true
+      @status = @current_step.instance_variable_get(:@status)
+    end
+  ensure
+    after_run
+  end
+
+  # Internal: Placeholder for run. TestCase subclasses must implement this.
+  #
+  # Returns nothing.
+  # Raises Exception.
+  def run
+    raise "Test case must implement `run' method!"
+  end
+
+  # Internal: Hook that executes before every test.
+  #
+  # Returns nothing.
+  def before_run
+    # Log server info
+    %w[name hostname publicIp localIp version sha authSystem].each do |inf|
+      logger.info("TMC Server Info [#{inf}] : #{server_info[inf]}")
+    end
+    # Log current user and workspace
+    logger.info("Current user: #{current_user['name']} (#{current_user['email']})")
+    unless @workspace.nil?
+      logger.info("Current workspace: #{@workspace}")
+    end
+    # Populate test info
+    @steps = (test_info['steps'] || []).map do |step|
+      TestStep.new(self, step['id'], step['name'], @primary_device_id, @iteration)
+    end
+    parse_sword_test_data if is_sword?
+    logger.info("Test: #{name}", screenshot: true)
+    set_status(TestStatus.new(self, TestStatus::NOT_RUN)) if status.nil?
+    # Verify prerequisites
+    check_prerequisites
+    # Initialize dut (if there is one) except for CI tests
+    if device?
+      require_valid_for_device
+      # Log the actual resolution
+      res = dut.resolution(update: true)
+      logger.info("Actual device resolution: #{res[:width]}x#{res[:height]}")
+      # Set up video recording
+      n = (options[:record_last_n_seconds] || 0)
+      if n > 0
+        logger.info("Recording last #{n} seconds")
+        id = dut.record_video(duration: n.sec, block: false)[:id]
+        @recording_video_id = id
+      end
+    end
+  end
+
+  # Internal: Hook that executes after every test.
+  #
+  # Returns nothing.
+  def after_run
+    @ignore_interrupt = true
+    begin
+      screen = nil
+      if device?
+        begin
+          screen = dut.capture_screen
+        rescue Exception # signals handled by `trap_signals'
+          # no-op
+        end
+      end
+      @status.status ||= TestStatus::FAILED
+      status = @status.status
+      message = @status.reason
+      backtrace = @status.backtrace
+      msg_str = message.nil? ? '' : ": #{message}"
+      trace_str = @no_log_trace || backtrace.nil? ? '' : "\n\t#{backtrace.join("\n\t")}"
+      # log status
+      error_str = ''
+      unless backtrace.nil?
+        e = record_error(message, backtrace: backtrace)
+        error_str = "\n\t" + e.to_s
+      end
+      args = ["Test #{status}#{msg_str}#{error_str}#{trace_str}", tag: 'RESULT', screen_image: screen]
+      puts args[0] # always log test result to STDOUT.
+      if [TestStatus::FAILED, TestStatus::ERROR].include?(status)
+        logger.error(*args)
+      else
+        logger.info(*args)
+      end
+      # TODO: restore or delete this functionality
+      # if result == TestStatus::FAILED
+      #  # Fetch device logs on failure
+      #  if fetch_option(:generate_odn_logs_on_failure, false) && stb_capable_of?('ODN')
+      #    mas_fetch_odn_binary_logs_from_stb
+      #  end
+      #  if fetch_option(:generate_fdr_logs_on_failure, false) && stb_vendor?('Cisco')
+      #    dncs_fetch_cisco_fdr_logs_from_stb
+      #  end
+      # end
+      # Report execution time before teardown
+      logger.info("Total execution time: #{get_readable_time(stop_time - start_time)}", tag: 'RUNTIME')
+      teardown
+      @video_recording_ids.each do |id, dev|
+        begin
+          tmc_delete("/api/video/record/#{dev}", json: { id: id })
+        rescue StandardError
+          # no-op
+        end
+      end
+      @audio_recording_ids.each do |id, dev|
+        begin
+          tmc_delete("/api/audio/record/#{dev}", json: { id: id })
+        rescue StandardError
+          # no-op
+        end
+      end
+      # Set status and report result after teardown
+    ensure
+      # Always set status
+      begin
+        set_status(@status)
+      rescue Exception => e # signals handled by `trap_signals'
+        # Log any status error
+        logger.error(e)
+      ensure
+        # Always report
+        begin
+          report_result(result: @status.status, message: @status.reason) unless @reported_results
+        rescue Exception => e # signals handled by `trap_signals'
+          # Log any reporting error
+          logger.error(e)
+        end
+      end
+    end
+  end
+
+  # Internal: Gets test result, failing the test if any errors occurred.
+  def get_result
+    if @errors.empty? || @ignore_errors
+      pass unless status == TestStatus::PASSED
+    else
+      err = @errors.each_with_index.map do |e, i|
+        step_str = e.step.nil? ? '' : " (Step ##{e.step.id}#{e.step.name.nil? ? '' : " - #{e.step.name}"})"
+        "#{i + 1}.#{step_str} #{e.message} #{e}"
+      end.join("\n\t")
+      @status = TestStatus.new(self, TestStatus::FAILED, exception: Exception.new("One or more errors occurred.\n\t#{err}"))
+      raise TestException.new
+    end
+  end
+
+  # Internal: Ensures the test and DUT prerequisites are met.
+  #
+  # Returns nothing.
+  def check_prerequisites
+    return if (@@prereqs_for_test + @@prereqs_for_dut).empty?
+
+    lock("prereqs-#{@job}", 12.hr) do
+      td_prereqs = test_data.fetch(:_prereqs, {})
+      unless @@prereqs_for_test.empty?
+        # Check test prereqs
+        prereqs_obj = PrereqsForTest.new(self)
+        @@prereqs_for_test.each do |prereq|
+          success = td_prereqs[prereq]
+          if success.nil?
+            # Prereq not yet checked
+            logger.info("Checking prerequisite for test: #{prereq}")
+            success = prereqs_obj.send(prereq) ? true : false
+            test_data.update(_prereqs: { prereq => success })
+          end
+          unless success
+            # Prereq failed
+            fail("Prerequisite failed for test: #{prereq}")
+          end
+        end
+      end
+      unless @@prereqs_for_dut.empty?
+        # Check DUT prereqs
+        dut_key = :"device #{dut.id}"
+        prereqs_obj = PrereqsForDut.new(self)
+        @@prereqs_for_dut.each do |prereq|
+          dut_prereqs = td_prereqs.fetch(dut_key, {})
+          success = dut_prereqs[prereq]
+          if success.nil?
+            # Prereq not yet checked
+            logger.info("Checking prerequisite for device #{dut.id}: #{prereq}")
+            success = prereqs_obj.send(prereq) ? true : false
+            test_data.update(_prereqs: { dut_key => dut_prereqs.merge(prereq => success) })
+          end
+          unless success
+            # Prereq failed
+            fail("Prerequisite failed for device #{dut.id}: #{prereq}")
+          end
+        end
+      end
+    end
+  end
+
+  # Internal: Ensures the test is valid for the current device type.
+  #
+  # Returns nothing.
+  def require_valid_for_device
+    return unless device?
+
+    model = dut.model
+    model = 'UNKNOWN' if model.nil? || model.empty? || model == -1
+    if @@not_valid_for.key?(model.to_sym)
+      reason = @@not_valid_for[model.to_sym]
+      reason_str = reason.nil? ? '' : " Reason: #{reason}"
+      raise "This test is not valid for #{model}!#{reason_str}"
+    elsif !@@valid_for.empty? && !@@valid_for.include?(model.to_sym)
+      raise "#{model} is not in the list of valid device types for this test!"
+    end
+  end
+
+  # Internal: Acquires a TMC lock to modify the given account data.
+  #
+  # data  - Object data for which to acquire a lock.
+  # block - Block to execute while lock is acquired.
+  #
+  # Returns nothing.
+  def modifies_account_data(data, &block)
+    lock(data.to_s, 1.hr, &block)
+  end
+
+  # Internal: Acquires a TMC lock to modify the parental controls PIN.
+  #
+  # Returns nothing.
+  def modifies_parental_controls_pin(&block)
+    modifies_account_data(:parental_controls_pin, &block)
+  end
+
+  # Internal: Formats the given method with optional args and block into a nice string.
+  #
+  # meth  - String or Symbol name of method to format.
+  # args  - Splat Array of method arguments.
+  # block - Block associated with the method.
+  #
+  # Returns the formatted method String.
+  def method_to_str(meth, *args, &block)
+    args_str = args.map { |arg| arg.is_a?(String) ? arg.inspect.tr('"', "'") : arg.to_s }.join(' ')
+    "#{meth}(#{args_str}#{block.nil? ? '' : ", #{block}"})"
+  end
+
+  # Internal: Gets the specified DUT.
+  #
+  # n - Integer index (1-based) of DUT to fetch.
+  #
+  # Returns nothing.
+  def get_dut(n)
+    if @duts[n].nil?
+      # Initialize DUT
+      dut_id = @device_ids[n - 1]
+      raise "Invalid DUT ##{n}. #{@device_ids.count} devices selected for test." if dut_id.nil?
+
+      resp = tmc_get("/api/config/hardware/devices?devices=#{dut_id}")
+      cfg = resp['devices'].first
+      platform = cfg['platform']
+      if platform.nil? || platform.empty?
+        raise "No platform defined for device #{dut_id}! Check TMC hardware config."
+      end
+
+      Dir['./lib/platform/**/*.rb'].each { |f| require f }
+      begin
+        cls = Object.const_get(platform)
+      rescue NameError
+        raise "Unknown platform: #{platform}"
+      end
+      # Initialize the dut object
+      obj = cls.new(self, id: dut_id, config: cfg)
+      # Report dut info
+      report_info = %w[name model boxCode platform ipAddress macAddress remoteType]
+      report_info.each do |inf|
+        logger.info "Device #{dut_id} Info [#{inf}] : #{cfg[inf]}"
+      end
+      @duts[n] = obj
+    end
+    @duts[n]
+  end
+
+
+  # Internal: Parses SWORD test data.
+  def parse_sword_test_data
+    logger.debug('Parsing SWORD test data')
+    sword_data = test_data[:sword_data]
+    begin
+      @sword_job_id = sword_data[:job_id]
+      raise 'SWORD job id not found in test data' if @sword_job_id.nil?
+
+      @sword_test_plan_result_id = sword_data[:test_plan_result_id]
+      raise 'SWORD test plan result id not found in test data' if @sword_test_plan_result_id.nil?
+
+      @sword_report_ip = sword_data[:report_ip]
+      raise 'SWORD report IP not found in test data' if @sword_report_ip.nil?
+
+      @sword_hardware_unit_id = Hash[sword_data.fetch(:hardware_unit_ids, [])][dut.id]
+      raise "SWORD hardware unit id for device #{dut.id} not found in test data" if @sword_hardware_unit_id.nil?
+
+      @sword_test_cycle_test_case_id = @id
+      test_cycle_test_case = Hash[sword_data.fetch(:test_cycle_test_cases, [])].fetch(@sword_test_cycle_test_case_id, {})
+      @sword_test_case_result_id = test_cycle_test_case[:test_case_result_id]
+      raise "SWORD test case result id for test cycle test case #{@sword_test_cycle_test_case_id} not found in test data" if @sword_test_case_result_id.nil?
+
+      @sword_report_grouping = sword_data[:report_grouping]
+      @sword_result_url = is_a?(PerformanceTestCase) ? '/automated_test_reporter' : sword_data[:result_url]
+      @sword_finish_url = sword_data[:finish_url]
+      sword_report_port = sword_data.fetch(:report_port, 80)
+      sword_report_proto = sword_report_port == 443 ? 'https' : 'http'
+      @sword_base_url = "#{sword_report_proto}://#{@sword_report_ip}:#{sword_report_port}"
+      @sword_tcr_auto_detail_id = nil
+    rescue StandardError
+      logger.error("Failed to parse SWORD test data:\n#{sword_data}")
+      raise
+    end
+  end
+
+  # Internal: Traps all possible signals, ignoring them, except for Interrupt, which is used to signify cancellation.
+  def trap_signals
+    Signal.list.each_value do |signo|
+      begin
+        Signal.trap(signo) do
+          puts "Trapped signal: #{signo}"
+          if signo == 2 && !@ignore_interrupt
+            # trap Interrupt
+            @canceled = true
+            puts 'Processing interrupt ..'
+            raise Interrupt, 'Test canceled'
+          end
+        end
+      rescue StandardError
+        # no-op; we couldn't trap this signal
+      end
+    end
+  end
+end