framework_gem 0.1.0

data/lib/lib/helpers/tmc_helpers/tmc_helpers.rb

@@ -0,0 +1,1260 @@
+require 'time'
+require 'fileutils'
+require 'pathname'
+require './lib/helpers/tmc_helpers/ssh_helper/ssh_helper'
+require './lib/helpers/tmc_helpers/snmp_helper/snmp_helper'
+require './lib/helpers/tmc_helpers/email_helper/email_helper'
+require './lib/helpers/tmc_helpers/csv_helper/csv_helper'
+require './lib/helpers/tmc_helpers/http_helper/http_helper'
+
+# AWS defaults
+ENV['AWS_ACCESS_KEY_ID'] = 'AKIAJR4GME4RASTKVXXQ'
+ENV['AWS_SECRET_ACCESS_KEY'] = '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'
+ENV['AWS_REGION'] = 'us-west-2'
+ENV['AWS_DEFAULT_BUCKET'] = 'charter-testworkbench-com'
+
+# The Helpers module contains methods that can be used in test cases, methods, and prerequisites
+
+module TmcHelpers
+  include SnmpHelper
+  include EmailHelper
+  include SshHelper
+  include CsvHelper
+  include HttpHelper
+
+  # Public: Configures AWS.
+  #
+  # region            - String region (default: nil).
+  # access_key_id     - String S3 access key ID (default: nil).
+  # secret_access_key - String S3 secret access key (default: nil).
+  #
+  # Returns nothing.
+  def aws_config(region: nil, access_key_id: nil, secret_access_key: nil)
+    with_aws do
+      if access_key_id.nil? || secret_access_key.nil?
+        logger.warn("AWS not configured: Missing `access_key_id' or `secret_access_key'")
+        return
+      end
+      Aws.config.update(credentials: Aws::Credentials.new(access_key_id, secret_access_key))
+      Aws.config.update(region: region) unless region.nil?
+    end
+  end
+
+  # Public: Creates an AWS S3 bucket. TODO: VERIFY FUNCTIONALITY
+  #
+  # bucket  - String name of bucket.
+  # options - Hash of options to pass to create (default: {}).
+  #
+  # Returns nothing.
+  def aws_create_s3_bucket(bucket, options={})
+    logger.info("Creating S3 bucket: #{bucket}")
+    aws do |s3|
+      b = s3.bucket(bucket)
+      if b.exists?
+        raise 'Bucket already exists!'
+      end
+      b.create(options)
+    end
+    nil
+  end
+
+  # Public: Deletes an AWS S3 bucket. TODO: VERIFY FUNCTIONALITY
+  #
+  # bucket  - String name of bucket.
+  #
+  # Returns nothing.
+  def aws_delete_s3_bucket(bucket)
+    logger.info("Deleting S3 bucket: #{bucket}")
+    aws do |s3|
+      b = s3.bucket(bucket)
+      unless b.exists?
+        raise 'Bucket does not exist!'
+      end
+      b.delete!
+    end
+    nil
+  end
+
+  # Public: Uploads an object to an AWS S3 bucket.
+  #
+  # bucket  - String name of bucket. The bucket will be created if it does not exist.
+  # name    - String name of object to write. The object will be overwritten if it already exists.
+  # path    - String path to object.
+  # options - Hash of options to pass to upload (default: {}).
+  #
+  # Returns the public URI::HTTP for the object.
+  def aws_upload_s3(bucket, name, path, options={})
+    logger.info("Uploading file to S3 bucket '#{bucket}': #{path} (#{get_readable_size(File.size(path))})")
+    aws do |s3|
+      o = get_or_create_s3_bucket(s3, bucket).object(name)
+      o.upload_file(Pathname.new(path), {acl: 'public-read'}.merge(options))
+      url = o.public_url
+      logger.info("New file URL: #{url}")
+      url
+      # do the upload this way to protect the file after N seconds (1 week in this case)
+      #o.upload_file(Pathname.new(path), options)
+      #o.presigned_url(:get, expires_in: 604800)
+    end
+  end
+
+  # Public: Writes an object to an AWS S3 bucket.
+  #
+  # bucket  - String name of bucket. The bucket will be created if it does not exist.
+  # name    - String name of object to write. The object will be overwritten if it already exists.
+  # data    - String data to write to object.
+  # options - Hash of options to pass to put (default: {}).
+  #
+  # Returns the public URI::HTTP for the object.
+  def aws_write_s3(bucket, name, data, options={})
+    logger.info("Writing object to S3 bucket '#{bucket}': #{name} (#{get_readable_size(data.size)})")
+    aws do |s3|
+      o = get_or_create_s3_bucket(s3, bucket).object(name)
+      o.put({body: data, acl: 'public-read'}.merge(options))
+      url = o.public_url
+      logger.info("New object URL: #{url}")
+      url
+      # do the PUT this way to protect the file after N seconds (1 week in this case)
+      #o.put(options.merge(body: data))
+      #o.presigned_url(:get, expires_in: 604800)
+    end
+  end
+
+  # Public: Reads an object from an AWS S3 bucket.
+  #
+  # bucket  - String name of bucket.
+  # name    - String name of object to read.
+  # options - Hash of options to pass to read (default: {}).
+  #
+  # Returns the String object value.
+  def aws_read_s3(bucket, name, options={})
+    logger.info("Reading object from S3 bucket '#{bucket}': #{name}")
+    aws do |s3|
+      b = s3.bucket(bucket)
+      unless b.exists?
+        raise 'Bucket does not exist!'
+      end
+      o = b.object(name)
+      unless o.exists?
+        raise 'Object does not exist!'
+      end
+      o.get(options).body.string
+    end
+  end
+
+  # Public: Deletes an object from an AWS S3 bucket.
+  #
+  # bucket  - String name of bucket.
+  # name    - String name of object to delete.
+  # options - Hash of options to pass to delete (default: {}).
+  #
+  # Returns nothing.
+  def aws_delete_s3(bucket, name, options={})
+    logger.info("Deleting object from S3 bucket '#{bucket}': #{name}")
+    aws do |s3|
+      b = s3.bucket(bucket)
+      unless b.exists?
+        raise 'Bucket does not exist!'
+      end
+      o = b.object(name)
+      unless o.exists?
+        raise 'Object does not exist!'
+      end
+      o.delete(options)
+    end
+  end
+
+  # Public: Yields the given block until the result is not empty.
+  #
+  # timeout     - Integer total milliseconds to try meeting the criteria before timing out (default: 30.sec).
+  # message     - String custom message to log (default: 'executing provided block').
+  # block       - Block to yield.
+  #
+  # Returns the final result of yielding the block.
+  def until_not_empty(args={}, &block)
+    until_condition(:not_empty, args, &block)
+  end
+
+  # Public: Yields the given block until the result is not nil.
+  #
+  # timeout     - Integer total milliseconds to try meeting the criteria before timing out (default: 30.sec).
+  # message     - String custom message to log (default: 'executing provided block').
+  # block       - Block to yield.
+  #
+  # Returns the final result of yielding the block.
+  def until_not_nil(args={}, &block)
+    until_condition(:not_nil, args, &block)
+  end
+
+  # Public: Yields the given block until the result is the same twice in a row.
+  #
+  # timeout     - Integer total milliseconds to try meeting the criteria before timing out (default: 30.sec).
+  # message     - String custom message to log (default: 'executing provided block').
+  # allow_empty - Boolean indicating whether to consider empty objects (String, Array, etc.) matching (default: false).
+  # block       - Block to yield.
+  #
+  # Returns the final result of yielding the block.
+  def until_same(args={}, &block)
+    until_condition(:same, args, &block)
+  end
+
+  # Public: Yields the given block until the result equals the specified value.
+  #
+  # value       - Object value that must equal the result of the block.
+  # timeout     - Integer total milliseconds to try meeting the criteria before timing out (default: 30.sec).
+  # message     - String custom message to log (default: 'executing provided block').
+  # block       - Block to yield.
+  #
+  # Returns the final result of yielding the block.
+  def until_equals(value, args={}, &block)
+    args[:value] = value
+    until_condition(:equals, args, &block)
+  end
+
+  # Public: Yields the given block until the result does not equal the specified value.
+  #
+  # value       - Object value that must equal the result of the block.
+  # timeout     - Integer total milliseconds to try meeting the criteria before timing out (default: 30.sec).
+  # message     - String custom message to log (default: 'executing provided block').
+  # block       - Block to yield.
+  #
+  # Returns the final result of yielding the block.
+  def until_not_equals(value, args={}, &block)
+    args[:value] = value
+    until_condition(:not_equals, args, &block)
+  end
+
+  # Public: Yields the given block until the result includes the specified value.
+  #
+  # value       - Object value that must be included in the result of the block.
+  # timeout     - Integer total milliseconds to try meeting the criteria before timing out (default: 30.sec).
+  # message     - String custom message to log (default: 'executing provided block').
+  # block       - Block to yield.
+  #
+  # Returns the final result of yielding the block.
+  def until_includes(value, args={}, &block)
+    args[:value] = value
+    until_condition(:includes, args, &block)
+  end
+
+  # Public: Yields the given block until the result does not include the specified value.
+  #
+  # value       - Object value that must not be included in the result of the block.
+  # timeout     - Integer total milliseconds to try meeting the criteria before timing out (default: 30.sec).
+  # message     - String custom message to log (default: 'executing provided block').
+  # block       - Block to yield.
+  #
+  # Returns the final result of yielding the block.
+  def until_not_includes(value, args={}, &block)
+    args[:value] = value
+    until_condition(:not_includes, args, &block)
+  end
+
+  # Public: Yields the given block until the specified criteria are met or times out.
+  #
+  # condition   - Symbol condition to test. May be one of the following:
+  #               :not_empty    - Returns when the result of the block is not empty.
+  #               :not_nil      - Returns when the result of the block is not nil.
+  #               :same         - Returns when the result of the block is the same twice in a row.
+  #               :equals       - Returns when the given value equals the result of the block.
+  #               :not_equals   - Returns when the given value does not equal the result of the block.
+  #               :includes     - Returns when the given value is included in the result of the block.
+  #               :not_includes - Returns when the given value is not included in the result of the block.
+  # value       - Object value (default: nil). Required if needed to test condition.
+  # timeout     - Integer total milliseconds to try meeting the criteria before timing out (default: 30.sec).
+  # message     - String custom message to log (default: 'executing provided block').
+  # allow_empty - Boolean indicating whether to consider empty objects (String, Array, etc.)
+  #               matching when the criteria is :same (default: false).
+  # block       - Block to yield.
+  #
+  # Returns the final result of yielding the block.
+  def until_condition(condition, args={}, &block)
+    message = args.fetch(:message, 'executing provided block')
+    timeout = args.fetch(:timeout, 30.sec)
+    value_str = args[:value].nil? ? '' : " #{args[:value].inspect}"
+    logger.info("#{message.capitalize} until #{condition}#{value_str} or timeout (#{timeout} ms)")
+    ret = nil
+    last_ret = -1
+    start_time = Time.now
+    while (Time.now - start_time) <= (timeout / 1.sec)
+      ret = block.call
+      case condition
+        when :not_empty
+          break unless ret.nil? || ret.empty?
+        when :not_nil
+          break unless ret.nil?
+        when :same
+          break if ret == last_ret && (args[:allow_empty] || !ret.empty?)
+          last_ret = ret
+        when :equals
+          if args[:value].is_a?(Regexp)
+            break if !ret.nil? && ret =~ args[:value]
+          else
+            break if ret == args[:value]
+          end
+        when :not_equals
+          if args[:value].is_a?(Regexp)
+            break unless ret.nil? || ret =~ args[:value]
+          else
+            break unless ret == args[:value]
+          end
+        when :includes
+          unless ret.nil?
+            if args[:value].is_a?(Regexp)
+              break unless ret.select { |val| val =~ args[:value] }.empty?
+            else
+              break if ret.include?(args[:value])
+            end
+          end
+        when :not_includes
+          unless ret.nil?
+            if args[:value].is_a?(Regexp)
+              break if ret.select { |val| val =~ args[:value] }.empty?
+            else
+              break unless ret.include?(args[:value])
+            end
+          end
+        else
+          raise "Invalid condition: #{condition}"
+      end
+      sleep(100)
+    end
+    ret
+  end
+
+  # Public: Picks a random item from the given array.
+  #
+  # items - Splat Array of items from which to pick.
+  #
+  # Returns the randomly-chosen item Object.
+  def pick_random(*items)
+    if items.first.is_a?(Array)
+      items = items.first
+    end
+    logger.info("Picking random item from: #{items.inspect}")
+    item = items[items.count > 1 ? rand(items.count) : 0]
+    logger.info("Picked #{item.inspect}")
+    item
+  end
+
+  # Public: Checks if the given number looks like a modern year (1900 - 2999).
+  #
+  # yyyy - Integer number to validate.
+  #
+  # Returns a Boolean true if the number looks like a year, otherwise false.
+  def is_year?(yyyy)
+    min = 1900
+    max = 2999
+    logger.info("Checking if #{yyyy.inspect} is a valid year (#{min} - #{max})")
+    yyyy.to_i >= min && yyyy.to_i < max
+  end
+
+  # Public: Checks if the given value is a valid movie/series rating.
+  #
+  # rating - String rating to validate.
+  #
+  # Returns a Boolean true if the rating is valid, otherwise false.
+  def is_rating?(rating)
+    valid_ratings = %w(TV-G TV-PG TV-14 TV-MA G PG PG-13 R NC-17 NR)
+    logger.info("Checking if #{rating.inspect} is a valid rating (#{valid_ratings.join(', ')})")
+    valid_ratings.include?(rating)
+  end
+
+  # Public: Checks to see if a Suite Instance ID exists for the current twb_suite_name.
+  #
+  # Returns a Boolean true if a Suite Instance ID exists for the current suite. Else, returns a Boolean false.
+  def twb_suite_exists?
+    test_data.refresh
+    if test_data[:report_per_slot]
+      return true if test_data.fetch("twb_suite_id_slot#{dut.slot}_iter#{iteration}".to_sym, false)
+      return false
+    end
+    return true if test_data.fetch(:twb_suite_id, false)
+    return false
+  end
+
+  # Public: Checks to see if a Case Instance ID exists for the current Slot and Test Case in the Job.
+  #
+  # Returns a Boolean true if a Case Instance ID exists for the current suite. Else, returns a Boolean false.
+  def twb_case_exists?
+    test_data.refresh
+    return true if test_data.fetch("twb_case_id#{id}_slot#{dut.slot}_iter#{iteration}".to_sym, false)
+    return false
+  end
+
+  # Public: Gets a Suite Instance ID for the current twb_suite_name. If one exists already it is used, otherwise a POST to TWB retrieves a new one.
+  #
+  # twb_suite_name           - String name of the test suite (default: test_data[:twb_suite_name]).
+  # program_application_name - String name of the program application (default: test_data[:program_application_name]).
+  #
+  # Returns the String suite_instance_id for the suite or current Job if successful. Else, returns nil.
+  def twb_get_suite_instance_id(args={})
+    test_suite_name = args.fetch(:twb_suite_name, test_data[:twb_suite_name])
+    # Check to see if the Suite Instance Id has already been written to disk
+    test_data.refresh
+    if twb_suite_exists?
+      return test_data.fetch("twb_suite_id_slot#{dut.slot}_iter#{iteration}".to_sym, nil) if test_data[:report_per_slot]
+      return test_data.fetch(:twb_suite_id, false)
+    else
+      program_application_name = args.fetch(:program_application_name, test_data[:program_application_name])
+      return twb_post_suite(:twb_suite_name => test_suite_name, :program_application_name => program_application_name)
+    end
+  end
+
+  # Public: Gets a Case Instance ID for the current twb_suite_name. If one exists already it is used, otherwise a POST to TWB retrieves a new one.
+  #
+  # twb_suite_name  - String name of the test suite (default: test_data[:twb_suite_name]).
+  #
+  # Returns the String case_instance_id for the current test case if successful. Else, returns nil.
+  def twb_get_case_instance_id(args={})
+    test_suite_name = args.fetch(:twb_suite_name, test_data[:twb_suite_name])
+    # Check if the Suite & Case Instance Id has already been written to disk
+    if twb_case_exists?
+      test_data.refresh
+      return test_data.fetch("twb_case_id#{id}_slot#{dut.slot}_iter#{iteration}".to_sym, false)
+    else
+      suite_instance_id = twb_get_suite_instance_id
+      return twb_post_testcase(:twb_suite_name => test_suite_name, :suite_instance_id => suite_instance_id)
+    end
+  end
+
+  # Public: Takes a screenshot on current STB and POSTS to TWB. The user has the ability to set the Suite & Case instance ID or if a Suite &/or Case ID already exists for the twb_suite_name or current Job Name, those will be used.  In the case where neither a Suite & Case instance ID are provided and they don't already exist for the twb_suite_name or Job Name, new ones will be retrieved from TWB.
+  #
+  # twb_suite_name    - String name of the Test Suite Name to report to (default: test_data[:twb_suite_name])
+  # program_application_name - String name of the Program Application to report to (default: test_data[:program_application_name]).
+  # ss_filename       - String filename of image to POST. If none is provided a screenshot on active stb will be captured (default: nil)
+  # timeout           - Integer total milliseconds to wait for a response (default: 5.min).
+  # verify_mode       - Integer desired HTTP verify mode (default: nil).
+  # uri               - String full URI for the resource to request(default: "http://charter.testworkbench.com/ords/test/postScreenshots/#{case_instance_id}").
+  # case_instance_id  - result of twb_get_case_instance_id
+  # suite_instance_id - result of twb_get_suite_instance_id
+  # size              - number from 0 to 100 for percentage size of the image
+  # quality           - number from 0 to 100 for image quality
+  #
+  # Returns the path to the screenshot file, ss_filename
+  def twb_post_screenshot(args={})
+    test_suite_name = (args.key?(:twb_suite_name)) ? args[:twb_suite_name] : test_data[:twb_suite_name]
+    program_application_name = (args.key?(:program_application_name)) ? args[:program_application_name] : test_data[:program_application_name]
+    suite_instance_id = (args.key?(:suite_instance_id)) ? args[:suite_instance_id] : twb_get_suite_instance_id(:twb_suite_name => test_suite_name, :program_application_name => program_application_name)
+
+    image_size = args.fetch(:size, 100).to_i
+    image_size = (image_size > 100) ? 100 : image_size
+    image_size = (image_size < 0) ? 0 : image_size
+
+    image_quality = args.fetch(:quality, 100).to_i
+    image_quality = (image_quality > 100) ? 100 : image_quality
+    image_quality = (image_quality < 0) ? 0 : image_quality
+
+
+    case_instance_id = (args.key?(:case_instance_id)) ? args[:case_instance_id] : twb_get_case_instance_id(:twb_suite_name => test_suite_name)
+    ss_filename = args.fetch(:ss_filename, nil)
+    timeout = args.fetch(:timeout, 5.min)
+    verify_mode = args.fetch(:verify_mode, 0)
+    headers = {'Content-Type' => 'image/jpeg'}
+    uri = args.fetch(
+        :uri,
+        "http://charter.testworkbench.com/ords/test/postScreenshots/#{case_instance_id}"
+    )
+    tmc_current_screenshots = Hash[test_data.fetch(:tmc_current_screenshots, [])]
+    if tmc_current_screenshots[id].nil?
+      test_data[:tmc_current_screenshots] = tmc_current_screenshots.update(id => 1).to_a  # can't use hash because of integer keys
+    else
+      tmc_current_screenshots[id] += 1
+      test_data[:tmc_current_screenshots] = tmc_current_screenshots.to_a  # can't use hash because of integer keys
+    end
+    if ss_filename.nil?
+      ss_filename = "twb_suite_#{suite_instance_id}_case_#{case_instance_id}_screenshot_#{tmc_current_screenshots[id]}.jpg"
+      data = dut.capture_screen(:filename => ss_filename, :format => :raw, :size => image_size, :quality => image_quality)
+    else
+      data = ss_filename
+    end
+    web_post(uri, :headers => headers,
+                    :verify_mode => verify_mode, :timeout => timeout, :body => data
+    ).json
+    return ss_filename
+  end
+
+  # Public: Writes a screenshot to an AWS S3 bucket in preparation for reporting to TWB.
+  #
+  # access_key_id            - String S3 access key ID (default: TWB access key).
+  # secret_access_key        - String S3 secret access key (default: TWB secret access key).
+  # region                   - Symbol S3 region (default: us-west-2).
+  #                            :us-east-1 - N. Virginia
+  #                            :us-east-2 - Ohio
+  #                            :us-west-1 - N. California
+  #                            :us-west-2 - Oregon
+  # bucket_name              - String S3 bucket name (default: 'charter-testworkbench-com').
+  # aws_folder               - String folder name where image will POST (default: TMC_Screenshots).
+  # ss_filename              - String filename of image to POST. If none is provided a screenshot on active stb will be captured (default: nil)
+  # size              - number from 0 to 100 for percentage size of the image
+  # quality           - number from 0 to 100 for image quality
+  #
+  # Returns the public URI::HTTP for the object.
+  def twb_prep_s3_screenshot(args={})
+    suite_instance_id = (args.key?(:suite_instance_id)) ? args[:suite_instance_id] : twb_get_suite_instance_id
+    case_instance_id = (args.key?(:case_instance_id)) ? args[:case_instance_id] : twb_get_case_instance_id
+
+    image_size = args.fetch(:size, 100).to_i
+    image_size = (image_size > 100) ? 100 : image_size
+    image_size = (image_size < 1) ? 1 : image_size
+
+    image_quality = args.fetch(:quality, 100).to_i
+    image_quality = (image_quality > 100) ? 100 : image_quality
+    image_quality = (image_quality < 0) ? 0 : image_quality
+
+    access_key_id = args.fetch(:access_key_id, 'AKIAJR4GME4RASTKVXXQ')
+    secret_access_key = args.fetch(:secret_access_key, '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')
+    region = args.fetch(:region, 'us-east-2')
+    bucket_name = args.fetch(:bucket_name, 'charter-testworkbench-com')
+    aws_folder = args.fetch(:aws_folder, 'TMC_Screenshots')
+    ss_filename = args.fetch(:ss_filename, nil)
+    tmc_current_screenshots = Hash[test_data.fetch(:tmc_current_screenshots, [])]
+    if tmc_current_screenshots[id].nil?
+      test_data[:tmc_current_screenshots] = tmc_current_screenshots.update(id => 1).to_a  # can't use hash because of integer keys
+    else
+      tmc_current_screenshots[id] += 1
+      test_data[:tmc_current_screenshots] = tmc_current_screenshots.to_a  # can't use hash because of integer keys
+    end
+    filename = "twb_suite_#{suite_instance_id}_case_#{case_instance_id}_screenshot_#{tmc_current_screenshots[id]}.jpg"
+    # Prep the screenshot
+    if ss_filename.nil?
+      data = dut.capture_screen(:filename => filename, :format => :raw, :size => image_size, :quality => image_quality)
+    else
+      data = ss_filename
+    end
+    aws_write_s3(bucket_name, "#{aws_folder}/#{filename}", data)
+    return "#{aws_folder}/#{filename}"
+  end
+
+  # Public: POSTs the Suite level results to TWB and retrieves the Suite Instance ID. If there is already a Suite Instance ID associated with the current test_suite_name it will be used instead.
+  #
+  # tester_name              - String name of tester (default: current_user['name']).
+  # report_to_scorecard      - String value of 'Y' or 'N' indicating scorecard is/isn't used (default: 'N').
+  # footprints               - String comma separated list of values (default '').
+  #
+  # Returns the String suite_instance_id for the suite if successful. Else, returns nil.
+  def twb_post_suite(args={})
+    # Check to see if the Suite Instance Id has already been written to Test Data
+    return twb_get_suite_instance_id if twb_suite_exists?
+
+    test_suite_name = args.fetch(:twb_suite_name, test_data[:twb_suite_name])
+    tester_name = args.fetch(:tester_name, current_user['name'])
+    program_application_name = args.fetch(:program_application_name, test_data[:program_application_name])
+    report_to_score_card = args.fetch(:report_to_score_card, test_data[:report_to_score_card])
+    report_to_score_card = 'N' if report_to_score_card.to_s.empty?
+    footprints = args.fetch(:footprints, test_data[:footprints])
+    footprints = '' if footprints.to_s.empty?
+    environment = args.fetch(:spectrum_environment, current_workspace)
+    device = args.fetch(:device, 'undefined') # dvr or non-dvr
+    device = 'dvr' if dut.model.include?('210')
+    device = 'non-dvr' if dut.model.include?('110')
+    slot = args.fetch(:slot, dut.slot)
+    mac_address = args.fetch(:mac_address, dut.mac_address)
+    mac_address = 'undefined' if mac_address.to_s.empty?
+    machine_name = args.fetch(:machine_name, server_name)
+    uri = args.fetch(:uri, 'http://charter.testworkbench.com/ords/test/suite/')
+    # Build hash for required params
+    rb_hash = {
+        :test_suite_name => test_suite_name,
+        :tester_name => tester_name,
+        :program_application_name => program_application_name,
+        :report_to_score_card => report_to_score_card,
+        :footprints => footprints,
+        :environment => environment,
+        :device => device,
+        :tmc_slot => slot,
+        :box_mac_address => mac_address,
+        :machine_name => machine_name
+    }
+    # Add optional params to hash (these aren't published in TomDocs)
+    project_release = args.fetch(:project_release, nil)
+    rb_hash[:project_release] = project_release unless project_release.nil?
+    device_version = args.fetch(:device_version, nil)
+    rb_hash[:device_version] = device_version unless device_version.nil?
+    browser = args.fetch(:browser, nil)
+    rb_hash[:browser] = browser unless browser.nil?
+    browser_version = args.fetch(:browser_version, nil)
+    rb_hash[:browser_version] = browser_version unless browser_version.nil?
+    operating_system = args.fetch(:operating_system, nil)
+    rb_hash[:operating_system] = operating_system unless operating_system.nil?
+    operating_system_version = args.fetch(:operating_system_version, nil)
+    rb_hash[:operating_system_version] = operating_system_version unless operating_system_version.nil?
+    target_test_plan_name = args.fetch(:target_test_plan_name, nil)
+    rb_hash[:target_test_plan_name] = target_test_plan_name unless target_test_plan_name.nil?
+    custom_1 = args.fetch(:custom_1, nil)
+    rb_hash[:custom_1] = custom_1 unless custom_1.nil?
+    custom_2 = args.fetch(:custom_2, nil)
+    rb_hash[:custom_2] = custom_2 unless custom_2.nil?
+    custom_3 = args.fetch(:custom_3, nil)
+    rb_hash[:custom_3] = custom_3 unless custom_3.nil?
+    eligible_to_report = args.fetch(:eligible_to_report, nil)
+    rb_hash[:eligible_to_report] = eligible_to_report unless eligible_to_report.nil?
+    device_type = args.fetch(:device_type, nil)
+    rb_hash[:device_type] = device_type unless device_type.nil?
+    # POST /suite/
+    logger.debug('POST /suite/')
+    resp = web_post(uri, :verify_mode => 0, :json => rb_hash).json
+    logger.warn("Failed to connect to Test Work Bench") if resp.nil?
+    suite_instance_id = resp['suite_instance_id']
+    if suite_instance_id.nil?
+      logger.warn('Failed to retrieve Suite Instance ID from TWB!')
+      logger.warn("Error Message: #{resp['error_message']}")
+      logger.warn("Program List: #{resp['program_list']}") if resp['program_list']
+      return nil
+    else
+      logger.debug("Suite Instance ID Retrieved: #{suite_instance_id}")
+      test_data.refresh
+      if test_data[:report_per_slot] # if users want to report to individual suites for individual slots
+        test_data["twb_suite_id_slot#{dut.slot}_iter#{iteration}".to_sym] = suite_instance_id
+      else
+        test_data[:twb_suite_id] = suite_instance_id
+      end
+      return suite_instance_id
+    end
+  end
+
+  # Public: POSTs the Case level results to TWB and retrieves the Case Instance ID.
+  #
+  # uri               - String full URI for the resource to request (default: "https://twb.dev-charter.net/ords/preprod/testcase/").
+  # test_case_name    - String name of the test case (default: test_data[:test_case_name]).
+  # suite_instance_id - result of twb_get_suite_instance_id
+  #
+  # Returns the String Case Instance ID if successful. Else, returns nil.
+  def twb_post_testcase(args={})
+    # Check to see if the Case Instance Id has already been written to disk
+    return twb_get_case_instance_id if twb_case_exists?
+
+    test_case_name = args.fetch(:test_case_name, self.name)
+    test_suite_name = (args.key?(:twb_suite_name)) ? args[:twb_suite_name] : test_data[:twb_suite_name]
+    program_application_name = (args.key?(:program_application_name)) ? args[:program_application_name] : test_data[:program_application_name]
+
+    suite_instance_id = (args.key?(:suite_instance_id)) ? args[:suite_instance_id] : twb_get_suite_instance_id(:twb_suite_name => test_suite_name,:program_application_name => program_application_name)
+
+    uri = args.fetch(
+        :uri,
+        'http://charter.testworkbench.com/ords/test/testcase/'
+    )
+    # Build hash for required params
+    rb_hash = {
+        :test_case_name => test_case_name,
+        :suite_instance_id => suite_instance_id
+    }
+    # Add optional params to hash (these aren't published in TomDocs)
+    head_end = args.fetch(:head_end, nil)
+    rb_hash[:head_end] = head_end unless head_end.nil?
+    stb_id = args.fetch(:stb_id, nil)
+    rb_hash[:stb_id] = stb_id unless stb_id.nil?
+    box_serial_no = args.fetch(:box_serial_no, nil)
+    rb_hash[:box_serial_no] = box_serial_no unless box_serial_no.nil?
+    box_mac_address = args.fetch(:box_mac_address, nil)
+    rb_hash[:box_mac_address] = box_mac_address unless box_mac_address.nil?
+    box_model_number = args.fetch(:box_model_number, nil)
+    rb_hash[:box_model_number] = box_model_number unless box_model_number.nil?
+    ams_number = args.fetch(:ams_number, nil)
+    rb_hash[:ams_number] = ams_number unless ams_number.nil?
+    sgui_id = args.fetch(:sgui_id, nil)
+    rb_hash[:sgui_id] = sgui_id unless sgui_id.nil?
+    zodiac_version = args.fetch(:zodiac_version, nil)
+    rb_hash[:zodiac_version] = zodiac_version unless zodiac_version.nil?
+    custom_1 = args.fetch(:custom_1, nil)
+    rb_hash[:custom_1] = custom_1 unless custom_1.nil?
+    custom_2 = args.fetch(:custom_2, nil)
+    rb_hash[:custom_2] = custom_2 unless custom_2.nil?
+    custom_3 = args.fetch(:custom_3, nil)
+    rb_hash[:custom_3] = custom_3 unless custom_3.nil?
+    # POST /testcase/
+    logger.debug('POST /testcase/')
+    resp = web_post(uri, :verify_mode => 0, :json => rb_hash).json
+    case_instance_id = resp['case_instance_id']
+    if case_instance_id.nil?
+      logger.warn("Failed to POST Testcase and retrieve Case Instance ID for Suite Instance ID #{suite_instance_id}")
+      logger.warn("Error Message: #{resp['error_message']}")
+      return nil
+    else
+      logger.debug("Case Instance ID Retrieved: #{case_instance_id}")
+      # Write Case ID to Test Data
+      test_data.refresh
+      test_data["twb_case_id#{id}_slot#{dut.slot}_iter#{iteration}".to_sym] = case_instance_id
+      return case_instance_id
+    end
+  end
+
+  # Public: POSTs the Step level results to TWB.
+  #
+  # s3_screenshot            - Boolean true/false indicating if a screenshot should be saved to S3 bucket (default: false).
+  # description              - String description of results (default: 'Step Passed.').
+  # twb_suite_name           - String name of the test suite (default: test_data[:twb_suite_name]).
+  # program_application_name - String name of the program application (default: test_data[:program_application_name]).
+  # screenshot               - Boolean true/false indicating a screenshot is/isn't sent (default: false).
+  # ss_filename              - String filename of image to POST. If none is provided a screenshot on active stb will be captured (default: nil)
+  # access_key_id            - String S3 access key ID (default: TWB access key).
+  # secret_access_key        - String S3 secret access key (default: TWB secret access key).
+  # bucket_name              - String S3 bucket name (default: 'charter-testworkbench-com').
+  # aws_folder               - String folder name where image will POST (default: TMC_Screenshots).
+  # case_instance_id  - result of twb_get_case_instance_id
+  # suite_instance_id - result of twb_get_suite_instance_id
+  #
+  # Returns String return message if successful. Else, returns nil.
+  def twb_post_teststep(args={})
+    tcr_auto_detail_text = args.fetch(:description, 'Step Passed.')
+    post_screenshot = args.fetch(:screenshot, false)
+    post_s3_screenshot = args.fetch(:s3_screenshot, false)
+    ss_filename = args.fetch(:ss_filename, nil)
+    test_suite_name = (args.key?(:twb_suite_name)) ? args[:twb_suite_name] : test_data[:twb_suite_name]
+    program_application_name = (args.key?(:program_application_name)) ? args[:program_application_name] : test_data[:program_application_name]
+
+    suite_instance_id = (args.key?(:suite_instance_id)) ? args[:suite_instance_id] : twb_get_suite_instance_id(:twb_suite_name => test_suite_name,:program_application_name => program_application_name)
+
+    case_instance_id = (args.key?(:case_instance_id)) ? args[:case_instance_id] : twb_get_case_instance_id(:twb_suite_name => test_suite_name)
+
+    # POST /teststep/
+    logger.debug('POST /teststep/')
+    uri = args.fetch(
+        :uri,
+        'http://charter.testworkbench.com/ords/test/teststep/'
+    )
+    result = args.fetch(:result_value, 'Passed')
+    result = 'Passed' if result == :PASS
+    result = 'Failed' if result == :FAIL
+    if post_s3_screenshot
+      access_key_id = args.fetch(:access_key_id, 'AKIAJR4GME4RASTKVXXQ')
+      secret_access_key = args.fetch(:secret_access_key, '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')
+      bucket_name = args.fetch(:bucket_name, 'charter-testworkbench-com')
+      aws_folder = args.fetch(:aws_folder, 'TMC_Screenshots')
+      image_path = twb_prep_s3_screenshot(:access_key_id => access_key_id,
+                                          :secret_access_key => secret_access_key,
+                                          :bucket_name => bucket_name,
+                                          :suite_instance_id => suite_instance_id,
+                                          :case_instance_id => case_instance_id,
+                                          :aws_folder => aws_folder,
+                                          :ss_filename => ss_filename)
+      resp = web_post(uri, :verify_mode => 0, :json => {
+          :suite_instance_id => suite_instance_id,
+          :case_instance_id => case_instance_id,
+          :step_status => result,
+          :actual_description => tcr_auto_detail_text,
+          #:component => 'at mail',
+          :image_path => image_path
+      }).json
+    else
+      resp = web_post(uri, :verify_mode => 0, :json => {
+          :suite_instance_id => suite_instance_id,
+          :case_instance_id => case_instance_id,
+          :step_status => result,
+          :actual_description => tcr_auto_detail_text,
+          #:component => 'at mail',
+          #:image_path => 'S3 server location'
+      }).json
+    end
+    if post_screenshot
+      twb_post_screenshot(
+          :twb_suite_name => test_suite_name,
+          :program_application_name => program_application_name,
+          :suite_instance_id => suite_instance_id,
+          :case_instance_id => case_instance_id,
+          :ss_filename => ss_filename
+      )
+    end
+    return_msg = resp['return_msg']
+    if return_msg.nil?
+      logger.warn('Failed to POST Teststep to TWB!')
+      return nil
+    else
+      logger.debug("Return Msg: #{return_msg}")
+      return return_msg
+    end
+  end
+  
+  
+  # Public: Takes a screenshot on current STB and POSTS to TWB. The user has the ability to set the Suite & Case instance ID or if a Suite &/or Case ID already exists for the twb_suite_name or current Job Name, those will be used.  In the case where neither a Suite & Case instance ID are provided and they don't already exist for the twb_suite_name or Job Name, new ones will be retrieved from TWB and added to the args.
+  #
+  # twb_suite_name    - String name of the Test Suite Name to report to (default: test_data[:twb_suite_name])
+  # program_application_name - String name of the Program Application to report to (default: test_data[:program_application_name]).
+  # ss_filename       - String filename of image to POST. If none is provided a screenshot on active stb will be captured (default: nil)
+  # timeout           - Integer total milliseconds to wait for a response (default: 5.min).
+  # verify_mode       - Integer desired HTTP verify mode (default: nil).
+  # uri               - String full URI for the resource to request(default: "http://charter.testworkbench.com/ords/test/postScreenshots/#{case_instance_id}").
+  # case_instance_id  - result of twb_get_case_instance_id
+  # suite_instance_id - result of twb_get_suite_instance_id
+  # size              - number from 0 to 100 for percentage size of the image
+  # quality           - number from 0 to 100 for image quality
+  #
+  # Returns the path to the screenshot file, ss_filename
+  def twb_post_screenshot!(args={})
+    args[:twb_suite_name] = test_data[:twb_suite_name] unless args.key?(:twb_suite_name)
+    test_suite_name = args[:twb_suite_name]
+    args[:program_application_name] = test_data[:program_application_name] unless args.key?(:program_application_name)
+    program_application_name = args[:program_application_name]
+    description = args[:description]
+    description = 'Starting Test...' if description.nil?
+    unless args.key?(:suite_instance_id)
+        args[:suite_instance_id] = twb_get_suite_instance_id(
+            :twb_suite_name => test_suite_name, 
+            :program_application_name => program_application_name,
+            :description => description
+        )
+    end
+    args[:case_instance_id] = twb_get_case_instance_id(:twb_suite_name => test_suite_name) unless args.key?(:case_instance_id)
+    twb_post_screenshot(args)
+  end
+
+  # Public: POSTs the Step level results to TWB. Edits the args to add missing data
+  #
+  # s3_screenshot            - Boolean true/false indicating if a screenshot should be saved to S3 bucket (default: false).
+  # description              - String description of results (default: 'Step Passed.').
+  # twb_suite_name           - String name of the test suite (default: test_data[:twb_suite_name]).
+  # program_application_name - String name of the program application (default: test_data[:program_application_name]).
+  # screenshot               - Boolean true/false indicating a screenshot is/isn't sent (default: false).
+  # ss_filename              - String filename of image to POST. If none is provided a screenshot on active stb will be captured (default: nil)
+  # access_key_id            - String S3 access key ID (default: TWB access key).
+  # secret_access_key        - String S3 secret access key (default: TWB secret access key).
+  # bucket_name              - String S3 bucket name (default: 'charter-testworkbench-com').
+  # aws_folder               - String folder name where image will POST (default: TMC_Screenshots).
+  # case_instance_id  - result of twb_get_case_instance_id
+  # suite_instance_id - result of twb_get_suite_instance_id
+  #
+  # Returns String return message if successful. Else, returns nil.
+  def twb_post_teststep!(args={})
+    args[:twb_suite_name] = test_data[:twb_suite_name] unless args.key?(:twb_suite_name)
+    test_suite_name = args[:twb_suite_name]
+    args[:program_application_name] = test_data[:program_application_name] unless args.key?(:program_application_name)
+    program_application_name = args[:program_application_name]
+    description = args[:description]
+    description = 'Starting Test...' if description.nil?
+    unless args.key?(:suite_instance_id)
+        args[:suite_instance_id] = twb_get_suite_instance_id(
+            :twb_suite_name => test_suite_name, 
+            :program_application_name => program_application_name,
+            :description => description
+        )
+    end
+    args[:case_instance_id] = twb_get_case_instance_id(:twb_suite_name => test_suite_name) unless args.key?(:case_instance_id)
+    twb_post_teststep(args)
+  end
+
+  # Public: Performs a GET request for the given URI.
+  #
+  # uri        - String full URI for the resource to GET.
+  # body       - String data to populate the request body (default: nil).
+  # headers    - Hash of headers to add to the request (default: {}).
+  # basic_auth - Hash of basic authentication :username and :password to use (default: nil).
+  # timeout    - Integer total milliseconds to wait for a response (default: 5.min).
+  #
+  # Returns the Hash JSON response, or nil if there was an error.
+  def web_get(uri, args={})
+    web_request(:get, uri, args)
+  end
+
+  # Public: Performs a POST request for the given URI.
+  #
+  # uri        - String full URI for the resource to POST.
+  # body       - String data to populate the request body (default: nil).
+  # json       - Hash JSON object to send in the request body (default: nil). By default no JSON will be included.
+  # form_data  - Hash form data to send in the request (default: nil). By default no form data will be included.
+  # basic_auth - Hash of basic authentication :username and :password to use (default: nil).
+  # headers    - Hash of headers to add to the request (default: {}).
+  # timeout    - Integer total milliseconds to wait for a response (default: 5.min).
+  #
+  # Returns the Hash JSON response, or nil if there was an error.
+  def web_post(uri, args={})
+    web_request(:post, uri, args)
+  end
+
+  # Public: Performs a PUT request for the given URI.
+  #
+  # uri        - String full URI for the resource to PUT.
+  # body       - String data to populate the request body (default: nil).
+  # json       - Hash JSON object to send in the request body (default: nil). By default no JSON will be included.
+  # form_data  - Hash form data to send in the request (default: nil). By default no form data will be included.
+  # basic_auth - Hash of basic authentication :username and :password to use (default: nil).
+  # headers    - Hash of headers to add to the request (default: {}).
+  # timeout    - Integer total milliseconds to wait for a response (default: 5.min).
+  #
+  # Returns the Hash JSON response, or nil if there was an error.
+  def web_put(uri, args={})
+    web_request(:put, uri, args)
+  end
+
+  # Public: Performs a DELETE request for the given URI.
+  #
+  # uri        - String full URI for the resource to DELETE.
+  # body       - String data to populate the request body (default: nil).
+  # json       - Hash JSON object to send in the request body (default: nil). By default no JSON will be included.
+  # form_data  - Hash form data to send in the request (default: nil). By default no form data will be included.
+  # basic_auth - Hash of basic authentication :username and :password to use (default: nil).
+  # headers    - Hash of headers to add to the request (default: {}).
+  # timeout    - Integer total milliseconds to wait for a response (default: 5.min).
+  #
+  # Returns the Hash JSON response, or nil if there was an error.
+  def web_delete(uri, args={})
+    web_request(:delete, uri, args)
+  end
+
+  # Public: Computes the similarity of two strings by searching the read string for
+  #         the expected string within
+  # expected - the string expected by the test
+  # read     - the string read from screen
+  # options  - options for cleaning common OCR text errors. see get_clean_ocr_text
+  def get_substring_similarity(expected, read, options = {})
+    expected = get_clean_ocr_text(expected, options)
+    read = get_clean_ocr_text(read, options)
+
+		max_similarity = 0
+
+		# if the expected string is longer than the read string
+		# padding will need to be added
+		if expected.length > read.length
+			read = read.ljust(expected.length, ' ')
+		end
+
+		i = 0
+		until i > read.length - expected.length do
+			substring = read[i, expected.length]
+			similarity = get_string_similarity(expected, substring)
+			max_similarity = [similarity, max_similarity].max
+			i += 1
+		end
+
+		return max_similarity
+  end
+
+	# Public: Computes the similarity of two strings and returns a value of 1.0 for
+  #         identical strings. This is based on the Levenshtein distance algorithm
+  # s1 - string to compare
+  # s2 - string to compare
+  # options - options to process strings (see: get_clean_ocr_text)
+  def get_string_similarity(s1, s2, options = {})
+    s1 = get_clean_ocr_text(s1, options)
+    s2 = get_clean_ocr_text(s2, options)
+
+		if s1 == s2
+			return 1.0
+		end
+
+		n = s1.length
+		m = s2.length
+		d = Array.new(n + 1) { Array.new(m +1) }
+
+		(0..n).each {|i| d[i][0] = i}
+		(0..m).each {|j| d[0][j] = j}
+
+		for i in 1..n
+			for j in 1..m
+				cost = s2[j - 1] == s1[i - 1] ? 0 : 1
+				d[i][j] = [d[i - 1][j] + 1, d[i][j - 1] + 1, d[i - 1][j - 1] + cost].min
+			end
+		end
+
+		denom = [n, m].max
+		return 1.0 - (d[n][m] / denom.to_f)
+	end
+
+  # Public: Returns a modified string with common OCR replacements
+  # inputString - string to be cleaned
+  # options     - operations to be applied to the input string
+	def get_clean_ocr_text(inputString, options = {:removeSpaces => false,
+                                                 :toUppercase => false,
+                                                 :removeSpecials => false,
+                                                 :replaceB3 => false,
+                                                 :replaceB8 => false,
+                                                 :replaceG6 => false,
+                                                 :replaceO0 => false,
+                                                 :replaceTL => false,
+                                                 :replaceS5 => false})
+		modifiedString = inputString
+		if options[:removeSpaces]
+			modifiedString = modifiedString.gsub(/\s+/, '')
+		end
+		if options[:toUppercase]
+			modifiedString = modifiedString.upcase
+		end
+		if options[:removeSpecials]
+			modifiedString = modifiedString.gsub(/[^A-Za-z0-9]/, '')
+		end
+		if options[:replaceB3]
+			modifiedString = modifiedString.gsub(/[3B]/, 'B')
+		end
+		if options[:replaceB8]
+			modifiedString = modifiedString.gsub(/[8B]/, 'B')
+		end
+		if options[:replaceG6]
+			modifiedString = modifiedString.gsub(/[G6]/, 'G')
+		end
+		if options[:replaceO0]
+			modifiedString = modifiedString.gsub(/[0O]/, 'O')
+		end
+		if options[:replaceTL]
+			modifiedString = modifiedString.gsub(/[LlT]/, 'L')
+		end
+		if options[:replaceS5]
+			modifiedString = modifiedString.gsub(/[S5]/, 'S')
+		end
+
+		return modifiedString
+	end
+
+  # Public: Converts a Ruby object to standard JSON format, i.e. :is_on_screen becomes :isOnScreen, etc.
+  #
+  # obj - Object to convert.
+  #
+  # Returns the converted Object.
+  def jsonify(obj, camel_case: true)
+    if obj.is_a?(Hash)
+      Hash[obj.map {|k,v| [jsonify(k.to_sym, camel_case: camel_case), jsonify(v, camel_case: camel_case)]}]
+    elsif obj.is_a?(Array)
+      obj.map {|v| jsonify(v, camel_case: camel_case)}
+    elsif obj.is_a?(Symbol)
+      camel_case ? to_camel_case(obj) : obj
+    else
+      obj
+    end
+  end
+
+  # Public: Converts a JSON object to standard Ruby format, i.e. 'isOnScreen' becomes :is_on_screen, etc.
+  #
+  # obj - Object to convert.
+  #
+  # Returns the converted Object.
+  def rubify(json, snake_case: true)
+    if json.is_a?(Hash)
+      Hash[json.map {|k,v| [rubify(k.to_sym, snake_case: snake_case), rubify(v, snake_case: snake_case)]}]
+    elsif json.is_a?(Array)
+      json.map {|v| self.rubify(v, snake_case: snake_case)}
+    elsif json.is_a?(Symbol)
+      snake_case ? to_snake_case(json) : json
+    else
+      json
+    end
+  end
+
+  # Public: Converts a value into snake_case
+  #
+  # value - String or Symbol to convert
+  #
+  # Returns the String or Symbol converted to snake_case.
+  def to_snake_case(value)
+    snake_case = value.to_s.gsub(/(?<!^)([A-Z])/, '_\1').downcase
+    value.is_a?(Symbol) ? snake_case.to_sym : snake_case
+  end
+
+  # Public: Converts a value into PascalCase
+  #
+  # value - String or Symbol value to convert
+  #
+  # Returns the String or Symbol converted to PascalCase.
+  def to_pascal_case(value)
+    pascal_case = value.to_s.split('_').map { |part| part.slice(0, 1).upcase + part.slice(1..-1) }.join
+    value.is_a?(Symbol) ? pascal_case.to_sym : pascal_case
+  end
+
+  # Public: Converts a value into camelCase
+  #
+  # value - String or Symbol value to convert
+  #
+  # Returns the String or Symbol converted to camelCase.
+  def to_camel_case(value)
+    parts = value.to_s.split('_').reject {|part| part.empty?}
+    camel_case = parts[0].slice(0, 1).downcase + parts[0].slice(1..-1) +
+      parts[1..-1].map { |part| part.slice(0, 1).upcase + part.slice(1..-1) }.join
+    value.is_a?(Symbol) ? camel_case.to_sym : camel_case
+  end
+
+  # Public: Gets a readable string for the given size in bytes.
+  #
+  # size_bytes - Integer size in bytes.
+  #
+  # Returns a String readable size in bytes.
+  def get_readable_size(size_bytes)
+    units = %w(B KB MB GB TB)
+    Array(0..units.length - 1).reverse.each do |i|
+      mult = 1000.0 ** i
+      if size_bytes >= (mult == 1 ? 0 : mult)
+        return "#{(size_bytes / mult).round(1)} #{units[i]}"
+      end
+    end
+  end
+
+  # Public: Gets a readable string for the given time in seconds.
+  #
+  # time_sec - Numeric seconds.
+  #
+  # Returns a String readable time.
+  def get_readable_time(time_sec)
+    parts = []
+    h = (time_sec / 3600.0).to_i
+    parts << "#{h}h" if h > 0
+    time_sec -= (h * 3600)
+    m = (time_sec / 60.0).to_i
+    parts << "#{m}m" if m > 0
+    time_sec -= (m * 60)
+    s = time_sec.to_i
+    parts << "#{s}s" if s > 0
+    ms = ((time_sec - s) * 1000.0).round
+    parts << "#{ms}ms" if ms > 0 || parts.empty?
+    parts.join(', ')
+  end
+  
+  # Public: Can send an alert to a WebEx room. Must have token to pass into first param.
+  #
+  # token    - Obtain token by creating bot @ https://developer.webex.com/docs/bots
+  # room_id  - Create room in webex, add bot to room. Then, can get roomId here: https://developer.webex.com/docs/api/v1/rooms/list-rooms
+  # text     - text to send into message body (default: nil)
+  # markdown - useful if you would like to create markdown text instead of plain. (default: nil)
+
+  def send_webex_alert(token, room_id, text: nil, markdown: nil)
+    web_post("https://api.ciscospark.com/v1/messages",  { json: {
+                                                              text: text.to_s, # to_s incase user doesn't sanitize.
+                                                              roomId: room_id.to_s,
+                                                              markdown: markdown.to_s
+    },
+    # pass token into header
+       headers: {
+         "Authorization": "Bearer #{token}"
+        }
+    })
+  end
+
+  private
+
+  # Internal: Gets the specified bucket from the given S3 instance, or creates the bucket if it does not exist.
+  def get_or_create_s3_bucket(s3, bucket)
+    b = s3.bucket(bucket)
+    unless b.exists?
+      b.create
+      logger.debug('Created bucket')
+    end
+    b
+  end
+
+  # Internal: Requires the AWS gem and executes the given block.
+  def with_aws(&block)
+    require 'aws-sdk-s3'  # require here as it takes some time, to avoid impacting syntax eval
+    block.call
+  end
+
+  # Internal: Passes an AWS S3 instance to the given block.
+  def aws(&block)
+    with_aws { block.call(Aws::S3::Resource.new) }
+  end
+
+  # Internal: Gets the current user.
+  def current_user
+    if @current_user.nil?
+      @current_user = tmc_get('/api/login') || {}
+    end
+    @current_user
+  end
+
+  # Internal: Gets the results path.
+  def results_path
+    if @results_path.nil?
+      # Bad idea to build absolute paths in the Ruby framework. Maybe get them from TMC (new endpoint).
+      user = current_user['shortName']
+      @results_path = "C:\\Program Files\\Time Warner Cable\\users\\#{user}\\results"
+    end
+    @results_path
+  end
+
+  # Internal: Gets the image samples path.
+  def image_samples_path
+    if @image_samples_path.nil?
+      # Bad idea to build absolute paths in the Ruby framework. Maybe get them from TMC (new endpoint).
+      user = current_user['shortName']
+      @image_samples_path = "C:\\Program Files\\Time Warner Cable\\users\\#{user}\\images"
+    end
+    @image_samples_path
+  end
+
+  # Internal: Gets the current workspace.
+  def current_workspace
+    if @current_workspace.nil?
+      @current_workspace = tmc_get('/api/workspaces/current')['name'] rescue nil
+    end
+    @current_workspace
+  end
+
+  # Internal: Gets the server info.
+  def server_info
+    if @tmc_server_info.nil?
+      @tmc_server_info = tmc_get('/api/info')
+    end
+    @tmc_server_info
+  end
+
+  # Internal: Gets the TMC software version.
+  def tmc_software_version
+    if @tmc_server_version.nil?
+      @tmc_server_version = server_info['version']
+    end
+    @tmc_server_version
+  end
+
+  # Internal: Performs a GET request for the given TMC resource.
+  #
+  # resource    - String URI of resource to GET. Exclude the protocol, host, and port.
+  # port        - Integer alternate port to use (default: 80).
+  # timeout     - Integer total milliseconds to wait for a response (default: 5.min).
+  # attr        - Symbol name of response attribute to get (default: :json).
+  #
+  # Returns the Hash JSON response, or nil if there was an error.
+  def tmc_get(resource, args={})
+    tmc_request(:get, resource, args)
+  end
+
+  # Internal: Performs a POST request for the given TMC resource.
+  #
+  # resource    - String URI of resource to POST. Exclude the protocol, host, and port.
+  # port        - Integer alternate port to use (default: 80).
+  # json        - Hash JSON object to send in the request body (default: nil). By default no JSON will be included.
+  # timeout     - Integer total milliseconds to wait for a response (default: 5.min).
+  #
+  # Returns the Hash JSON response, or nil if there was an error.
+  def tmc_post(resource, args={})
+    tmc_request(:post, resource, args)
+  end
+
+  # Internal: Performs a PUT request for the given TMC resource.
+  #
+  # resource    - String URI of resource to PUT. Exclude the protocol, host, and port.
+  # port        - Integer alternate port to use (default: 80).
+  # json        - Hash JSON object to send in the request body (default: nil). By default no JSON will be included.
+  # timeout     - Integer total milliseconds to wait for a response (default: 5.min).
+  #
+  # Returns the Hash JSON response, or nil if there was an error.
+  def tmc_put(resource, args={})
+    tmc_request(:put, resource, args)
+  end
+
+  # Internal: Performs a DELETE request for the given TMC resource.
+  #
+  # resource    - String URI of resource to DELETE. Exclude the protocol, host, and port.
+  # port        - Integer alternate port to use (default: 80).
+  # json        - Hash JSON object to send in the request body (default: nil). By default no JSON will be included.
+  # timeout     - Integer total milliseconds to wait for a response (default: 5.min).
+  #
+  # Returns the Hash JSON response, or nil if there was an error.
+  def tmc_delete(resource, args={})
+    tmc_request(:delete, resource, args)
+  end
+
+  # Internal: Performs a web request for the given TMC resource.
+  #
+  # http_method - Symbol HTTP method to use from :get, :post, :put, :delete.
+  # resource    - String URI of resource to request. Exclude the protocol, host, and port.
+  # port        - Integer alternate port to use (default: 443).
+  # json        - Hash JSON object to send in the request body (default: nil). By default no JSON will be included.
+  # attr        - Symbol attribute to return (default: :json).
+  # timeout     - Integer total milliseconds to wait for a response (default: 5.min).
+  #
+  # Returns the Hash JSON response, or nil if there was an error.
+  def tmc_request(http_method, resource, args={})
+    uri = "https://#{host}:#{args.fetch(:port, 443)}#{resource}"
+    args[:headers] = {'TMC-Identity-GUID': identity}
+    return_attr = args.delete(:attr) || :json
+    resp = web_request(http_method, uri, args)
+    if !resp.json.nil? && resp.json['status'] == -1
+      raise "#{resp.json['statusMessage'] || ''}\n#{resp.json['statusDetail'] || ''}".strip
+    end
+    resp.send(return_attr)
+  end
+
+end