oats 0.0.1

data/lib/oats/test_list.rb

@@ -0,0 +1,141 @@
+module Oats
+
+  # TestList has array of variations
+  class TestList
+    # Path of test relative to the dir_tests library
+    attr_reader :id
+    # Absolute path to the test.yml
+    attr_reader :path
+    # Array of Variation structures
+    attr_accessor :variations
+    # Parent variation, start and end times
+    attr_accessor :parent_variation, :start_time, :end_time, :pre_test, :post_test
+    @@current = nil
+    # Currently active test list
+    def TestList.current
+      @@current
+    end
+    def TestList.current=(list)
+      @@current = list
+    end
+
+    def TestList.txt_tests(pth)
+      list = IO.readlines(pth)
+      list = list.collect{|x| f=x.chomp.sub(/#.*/,'').strip}
+      return list.delete_if { |x| x == '' }
+    end
+
+    def add_variation(var)
+      lv = self.variations.last
+      lv.end_time = Time.now.to_i if lv and ! lv.end_time
+      if variations.empty? or variations.last.name != 'default'
+        variations << Variation.new(var,self)
+      else
+        variations.last.name = var
+        variations.last.start_time = Time.now.to_i
+      end
+    end
+
+    def testlist_hash
+      variation = nil
+      top_level_variations = self.variations[0]
+      unless top_level_variations.nil? or top_level_variations.tests.nil?
+        cur_test_list = top_level_variations.tests[0]
+        if cur_test_list
+          if cur_test_list.instance_of?(TestCase)
+            variation = top_level_variations
+          else
+            variation = cur_test_list.variations[0]
+          end
+          # Oats seems to set the end_time of variations incorrectly as equal to
+          # start time until very end. Compensate for it by borrowing the time from the TestList
+          variation.end_time = cur_test_list.end_time
+        end
+      end
+      return nil unless variation
+      return variation.variation_hash(pre_test, post_test)
+    end
+
+    def initialize(id, path)
+      @id = id
+      @path = path
+      @start_time = Time.now.to_i
+      @variations = []
+      add_variation('default')
+      $log.info "**** TEST LIST [#{@id}]" if id
+      #      raise OatsError, "Encountered recursive inclusion of test lists: [#{tree_id}]"
+      if @@current # Make this list a child of current list
+        @parent_variation = @@current.variations.last
+        @parent_variation.tests << self
+      else # record the root
+        $oats_info['test_files'] = self
+      end
+      @@current = self  # Repoint the current list
+    end
+  end
+
+  # TestList has an array of these
+  class  Variation
+    attr_reader :tests
+    attr_accessor :start_time, :env_name, :name, :list_name, :end_time,  :total, :pass, :fail, :skip, :parent
+    def initialize(var,list)
+      @parent = list
+      @name = var
+      @tests = []
+      @start_time = Time.now.to_i
+    end
+
+
+    def variation_hash(pre_test, post_test)
+      err_msg = nil
+      testlist = self
+      $log ||= Rails.logger
+      testlist.tests.each_with_index do |tst,idx|
+        unless tst.instance_of?(TestCase)
+          msg = "Expected a test case in #{testlist.list_name} but got:"
+          $log.error "#{msg} #{tst.inspect}"
+          msg = "... in job:"
+          $log.error "#{msg} #{self.inspect}"
+          msg = "Deleting the TestList #{tst.id}"
+          err_msg = "Deleted unexpected sub-TestList: #{tst.id}"
+          $log.error msg
+          testlist.tests.delete(tst)
+          next
+        end
+      end
+      testlist.parent = nil
+
+      thash = {
+        'fail' => testlist.fail,
+        'pass' => testlist.pass,
+        'skip' => testlist.skip,
+        'total' => testlist.total,
+        'start_time' => testlist.start_time,
+        'end_time' => testlist.end_time,
+        'tests' => []
+      }
+      if pre_test and ! pre_test.errors.empty?
+        thash['tests'].push(pre_test)
+        thash['fail'] = thash['fail'] ? (thash['fail'] +1) : 1
+      end
+      if post_test and ! post_test.errors.empty?
+        thash['tests'].push(post_test)
+        thash['fail'] = thash['fail'] ? (thash['fail'] +1) : 1
+      end
+      thash['results_error'] = err_msg if err_msg
+      testlist.tests.each do |t|
+        tc = { 'id' => t.id,
+          'status' => t.status,
+          'error_capture_file' => t.error_capture_file,
+          'result' => t.result,
+          'timed_out' => t.timed_out?,
+          'start_time' => t.start_time,
+          'end_time' => t.end_time      }
+        tc['errors'] = t.errors if t.errors
+        thash['tests'].push tc
+      end
+      return thash
+    end
+
+  end
+end

data/lib/oats/unixdiff.rb

@@ -0,0 +1,75 @@
+#!/usr/bin/env ruby
+$:.push = File.dirname(__FILE__)
+require 'diff'
+
+
+def loadfile(filename)
+  lines = nil
+  File.open(filename, "r") { |f|
+    lines = f.readlines
+  }
+  return lines
+end
+
+def diffrange(a, b)
+  if (a == b)
+    "#{a}"
+  else
+    "#{a},#{b}"
+  end
+end
+
+class Diff
+  def to_diff(io = $defout)
+    offset = 0
+    @diffs.each { |b|
+      first = b[0][1]
+      length = b.length
+      action = b[0][0]
+      addcount = 0
+      remcount = 0
+      b.each { |l|
+        if l[0] == "+"
+          addcount += 1
+        elsif l[0] == "-"
+          remcount += 1
+        end
+      }
+      if addcount == 0
+        puts "#{diffrange(first+1, first+remcount)}d#{first+offset}"
+      elsif remcount == 0
+        puts "#{first-offset}a#{diffrange(first+1, first+addcount)}"
+      else
+        puts "#{diffrange(first+1, first+remcount)}c#{diffrange(first+offset+1, first+offset+addcount)}"
+      end
+      lastdel = (b[0][0] == "-")
+      b.each { |l|
+        if l[0] == "-"
+          offset -= 1
+          print "< "
+        elsif l[0] == "+"
+          offset += 1
+	  if lastdel
+	    lastdel = false
+            puts "---"
+          end
+          print "> "
+        end
+	print l[2]
+      }
+    }
+  end
+end
+
+if $0 == __FILE__
+
+  file1 = ARGV.shift
+  file2 = ARGV.shift
+
+  ary1 = loadfile file1
+  ary2 = loadfile file2
+
+  diff = Diff.new(ary1, ary2)
+  diff.to_diff
+
+end

data/lib/oats/util.rb

@@ -0,0 +1,125 @@
+autoload :Process, 'win32/process'
+
+module Oats
+  module Util
+
+    #  def Util.cygwin_fix_path(file,dir = nil)
+    #  end
+    def Util.expand_path(file,dir = nil)
+      file = File.expand_path(file, dir)
+      file.sub!('/',':/') if file.sub!('/cygdrive/','')
+      file
+    end
+
+    # Returns a unique path in dir using basename of file_name.
+    # file_name:: Appends '_count' to the the basename if the file already exists.
+    # dir:: if not given, uses the dirname of file_name. If file_name does not
+    #       have dirname, assumes dir = '.'  If dir does not exist, it is created.
+    def Util.file_unique(file_name, dir = nil)
+      new_path, existing_path = Util.file_examine(file_name, dir)
+      return new_path
+    end
+
+    # Returns the file path for the existing file with the highest _count in dir
+    # dir:: if not given, uses the dirname of file_name. If file_name does not
+    #       have dirname, assumes dir = '.'  If dir does not exist, it is created.
+    def Util.file_latest(file_name, dir = nil)
+      new_path, existing_path = Util.file_examine(file_name, dir)
+      return existing_path
+    end
+
+    # Returns a unique path in dir using basename of file_name for a new file
+    # and also return the file path for the existing file with the highest _count
+    # in dir.
+    # file_name:: Appends '_count' to the the basename if the file already exists.
+    # dir:: if not given, uses the dirname of file_name. If file_name does not
+    #       have dirname, assumes dir = '.'  If dir does not exist, it is created.
+    def Util.file_examine(file_name, dir = nil)
+      fname = File.basename(file_name)
+      dir ||= File.dirname(file_name)
+      dir = '.' unless dir
+      existing_path = nil
+      path = File.join dir, fname
+      if File.directory?(dir)
+        (1..100).each do |cnt|
+          break unless File.exist?(path)
+          existing_path = path
+          extn = File.extname(path)
+          if extn
+            base = path.sub(/#{extn}\z/,'')
+            base.sub!(/(_\d*)?\z/,"_#{cnt}")
+            path = base + extn
+          else
+            path = File.join dir, file_name + "_#{cnt}"
+          end
+        end
+      else
+        FileUtils.mkdir_p(dir)
+      end
+      existing_path = Util.expand_path(existing_path) unless existing_path.nil?
+      return Util.expand_path(path), existing_path
+    end
+
+    # Kill process occupying a port
+    def Util.clear_port(port,log)
+      matching_busy_port_line = IO.popen('netstat -a -o').readlines.grep(Regexp.new(port.to_s)).first
+      return unless matching_busy_port_line and matching_busy_port_line =~ /LISTENING/
+      pid = matching_busy_port_line.chomp!.sub(/.*LISTENING *(\d+).*/,'\1')
+      log.warn "Likely busy port: [#{matching_busy_port_line}]"
+      # Cygwin specific code
+      #    pid_line = IO.popen("pslist #{pid}").readlines.grep(Regexp.new('java.*'+pid.to_s)).first
+      #    log.warn pid_line
+      #    begin
+      log.warn "Will attempt to kill the PID #{pid}"
+      signal = 'KILL'
+      killed = Process.kill(signal,pid.to_i)
+      if killed.empty?
+        log.warn "Failed to kill the process"
+        return false
+      else
+        log.warn "Successfully killed the process."
+        return true
+      end
+    end
+
+    # Kill process using a handle
+    # Util.clear_handle('oats_in_progress.lock','java','ruby') willl kill
+    def Util.clear_handle(hstring,*proc_names)
+      pid = nil
+      proc_name = nil
+      handle_string = nil
+      line = nil
+      matches = IO.popen("handle #{hstring}").readlines
+      matches.each do |lvar|
+        line = lvar
+        line =~ /(.*) pid:(.*) .*: (.*)/
+        next unless $1
+        proc_name = $1.strip
+        pid = $2.strip
+        handle_string = $3.strip
+        if handle_string =~ /#{hstring}/
+          proc_names.each do |name|
+            break if proc_name =~ /#{name}/
+          end
+        end
+      end
+      return unless pid
+      puts "Likely locking process: [#{line}]"
+      # Cygwin specific code
+      #    pid_line = IO.popen("pslist #{pid}").readlines.grep(Regexp.new('java.*'+pid.to_s)).first
+      #    log.warn pid_line
+      #    begin
+      puts "Will attempt to kill the PID #{pid}"
+      signal = 'KILL'
+      killed = Process.kill(signal,pid.to_i)
+      if killed.empty?
+        puts "Failed to kill the process"
+        return false
+      else
+        puts "Successfully killed the process."
+        return true
+      end
+    end
+
+  end
+end

data/lib/oats/version.rb

@@ -0,0 +1,3 @@
+module Oats
+  VERSION = "0.0.1"
+end

data/lib/oats.rb

@@ -0,0 +1,36 @@
+
+defined? Jruby && JRuby.objectspace = true # avoid error  http://rubyforge.org/pipermail/nokogiri-talk/2010-April/000355.html
+
+$oats_execution = {}  # Keeps variables that persists throughout a agents life, across testlists
+# Need to be before reading classes to allow the loaded classes register themselves here
+# In agent mode, this will contain 'options'.
+# Classes of OATS can check existence of this to determine whether called by OATS or OCC
+
+require 'pp'
+require 'oats/commandline_options'
+options = Oats::CommandlineOptions.options
+$oats_execution['options'] = options
+if options['execution:occ:agent_nickname'] || options['execution:occ:agent_port'] || options['_:command']
+  $oats_execution['agent'] = options  # Existence of this from now on implies running in agent mode
+end
+
+ENV['OATS_HOME'] ||= File.expand_path( '..', File.dirname(__FILE__) )
+ENV['OATS_TESTS'] ||= options['_:dir_tests'] || (ENV['OATS_HOME'] + '/oats_tests')
+
+$:.unshift(ENV['OATS_TESTS'] + '/lib')
+
+require 'oats/keywords'
+
+# GEMS needed by OATS.
+require 'rubygems'
+require "bundler/setup"
+#Bundler.require
+#gem 'log4r'
+#require 'deep_merge' # Need modified version of https://github.com/danielsdeleo/deep_merge for 1.9 compatibility
+require 'log4r'  # http://log4r.sourceforge.net/rdoc/index.html
+
+require 'oats/driver'
+require 'oats/oats_lock'
+
+#ENV['OATS_HOME'] ||= Oats::Util.expand_path( '..', File.dirname(__FILE__) )
+require 'oats/oats' #  Interface methods to user methods implemented in other modules

data/nbproject/project.properties

@@ -0,0 +1,10 @@
+file.reference.oats-lib=lib
+file.reference.oats-tests=tests
+javac.classpath=
+main.file=oats
+platform.active=Ruby
+source.encoding=UTF-8
+src.bin.dir=bin
+test.lib.dir=lib
+test.oats_tests.dir=oats_tests
+test.test.dir=test

data/nbproject/project.xml

@@ -0,0 +1,17 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<project xmlns="http://www.netbeans.org/ns/project/1">
+    <type>org.netbeans.modules.ruby.rubyproject</type>
+    <configuration>
+        <data xmlns="http://www.netbeans.org/ns/ruby-project/1">
+            <name>oats</name>
+            <source-roots>
+                <root id="src.bin.dir"/>
+            </source-roots>
+            <test-roots>
+                <root id="test.test.dir"/>
+                <root id="test.oats_tests.dir"/>
+                <root id="test.lib.dir"/>
+            </test-roots>
+        </data>
+    </configuration>
+</project>

data/oats.gemspec

@@ -0,0 +1,42 @@
+# -*- encoding: utf-8 -*-
+$:.push File.expand_path("../lib", __FILE__)
+require "oats/version"
+
+Gem::Specification.new do |s|
+  s.name        = "oats"
+  s.version     = Oats::VERSION
+  s.authors     = ["Levent Atasoy"]
+  s.email       = ["levent.atasoy@gmail.com"]
+  s.homepage    = ""
+  s.summary     = %q{A flexible automated system integration regression test framework.}
+  s.description = %q{A flexible automated system integration regression test framework.}
+
+  s.rubyforge_project = "oats"
+
+  s.files         = `git ls-files`.split("\n")
+  s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
+  #  s.test_files = ["test/test_cgi_wrapper.rb" ]
+  s.executables   = %w{oats}
+  s.require_paths = ["lib"]
+
+  #   s.extra_rdoc_files = ["CHANGELOG", "COPYING", "lib/mongrel/camping.rb", "LICENSE", "README"]
+  #  s.has_rdoc = true
+  #  s.homepage = %q{http://mongrel.rubyforge.org}
+  #  s.rdoc_options = ["--line-numbers", "--inline-source", "--title", "Mongrel", "--main", "README"
+  s.date = %q{2012-05-22}
+  s.required_ruby_version = Gem::Requirement.new(">= 1.8.7")
+
+  s.add_dependency 'log4r'
+  s.add_dependency 'net-http-persistent' unless RUBY_VERSION !~ /^1.9/ # Speed up 1.8 connections
+
+  if ENV['OS'] == 'Windows_NT' or ENV['OATS_AGENT'] # Triggers possible intent to use agent
+    s.add_dependency 'win32-process'
+  else
+    s.add_dependency 'json'
+    s.add_dependency 'em-http-request'
+    if ENV['OS'] == 'Linux' # Seems to be needed by Ubuntu
+      s.add_dependency 'execjs'
+      s.add_dependency 'therubyracer'
+    end
+  end
+end