oats 0.0.1

data/lib/oats/ide.rb

@@ -0,0 +1,227 @@
+# IDE Class to run an IDE based HTML suite after transforming it based on oats_data
+
+module Oats
+
+  # Runs an IDE based HTML suite after transforming it based on current Oats data
+  class Ide
+    def initialize()
+      super
+      @suite_base_url_signin_type = nil;
+      @first_test_url = nil;
+    end
+
+    # Run input_suite_path while in a TestData.dir . Assumes Oats.data is initialized for TestData.dir
+    # input_suite_path:: path to the suite HTML
+    # hash:: list from => to values to use for regeneration of the included test cases.
+    def run (input_suite_path, hash = nil )
+      begin
+        run_ide(input_suite_path, hash)
+      ensure
+        TestData.current_test.collect_downloaded_output
+      end
+    end
+
+    private
+
+    def run_ide (input_suite_path, hash = nil )
+      suite_path = get_path(input_suite_path)
+      name = File.basename(suite_path)
+      doc = open(suite_path ) { |f| Hpricot(f) }
+      #    FileUtils.rm Dir[File.join(TestData.current_test.dir,'*.gen.*')] # Clean previously generated files
+      FileUtils.rm Dir['*.gen.*'] # Clean previously generated files in pwd
+      if doc.search("head[@profile='http://selenium-ide.openqa.org/profiles/test-case']").empty?
+        regen_suite = nil
+        doc.search('a[@href]') do |a|
+          if Oats.data['execution']['run_in_dir_results']
+            generated_test = regenerate_html(a['href'], test.result, File.dirname(suite_path), hash)
+          else
+            generated_test = regenerate_html(a['href'], test.dir, File.dirname(suite_path), hash)
+          end
+          if generated_test
+            regen_suite = true
+            a.set_attribute(:href,generated_test)
+          end
+        end
+        html_suite_path =  File.join(test.dir , File.basename(suite_path,'.*') + '.gen.html')
+        regen_suite = true if regen_suite or html_suite_path != suite_path
+        html_suite_path =  File.join(test.result , File.basename(suite_path,'.*') + '.gen.html') if Oats.data['execution']['run_in_dir_results']
+        $log.info "Creating: #{html_suite_path}"
+        File.open( html_suite_path, 'w' ) { |out| out.print doc } if regen_suite
+      else # A single test HTML, not the suite
+        raise OatsTestError, "Input file is not an IDE suite: " + html_suite_path
+      end
+
+      # Execute html_suite_path
+      result_file = File.join(test.result, File.basename(name, '.*') + '_results.html')
+      if Oats.data['selenium']['ide']['generate']
+        $log.warn "Option execution:ide:generate is set. Test will not be executed."
+        $log.debug "Target result_file was: #{result_file}"
+        return
+      end
+      rc_jar_file = File.join(Oats.data['_']['vendor'],'selenium-server.jar')
+      browser = '*' + Oats.data['selenium']['browser_type'].sub(/ .*/,'')
+      url = nil
+      if @suite_base_url_signin_type
+        url = Oats.data[@suite_base_url_signin_type]["SignIn"]["url"]
+      else
+        if @first_test_url
+          url = @first_test_url
+        else
+          raise(OatsError, "None of the tests in #{suite_path} specified a base URL.")
+        end
+      end
+      if url
+        base_url = url.match('https?://[^/]*/?')
+      else
+        base_url = nil
+      end
+      port = Oats.data['selenium']['ide']['port']
+      if Oats.data['env']['web']['host']
+        base_url = 'http://' + Oats.data['env']['web']['host']
+      else
+        base_url = base_url[0]
+      end
+      #    if base_url
+      #      base_url = base_url[0]
+      #    else
+      #      base_url = 'http://' + Oats.data['env']['web']['host']
+      #      $log.warn "Can not determine the base url from [#{url}]. Assuming base url is [#{base_url}]" \
+      #        unless @suite_base_url_signin_type and Oats.data[@suite_base_url_signin_type]["SignIn"]
+      #    end
+      command = "java -jar \"#{rc_jar_file}\" -port #{port}"
+      command +=  " -timeout #{Oats.data['selenium']['ide']['suite_timeout']}" if Oats.data['selenium']['ide']['suite_timeout']
+      # Don't use profiles when using RC in IDE mode
+      command += " -firefoxprofileTemplate \"#{$oats_global['firefox_profile_dir']}\"" \
+        if Oats.data['selenium']['browser_type'] =~ /firefox/ and $oats_global['firefox_profile_dir']
+      command += " -htmlSuite #{browser} #{base_url} \"#{html_suite_path}\" \"#{result_file}\" 2>&1"
+      $log.info "Starting Selenium Remote Control: #{command}"
+      #    return  # DEBUG
+      first_rc_try = true
+      failure_line = nil
+      catch :end_rc do
+        2.times do
+          IO.popen(command) do |io|
+            while io.gets do
+              $log.info chomp
+              if /Selenium is already running on port/ =~ $_
+                if first_rc_try
+                  io.readlines.each {|line|$log.info line.chomp }
+                  Util.clear_port(Oats.data['selenium']['ide']['port'],$log)
+                  $log.info "Will attempt to restart Selenium RC..."
+                else
+                  #                raise(OatsError, $_, caller[1..3])
+                  raise(OatsError, $_)
+                  throw(:end_rc)
+                end
+                first_rc_try = false
+              elsif /fail/i =~ $_ and /Failed to start: SocketListener/ !~ $_
+                failure_line = $_
+                throw(:end_rc)
+              elsif /exception/i =~ $_ # Like server.SeleniumCommandTimedOutException
+                failure_line = $_
+              end
+            end
+          end
+          throw(:end_rc) if first_rc_try
+        end
+      end
+      #    pause_val = Oats.data['execution']['ide']['pause_on_exit']
+      seconds = 999999
+      pause_val = $oats['selenium']['pause_on_exit']
+      if not pause_val.integer? or
+          pause_val <= 0
+        seconds = nil
+      elsif pause_val == 1
+        seconds = nil unless failure_line
+      elsif pause_val > 0
+        seconds = pause_val
+      end
+      raise(OatsError, "Result file is not readable: #{result_file}") unless File.readable?(result_file)
+      if seconds
+        # Need to quote browser path for cygwin because it may have spaces.
+        begin
+          timeout(seconds) do
+            #  $stderr.puts "Paused because selenium:pause_on_exit is set to [#{pause_val}]"
+            #  $stderr.puts "PLEASE HIT <ENTER> TO CONTINUE!"
+            successful = system( '"' +Oats.data['selenium']['ide']['result_browser'] + '" file://'+result_file)
+            $log.error "Error trying to open results file: #{$?}" \
+              unless successful or $? == 256
+          end
+        rescue Timeout::Error
+        end
+      end
+      TestData.pause_after_error = false
+      $log.info "Results are at: file://#{result_file}"
+      raise(OatsTestError, failure_line) if failure_line
+    end
+
+    # Helper method to replace HTML file contents based on oats and test data mappings.
+    def map_file_contents(oats_data, test_data, file_contents,key_path)
+      return unless test_data
+      #    $log.debug key_path
+      if @suite_base_url_signin_type.nil?
+        @suite_base_url_signin_type = 'Campaign' if key_path == 'root:Campaign:SignIn'
+        @suite_base_url_signin_type = 'Admin' if key_path == 'root:Admin:SignIn'
+        #      $log.debug "Base URL is set to #{baseUrl}"
+      end
+      test_data.each do |key,val|
+        repVal = oats_data[key]
+        next if val.nil? or repVal.nil?
+        if val.class == Hash
+          map_file_contents( repVal, val, file_contents,key_path + ':' + key)
+        else
+          file_contents.gsub!(val, repVal.to_s)
+          test_data[key] = repVal
+        end
+      end
+    end
+
+    # Updates HTML file contents based on current oats_data into test_dir_out
+    # Returns generated file name or nil if no new file is generated
+    def regenerate_html(file_in, dir_out, dir_in = dir_out, hash = nil)
+      basename = File.basename(file_in,'.*')
+      file_in_absolute = File.expand_path(file_in,dir_in) # get absolute path
+      unless File.exist?(file_in_absolute)
+        file_in_absolute = Dir.glob( File.join( $oats['execution']['dir_tests'],
+            '/**/', file_in.sub(/^(\.\.\/)*/, ''))).first
+        #        file_in = file_in.sub!(/[^\/]*\//,'')
+        raise(OatsError,"Can not locate IDE test case file: [#{file_in}]") unless file_in_absolute
+      end
+      file_in_root = file_in_absolute.sub(/(.*)\..*$/,'\1')
+      yaml_in = file_in_root + '.yml'
+      file_out_root = File.join(dir_out, basename)
+      file_gen = file_out_root +'.gen.html'
+      yml_out = file_out_root +'.gen.yml'
+      new_base_name = basename
+      if File.exist?(file_gen)
+        new_base_name = File.basename(File.dirname(file_in)) + '_' + new_base_name
+        file_gen = File.join(dir_out, new_base_name ) +'.gen.html'
+        yml_out =  File.join(dir_out, new_base_name ) +'.gen.yml'
+      end
+      if @suite_base_url_signin_type.nil? and @first_test_url.nil?
+        doc = open(file_in_absolute) { |f| Hpricot(f) }
+        link = doc.at("link[@rel='selenium.base']")
+        @first_test_url = link['href'] unless link.nil?
+      end
+      unless File.exist?(yaml_in)
+        return nil if file_in_root == file_out_root
+        $log.info "Copying [#{file_in_absolute}] to: #{file_gen}]"
+        FileUtils.cp(file_in_absolute, file_gen)
+        return basename + '.gen.html'
+      end
+      $log.debug "Regenerating [#{file_in_absolute}] into [#{file_gen}] based on [#{yaml_in}]"
+      file_contents = IO.read(file_in_absolute)
+      test_data = YAML.load_file(yaml_in)
+      map_file_contents(Oats.data, test_data, file_contents, 'root')
+      hash.each { |val, rep_val| file_contents.gsub!(val, rep_val) } if hash
+      if Oats.data['selenium']['browser_type'] =~ /iexplore/
+        file_contents.sub!(/(<\/IE-ONLY>.*-->)/,'<-- \1')
+        file_contents.sub!(/(<!--.*<IE-ONLY>)/,'\1 -->')
+      end
+      File.open( file_gen, 'w' ) { |out| out.print file_contents }
+      File.open( yml_out, 'w' ) { |out| YAML.dump( test_data, out ) }
+      basename + '.gen.html'
+    end
+
+  end
+end

data/lib/oats/keywords.rb

@@ -0,0 +1,67 @@
+
+module Oats
+
+  # Process keyword driven testing
+  class Keywords
+    class << self
+
+      # Same as selenium.wait_and_type, but maps key via OatsX.locator, and uses
+      # OatsX.data[key] for value
+      def wait_and_type(key, *args)
+        selenium.wait_and_type(locator(key), oats_data[key], *args)
+      end
+
+      # Same as selenium.wait_for_element, but maps key via OatsX.locator first
+      def wait_and_click(key)
+        selenium.wait_and_click(locator(key))
+      end
+
+      # Same as selenium.wait_for_element, maps key via OatsX.locator first
+      def wait_and_text(key)
+        selenium.wait_for_element(locator(key)).text
+      end
+
+      # Returned the key or mappings if defined in the <class>::LOCATOR_MAP
+      def locator(key)
+        self::LOCATOR_MAP[key] || key
+      end
+
+
+      # Return data from XL spreadsheet entries via Oats.data('xl.data')
+      # OatsX.oats_data(key_string) or OatsX.oats_data[key_string]
+      def oats_data(cell = nil, clas = self)
+        xl_root = $oats[clas.name]
+        list = xl_root['list'] || Oats.data('keywords.list')
+        if list
+          xl_root_list = xl_root[list]
+        else
+          xl_root_list =  xl_root
+        end
+        #        Oats.assert list, "Oats.data keywords.list is not defined."
+        val = cell ? xl_root_list[cell] : xl_root_list
+        Oats.assert( val, "No keywords are defined for #{clas}" + (list ? ".#{list}" : '') ) if cell == 'keywords'
+        Marshal.load(Marshal.dump(val)) # Protect Oats.data from modification
+      end
+
+      # Handles keyword processing.
+      # Used by OATS framework to run XL driven test suites.
+      # Users can also call this from yaml_handlers.
+      def process
+        # Class name comes from Oats.data oats_keywords_cleass, or in the case of XL files from TestCase ID
+        class_name = Oats.data('keywords.class') || File.basename(File.dirname(File.dirname(Oats.test.id)))
+        begin
+          keywords_class = Kernel.const_get class_name
+        rescue NameError
+          raise OatsTestError, "Can not find class: " + class_name
+        end
+        oats_data('keywords',keywords_class).each do |action|
+          Oats.assert keywords_class.respond_to?(action),
+            "There is no method defined in #{class_name} to the handle keyword 'a#{action}'."
+          Oats.info "Performing " + action
+          keywords_class.send action
+        end
+      end
+
+    end
+  end
+end

data/lib/oats/log4r_init.rb

@@ -0,0 +1,14 @@
+# Log4r can be configured using YAML. This example uses log4r_yaml.yaml
+require 'log4r'
+require 'log4r/yamlconfigurator'
+# we use various outputters, so require them, otherwise config chokes
+require 'log4r/outputter/datefileoutputter'
+require 'log4r/outputter/emailoutputter'
+include Log4r
+
+cfg = YamlConfigurator # shorthand
+cfg['HOME'] = ENV['HOME']     # the only parameter in the YAML, our HOME directory
+
+# load the YAML file with this
+cfg.load_yaml_file('log4r.yaml')
+

data/lib/oats/mysql.rb

@@ -0,0 +1,97 @@
+#require 'mysql' # http://www.tmtm.org/en/ruby/mysql
+require "tempfile"
+require 'oats/oats_exceptions'
+
+module Oats
+  class OatsMysqlError < OatsTestError ; end
+  class OatsMysqlMissingInput < OatsMysqlError ; end
+  class OatsMysqlNoConnect < OatsMysqlError ; end
+  # Oats.mysql creates an instance of this class to interact with MySQL DBs
+  class Mysql
+
+    # See Oats.mysql for more accurate/detailed documentation
+    # sql_input:: Path to a file.sql to execute
+    # connect:: Override for Oats.data sql:connect
+    # returns array of rows of results. Each row is an array of columns.
+    def run(sql_input, connect = nil, sql_out_name = nil)
+      raise OatsMysqlNoConnect, "Oats.data sql:connect is null" unless Oats.data['sql']['connect']
+      test = TestData.current_test
+      unless /\s/ =~ sql_input # If there is space in name, assume it is not a file
+        abs_path = File.expand_path(sql_input,test.path)
+      end
+      if File.exist?(abs_path)
+        mysql_input_file = OatsData.regenerate_file(abs_path)
+        mysql_input_file = abs_path unless mysql_input_file
+        name = File.basename(sql_input,'.*')
+        sql_input = IO.read(mysql_input_file)
+        sql_input = nil if sql_input.length > 200
+      else
+        tf = Tempfile.new("OatsMysqlInput")
+        tf.puts(sql_input)
+        tf.close
+        mysql_input_file = Util.expand_path(tf.path)
+        name = 'mysql_default'
+      end
+      sql_out_name = name + '.txt' unless sql_out_name
+      sql_out = File.join(test.result, sql_out_name) if sql_out_name
+      err_file = sql_out + '.err'
+      command = (ENV['OS'] != 'Darwin' ? 'mysql' : '/usr/local/mysql/bin/mysql') +
+        " #{parameters(connect)} < #{mysql_input_file} > #{sql_out} 2> #{err_file}"
+      #    $log.debug "Executing: #{command}"
+      $log.info "SQL: #{sql_input}" if sql_input
+      FileUtils.mkdir_p(test.out)
+      ok = system(command)
+      $log.error("MySQL failed with return code: #{$?}") unless ok
+      FileUtils.rm_f(err_file) unless File.size?(err_file)
+      FileUtils.rm_f(sql_out) unless File.size?(sql_out)
+      if File.exist?(err_file)
+        errors = IO.readlines(err_file)
+        errors.size == 1 or errors[0...-1].each {|line| $log.error line.chomp}
+        raise(OatsMysqlError,errors.last.chomp) unless errors.empty?
+      end
+      rows = IO.readlines(sql_out) if File.exist?(sql_out)
+      return [] unless rows
+      rows.shift
+      if rows[1] =~ /\t/
+        return rows.collect{|t| t.chomp.split(/\t/) }
+      else
+        return rows.collect{|t| t.chomp }
+      end
+    end
+
+
+    def processlist
+      raise OatsMysqlNoConnect, "Oats.data sql:connect is null" unless Oats.data['sql']['connect']
+      sql_out = 'mysql_processlist.txt'
+      command = "mysqladmin #{parameters('connect',true)} processlist > #{sql_out}"
+      success = system(command)
+      $log.error("MySQL failed with return code: #{$?}") unless success
+      FileUtils.rm_f(sql_out) unless File.size?(sql_out)
+    end
+
+    private
+
+    def parameters(connect,proc_list=false)
+      sql = Oats.data['sql']
+      connect ||= sql['connect']
+      conn = sql[connect]
+      user = conn['user']
+      err "Oats MySQL requires input for sql:user" unless user
+      password = conn['password']
+      err "Oats MySQL requires a string input for sql:password" unless password
+      password = " -p#{password}" unless password == ""
+      host = conn['host']
+      err "Oats MySQL requires input for sql:host" unless host
+      params = "-u#{user}#{password} -h#{host}"
+      return params if proc_list
+      db = conn['database']
+      err "Oats MySQL requires input for sql:db" unless db
+      "#{params} -D#{db}"
+    end
+
+    def err(inp)
+      raise(OatsMysqlMissingInput,inp)
+    end
+
+  end
+end