oats 0.0.1

data/lib/oats/oats.rb

@@ -0,0 +1,637 @@
+require 'oats/util'
+require 'oats/oats_exceptions'
+# Need these set for OCC when this is required from OCC
+ENV['OATS_HOME'] ||= File.expand_path( '..', File.dirname(__FILE__) )
+ENV['OATS_TESTS'] ||= (ENV['OATS_HOME'] + '/oats_tests')
+
+module Oats
+
+  # Main method that starts oats execution.
+  # Parameters are command-line arguments
+  # Returns oats_info object containing execution results
+  def Oats.run(args = nil)
+    Driver.run(args)
+  end
+
+  # Registers classes to initialize class methods by calling call <Class>.init before
+  # each TestList execution.  To use, put inside the class: Oats.testlist_init(self)
+  def Oats.testlist_init(klas, *args)
+    $oats_execution['testlist_init'] ||= {}
+    $oats_execution['testlist_init'][klas] = args
+  end
+
+  # Merges indicated YAML into the test's Oats.data
+  def Oats.yaml(yaml_file)
+    OatsData.include_yaml_file yaml_file
+  end
+
+  # Adds new test to the current test_files
+  # OatsTest.names method(s) should be defined under the OatsTest module in the lib
+  # Example:
+  # Oats.add_test Oats.add_test "method_test", "testid_#{i}", "parameter_#{i}"
+  # module OatsTest # Place this definition in the 'lib' to be auto-required
+  #    def self.method_test(params)
+  #      Oats.info "Running new test: #{Oats.test.id} with params: #{params.inspect}"
+  #    end
+  # end
+  def Oats.add_test(*args)
+    #    Oats.assert self.respond_to?(name), "Method OatsTest.#{names} is not defined."
+    #    args[0] = TestData.current_test.dir.sub(/\.rb/,".#{args[0]}.methodTest")
+
+    #    args.unshift TestData.current_test.dir
+    $oats_global['test_files'] ||= []
+    $oats_global['test_files'].push(args[0])
+  end
+
+  # Raises OatsAssertError unless  is includer.include?(includee) is true
+  # If given pre_message preceeds the standard message showing expected and actuals.
+  # Example:
+  # Oats.assert_include('is','this, "Should never fail")
+  def Oats.assert_include?(includee, includer, pre_message = nil)
+    pre_message += ' ' if pre_message
+    Oats.assert(includer.include?(includee),"#{pre_message} Failed since #{includer.inspect} does not include #{includee.inspect}")
+  end
+  # Raises OatsAssertError unless two parameters are '=='
+  # If given pre_message preceeds the standard message showing expected and actuals.
+  # Example:
+  # Oats.assert_equal(old_count, new_count, "After deletion, creative counts did not decrease.")
+  def Oats.assert_equal(expected, actual, pre_message = nil)
+    pre_message += ' ' if pre_message
+    Oats.assert(expected == actual,"#{pre_message}Expected value #{expected.inspect} does not match actual #{actual.inspect}")
+  end
+  # Raises OatsAssertError if two parameters are '=='
+  def Oats.assert_not_equal(expected, actual, pre_message = nil)
+    pre_message += ' ' if pre_message
+    Oats.assert(expected != actual,"#{pre_message}Expected different but received the same value: #{actual.inspect}")
+  end
+  # Raises OatsTestError unless test is true
+  def Oats.assert(test, message = nil)
+    message = 'Assertion failed.' unless message
+    raise(OatsAssertError, message) unless test
+  end
+
+  # Returns a browser (selenium driver), logging into RL site or opening URL.
+  # The browser is retrieved and reused in the subsequent rtest.*rb executions,
+  # but it is automatically closed at the end of each Oats test. If exists, the
+  # browser is also accessible via the global $selenium.
+  # The arguments url_or_site and credentials will be passed to Oselenium.login
+  #
+  # Parameters:
+  # url_or_site:: String, A URL, or site:
+  #                     [root@oats ]
+  #               Required parameter for the first invocation, can be
+  #               omitted in subsequent invocations to get the current browser.
+  #               Re-issueing it w/o logging out of the same site will reopen
+  #               the landing page. A different site will cause logout of the
+  #               old site and login to the new site. User will be created if
+  #               it does not already exists.
+  # new_browser:: If true, will create a new browser while keeping the old one.
+  # credentials::  Hash to contain credentials['email'] and, credentials['password']
+  #
+  # Methods in addition to the selenium driver methods are:
+  # login(site):: Same as Oats.browser(url_or_site), for a site. Returns nil if
+  #               site is not recognized.
+  # logout:: Logs out of the last logged in sites if any and returns browser.
+  #          Logout may not succeed if logout button is unavailable.
+  #
+  # Examples:
+  #  browser = Oats.browser('oats')
+  #  browser.click("link=Orders")
+  #  browser.login('root@')
+  #  browser.logout
+  #
+  def Oats.browser(*args)
+    require 'oats/oselenium' unless defined?(Oats::Oselenium)
+    Oselenium.browser(*args)
+  end
+
+  # Capture system screenshot and logs
+  # Returns captured file name if successful, or nil.
+  def Oats.system_capture
+    return if $selenium.nil? or # Snapshots are not supported on Ubuntu/Chrome
+    ($oats['selenium']['browser_type'] == 'chrome' and ENV['OS'] == 'Linux')
+    ct = TestData.current_test
+    file = Util.file_unique(fn="page_screenshot.png", ct.result)
+    Oats.info "Will attempt to capture #{fn}."
+    begin
+      timeout($oats['selenium']['capture_timeout']) { selenium.save_screenshot(file) }
+      ct.error_capture_file = fn
+    rescue Exception => e
+      $log.warn "Could not capture page screenshot: #{e}"
+    end
+    return ct.error_capture_file
+  end
+
+  # Loads the indicated ruby file file after locating it in the tests directory.
+  #
+  # Parameters:
+  # ruby_file_name: Name or path snippet of a the ruby file. Could be a glob.
+  #
+  # Examples:
+  #  Oats.oload 'rtest_AddCreatives'
+  #  Oats.oload 'verifyAddCreatives/rtest_Add*'
+  def Oats.oload(ruby_file_name)
+    file = TestCase.locate_test_rb(ruby_file_name)
+    if file
+      begin
+        Oats.debug "Loading rb file: #{file}"
+        Oats.global['oloads'].push file
+        load(file)
+      ensure
+        Oats.debug "Finished rb file: #{file}"
+        Oats.global['oloads'].pop
+      end
+    else
+      raise OatsError, "Can not locate ruby file to load: #{ruby_file_name}"
+    end
+  end
+
+  # Hash object providing access to the oats.yml state entries at the time of
+  # test execution. Note that Oats.data contents are isolated from modification
+  # across tests. If path is not found, returns nil unless do_raise_if_missing
+  # is set.
+  #  map_string:: Period seperated YAML path into the current Oats.data
+  #    If not specified, returns the full hash.
+  #  do_raise_if_missing:: set true to raise OatsTestError if key is missing
+  # Examples:
+  #  Oats.data 'selenium.browser' == 'firefox
+  #  Oats.data['selenium']['browser'] == 'firefox'
+  def Oats.data(map_str = nil, do_raise_if_missing = nil)
+    return $oats unless map_str
+    data_keys = map_str.split('.')
+    value = $oats
+    #    until ! value.kind_of?(Hash) or data_keys.size == 0 do
+    loop do
+      return value if data_keys.empty?
+      if value.instance_of? Hash
+        key = data_keys.shift
+        if do_raise_if_missing
+          Oats.assert(value.has_key?(key),  "Can not locate #{key} for #{map_str} at ")
+        end
+        value = value[key]
+      else
+        return nil
+      end
+    end
+  end
+
+  # Adjust result dir YAML entries if running on agent mode
+  def Oats.result_archive_dir
+    return $oats['result_archive_dir'] if $oats['result_archive_dir']
+    oats_data = $oats
+    oats_data['execution']['dir_results'] = Util.expand_path(oats_data['execution']['dir_results'])
+    oats_data['result_archive_dir'] = oats_data['execution']['dir_results'] + '_archive'
+    if $oats_execution['agent']
+      agent_nickname = Ragent.occ['agent_nickname']
+      if oats_data['execution']['dir_results'] !~ /#{agent_nickname}$/
+        # Should move to a better place.This is unrelated to results, Just picking up the agent file.
+        agent_ini_file = File.join(ENV['HOME'], agent_nickname + '_oats.yml')
+        oats_data = OatsData.load(agent_ini_file,oats_data) if File.exist?(agent_ini_file)
+        oats_data['result_archive_dir'] += '/' + agent_nickname
+        oats_data['execution']['dir_results'] += '/' + agent_nickname
+      end
+    end
+    FileUtils.mkdir_p(oats_data['result_archive_dir'])
+    return oats_data['result_archive_dir']
+  end
+
+  # Returns input or ''. Used to force ruby eval of Oat.data YML values
+  def Oats.eval(input=nil)
+    return input || ''
+  end
+  # Returns hash object containing info about persistent oats internal variables
+  # for the complete oats execution. Contents of Oats.context are also persisted  into
+  # the results.dump in the results directory.
+  #
+  # Examples:
+  #  Oats.context['stop_oats'] == true #  Request stopping oats after current test
+  def Oats.context
+    $oats_info
+  end
+
+  # Output debug level log entries.
+  def Oats.debug(arg)
+    $log.debug(arg)
+  end
+
+  # Output error level log entries.
+  def Oats.error(arg)
+    ex = OatsTestError.exception(arg.to_s)
+    TestData.error(ex)
+    $log.error(arg)
+  end
+
+  # Exit a OATS Test from the middle without throwing an error.
+  def Oats.exit(message=nil)
+    raise OatsTestExit, message if message
+    raise OatsTestExit
+  end
+
+  # Raise OatsTestExit and SKIP current test if there was a previous test and
+  # if previous test dif not pass or or_if_true is true
+  def Oats.skip_unless_previous_test_is_ok(or_if_true = false)
+    return unless TestData.previous_test
+    if or_if_true or TestData.previous_test.status != 0
+      Oats.data['execution']['no_run'] = true
+      Oats.exit "Skipping this test since previous test did not pass."
+    end
+  end
+
+  # Exception raised by Oats.filter
+  class OatsFilterError  < OatsError ; end
+
+  # Returns Windows file path of a file name to be used with file uploads.
+  # name:: globbed file name inside the test directory or under test/data folder.
+  # Examples:
+  # image = Oats.file "125x125_GIF_4K.gif"
+  def Oats.file(name)
+    file = name if File.exist?(name)
+    file = Dir.glob(File.join(Oats.test.path, name)).first unless file
+    file = Dir.glob(File.join( $oats['execution']['dir_tests'], 'data', '**',name)).first unless file
+    Oats.assert file, "Can not locate file with name [#{name}]"
+    Oselenium.remote_webdriver_map_file_path(file)
+  end
+
+
+  # Moves files downloaded by selenium into the test.result directory.
+  # Input is shell glob names, defaulting to '*'.
+  # Returns array of basenames of copied files.
+  # Assumes downloaded file is not empty
+  def Oats.collect_downloaded(file_glob_name = '*')
+    downloaded_files = []
+    result_dir = TestData.current_test.result
+    #    cur_test.collect_downloaded_output if cur_test && cur_test.instance_of?(TestCase)
+    Oats.wait_until("There were no files in: #{$oats_global['download_dir']}", 15) do
+      Dir.glob(File.join($oats_global['download_dir'],file_glob_name)) do |e|
+        # Ensure file is fully downloaded
+        old_size = 0
+        Oats.wait_until do
+          new_size = File.size?(e) # Returns nil if size is zero. Assumes downloaded file is not empty
+          if new_size and new_size == old_size # File size stabilized
+            FileUtils.mv(e, result_dir )
+            downloaded_files.push(File.basename(e))
+          else
+            old_size = new_size
+            false
+          end
+        end
+      end
+      downloaded_files != []
+    end
+    return downloaded_files
+  end
+
+
+  # Removes the random words from files in 'Oats.test.result' by applying
+  # prescribed filter to each line of file and replaces it.  The return value is
+  # the filtered contents of the file. The filtered contents are also placed in
+  # test.out to be compared as expected results. Errors will raise OatsFilterError.
+  # * With a block replaces each line with result of the block.
+  # * Without block, uses a pattern and replacement parameters for filtering.
+  # * If pattern and replacement is missing it copies the whole input file.
+  # * If in_file is a string, no output file is generated unless out_file is given.
+  #
+  # Parameters:
+  # in_file:: Name or path of file that is to be filtered and moved to
+  #	          Oats.test.out.  It can also be String Array or String containing the
+  #	          actual contents. If the file contains a space, it is assumed to be
+  #	          contents. Missing input or file raises OatsFilterError.
+  # out_file:: File name to use for the output file. This is an optional
+  #            parameter which can be skipped. If skipped, basename of the
+  #            infile is used.
+  # pattern:: A regexp pattern to pass on to a gsub or grep method.  Grep is
+  #	          used if replacement parameter is unspecified, in other words
+  #	          file_contents.grep(/pattern_string/)
+  # replacement:: Fixed string to replace the pattern by calling
+  #	              file_contents.gsub(pattern,replacement)
+  #
+  # Examples:
+  #  Oats.filter('input.txt') # Moves input.txt to test.out for auto-verification.
+  #  Oats.filter('input.txt','output.txt,/this/) # Considers only lines containing 'this'
+  #  Oats.filter('input.txt',/this.*that/,'thisAndThat') # Replaces indicated content
+  #  Oats.filter('input.txt') { |line| line unless line == 'this\n' } # Omits 'this\n' line
+  def Oats.filter(in_file, *param)
+    raise(OatsFilterError,"At least one inputis required.") unless in_file
+    test = TestData.current_test
+    case in_file
+    when String
+      raise(OatsFilterError,"Input string can not be empty.") if in_file == ''
+      if /\s/ =~ in_file # If there is space in name, assume it is not a file
+        input_is_file = false
+        lines = in_file.split($/)
+      else
+        input_is_file = true
+        if File.exist?(in_file)
+          filter_file = Util.expand_path(in_file)
+        else
+          in_files = Dir[in_file]
+          filter_file = in_files[0] unless in_files.empty?
+        end
+        unless filter_file
+          result_dir = test.result
+          filter_file = Util.expand_path(in_file, result_dir)
+          filter_file = nil unless File.exist?(filter_file)
+        end
+        unless filter_file
+          filter_file = Util.expand_path(in_file, result_dir)
+          in_files = Dir[filter_file]
+          if in_files.empty?
+            filter_file = nil
+          else
+            filter_file = in_files[0]
+          end
+        end
+        raise(OatsFilterError,"Can not locate file to filter: [#{in_file}] in: " + result_dir) unless filter_file
+        raise(OatsFilterError,"Can not read file to filter: #{filter_file}") unless File.readable?(filter_file)
+      end
+    when Array
+      input_is_file = false
+      lines = in_file
+    else
+      raise(OatsFilterError,'Unrecognized input type.')
+    end
+
+    if not param.empty? and param[0].instance_of?(String)
+      out_file = File.join(test.out, File.basename(param[0]))
+      param.shift
+    elsif input_is_file
+      out_file = File.join(test.out, File.basename(filter_file))
+    else
+      out_file = nil
+    end
+    FileUtils.mkdir_p(test.out) if test.out
+    if param.empty?
+      pattern = nil
+    else
+      pattern = param[0]
+      param.shift
+    end
+    if param.empty?
+      replacement = nil
+    else
+      replacement = param[0]
+      param.shift
+    end
+    lines = IO.readlines(filter_file) if input_is_file
+    #      FileUtils.rm(filter_file)
+    out_lines = if block_given?
+      lines.collect { |line| yield(line) }
+    elsif replacement
+      lines.collect { |line| line.sub!(pattern,replacement) }
+    elsif pattern
+      lines.grep(pattern)
+    else
+      if out_file and filter_file
+        FileUtils.cp(filter_file, out_file) # Do not mv here.
+        # Otherwise out_file can not produce unique files
+        return lines ? lines : []
+      end
+      lines ? lines : []
+    end
+
+    if out_lines
+      out_lines.delete_if{ |line| line.chomp == '' } unless out_lines.empty?
+      if out_file and not out_lines.empty?
+        File.open(out_file,'a+') { |ios| ios.write(out_lines.join) }
+      end
+    else
+      out_lines = []
+    end
+    out_lines
+  end
+
+  # Creates a file handle to output into the out directory with given name
+  # Returns the comparison with any previous ok file if exists.
+  #
+  # Parameters:
+  #   file_name: Appends '_<count>' to the this name if the file already exists.
+  #   content: String to output, must supply only if a block is not given.
+  #   no_raise: If set to true, just return comparison, don't raise exception
+  #  Examples:
+  # Oats.out_file('my_file.txt', "Check this string" }
+  # Oats.out_file('my_file.txt') { |f| f.puts "Check this string" }
+  def Oats.out_file(file_name, content = nil, no_raise = nil)
+    out_path = Util.file_unique(file_name, Oats.test.result)
+    File.open(out_path, 'w+') do |f|
+      if block_given?
+        yield f
+      else
+        f.puts content
+      end
+    end
+    Oats.assert(File.exist?(out_path), "Can not find file #{out_path}")  # Verify did create the file
+    File.basename(out_path)
+    #    file_ok = File.join Oats.test.ok_out, basename
+    #    is_ok = true
+    #    if File.exist?(file_ok)
+    #      is_ok  = FileUtils.compare_file(out_path, file_ok)
+    #      Oats.assert is_ok || no_raise, "Found differences in file: #{file_ok}"
+    #      Oats.info "Matched ok contents [#{content||basename}"
+    #    end
+    #    return is_ok
+  end
+
+
+  # Runs the input_suite_path from a particular Oats.test. Assumes Oats.data is
+  # initialized for Oats.test
+  #
+  # Parameters:
+  # input_suite_path:: path to the IDE suite HTML
+  # hash:: list from => to values to use for regeneration of the included test
+  # cases.
+  #
+  # Examples:
+  #  Oats.ide.run('../campaign/rtest.html', 'this_token" => 'that_value')
+  def Oats.ide(input_suite_path, hash = nil )
+    $ide.run(input_suite_path, hash )
+  end
+
+  # Obsolete. Create classes and use class variables to carry over global info.
+  def Oats.global
+    $oats_global
+  end
+
+  # Output info level log entries.
+  def Oats.info(arg)
+    #    return if arg.nil?
+    arg = arg.inspect unless arg.instance_of?(String)
+    $log.info(arg)
+  end
+
+
+
+  # Execute MySQL files or statements, return result set in an array of rows.
+  # Empty result set results in an empty array. First row [0] of the result
+  # contains the column headers. If each row has multiple fields, the row is
+  # returned in an array of strings. Otherwise each row a string containing the
+  # single column value.
+  #
+  # Parameters:
+  #  sql_input:: String denoting a file or SQL content (assumed if s has a space)
+  #  connect::   Override for Oats.data sql:connect
+  #  sql_out_name:: File name to place the SQL output into the test.out directory.
+
+  # Examples
+  #  Oats.mysql('input.sql')  => produces input.txt and returns its contents
+  #  Oats.mysql('input.sql', 'output.txt)  => produces output.txt and returns its contents
+  #  mysql_results = Oats.mysql "SELECT bu_lastname, FROM BusinessUser where bu_email='levent.atasoy@oats.org;XYZ'"
+  #  result = Oats.mysql(my_sql_statement)
+  #  result.is_empty? # true if SQL returns nothing
+  #  result.last # string value for the last row of a single select statement
+  #  result[1][2] # second column for the first return result row
+
+  def Oats.mysql(*sql_input)
+    require 'oats/mysql' unless defined?(Oats::Mysql) == 'constant'
+    $mysql ||= Oats::Mysql.new
+    $mysql.run(*sql_input)
+  end
+
+  #  Executes a script on an server via ssh using PuTTy/plink
+  #  Assumes pageant with keys for the username is up and running.
+  #  Returns the result of the standard output and standard error.
+  #
+  # Parameters:
+  # cmd_file:: Path of the executable relative to dir
+  # dir:: Directory to cd prior to executing cmd_file. Home of user if omitted.
+  # host/session: Name for putty on which to execute cmd_file. Defaults via Oats.data
+  # username:: Putty connection data Login username. Defaults via Oats.data.
+  #       If username is 'root', executes the cmd_file as sudo root with
+  #       Oats.data[ssh.root_sudo_username].
+  #       root_sudo_username must be able to
+  #        - access host via Plink/Pageant
+  #        - sudo -s on the host
+  #        - cd to dir without being root.
+  #
+  # Examples
+  #  out = Oats.rssh('/home/transfer.pl')
+  #  Oats.rssh('./transfer.pl', /home')
+  #  Oats.rssh('cat that.log','/var/www/app')
+  #  Oats.rssh('ls httpd', '/var/log', nil, 'root')
+  def Oats.rssh(cmd_file, dir = nil , host = nil, username = nil)
+    Ossh.run(cmd_file, dir, host, username )
+  end
+
+  #  Copies a file to the server via ssh using PuTTy/plink
+  #  Assumes pageant with keys for the username is up and running.
+  #  Returns the result of the standard output and standard error, which is
+  #  typically empty.
+  #
+  # Parameters:
+  # content_file:: Path of the content file, or the content string if file
+  #       does not exist.
+  # target_file_path:: Path of the file on the server
+  # host/session: Same parameter as in Oats.rssh
+  # username:: Same parameter as in Oats.rssh
+  #
+  # Examples
+  #  Oats.rput 'xxx     xxxxxxx', '/tmp/myfile.txt' , 'qapp001.dyn.wh.oats.org'
+  #  Oats.rput 'c:/qa/oats-user.yml', '/tmp/myfile.txt' , 'qapp001.dyn.wh.oats.org'
+  def Oats.rput(content_file, target_file_path = nil, host = nil, username = nil)
+    Ossh.run(content_file, target_file_path, host, username, true)
+  end
+
+  # Returns the current TestData object. You can use the public instance methods
+  # of TestCase to access to test path components or other test information.
+  def Oats.test
+    TestData.current_test
+  end
+
+  # Samples the given block each second until it returns true or times out.
+  # Raises OatsTestError if times out or returns last value of block.
+  #
+  # Parameters (also allowed as Hash):
+  #  :message  Exception message to issue upon timeout.
+  #            Appended with 'in N seconds' unless seconds is negative.
+  #  :seconds  For timeout, defaults from Oats.data selenium.command_timeout
+  #  :is_return Returns false if times out instead of raising OatsTestError.
+  #        If :message is nil, :is_return defaults to true
+  #  :interval  Seconds to wait in betweeen calls to block
+  #
+  # Example:
+  #  wait_str = 'loadingIcon'
+  #  Oats.wait_until("Page did not have [#{wait_str}]") {
+  #    $selenium.get_html_source.include?(wait_str)
+  #  }
+  def Oats.wait_until(*args)
+    raise(OatsTestError, 'Oats.wait_until requires an input block.') unless block_given?
+    if args[0].kind_of?(Hash)
+      options = args[0]
+      message = options[:message]
+      seconds = options[:seconds]
+      is_return = options[:is_return]
+      interval = options[:interval]
+    else
+      message, seconds, is_return, interval = *args
+    end
+    interval ||= 1
+    seconds ||= Oats.data['execution']['wait_until_timeout']
+    is_return = true if message.nil?
+    if seconds < 0
+      seconds = seconds.abs
+      message += " in #{seconds} seconds"
+    end
+    begin
+      return_val = false
+      Timeout::timeout seconds do
+        loop do
+          return_val = yield
+          break if return_val
+          sleep interval
+        end
+        return return_val
+      end
+    rescue Timeout::Error
+      if is_return
+        Oats.warn message if message
+        return false
+      else
+        raise(OatsTestError, message) if message
+        raise OatsTestError
+      end
+    end
+  end
+
+  # Returns a unique string for each machine for each call.
+  # The string will start with the input prefix if supplied.
+  # If the input prefix matches the pattern of unique output, then only the
+  # unique suffix is modified.
+  #
+  # Parameters:
+  # prefix:: Prefix string to use.
+  #
+  # Examples:
+  #  Oats.unique          => "mach_83580508"
+  #  Oats.unique('this')  => "this-835805081"
+  #  Oats.unique(Oats.unique('this'))  => "this-835805082"
+  def Oats.unique(prefix = nil)
+    agent = $oats_execution['agent'] ? $oats_execution['agent']['execution:occ:agent_nickname'] : nil
+    prefix = ENV['HOSTNAME'].sub(/\..*/,'').downcase unless prefix or agent
+    postfix =  (agent ? agent + '_' : '') + Time.now.to_i.to_s[-8..-1]
+    if Oats.global['unique']
+      extra = Oats.global['unique'].sub(/#{postfix}/,'')
+      unless extra == Oats.global['unique']
+        if extra == ''
+          postfix = "#{postfix}1"
+        else
+          postfix = postfix + ((extra.to_i) + 1).to_s
+        end
+      end
+    end
+    Oats.global['unique'] = postfix
+    if prefix
+      separator =  '-'
+    else
+      prefix =  ''
+      separator =  ''
+    end
+    postfix_pattern = separator + (agent ? agent + '_' : '') + '\d\d\d\d\d\d\d\d\d*'
+    return prefix.sub(/#{postfix_pattern}$/, '') + separator + "#{postfix}"
+  end
+
+  # Output warning level log entries.
+  def Oats.warn(arg)
+    $log.warn(arg)
+  end
+
+end
+