qa_robusta 0.1.3

data/qa_observer/test_runner.rb

@@ -0,0 +1,125 @@
+base = File.expand_path(File.dirname(__FILE__))
+require "#{base}/../common/lib/gem_helpers"
+GemHelpers.update_gem_path "#{base}/../common/gems/installed"
+require 'platform_helpers'
+require 'getoptions'
+require 'hpricot'
+require "#{base}/lib/doc"
+
+def usage(msg=nil)
+  usage = <<-EOF
+      Usage: test_runner.rb --site=<site_name> 
+                            --file_name=<ruby test case file> 
+                            --execute_methods=all | list,of,methods,to,execute
+                            --browser=<ie|firefox>
+                            --environment=<name such as production|test|dev>
+                            --format=junit --> this is an optional and used for CI systems
+                        
+             where --site_name base directory name to a site defined under qa_observer/sites
+  
+    
+  EOF
+  puts usage
+end
+
+opt = GetOptions.new(%w(help site=s file_name=s execute_methods=s browser:s environment=s format:s proxy:s))
+
+supported_browsers = ['ie', 'firefox', 'chrome']
+
+unless opt.site && opt.execute_methods && opt.file_name &&
+       opt.environment
+  if opt.browser
+    supported_browsers.include?(opt.browser)
+    raise ArgumentError, usage
+  end
+  raise ArgumentError, usage
+else
+
+  if opt.proxy
+    tmp_split = opt.proxy.split(':')
+    if tmp_split.length != 2
+      raise ArgumentError, '--proxy option requires format host:port'
+    end
+    
+    PROXY = { :enabled => true,
+              :host => tmp_split[0], 
+              :port => tmp_split[1] }
+  else
+    PROXY = { :enabled => false,
+              :host => nil, 
+              :port => nil }
+    
+  end
+  
+  base = File.expand_path(File.dirname(__FILE__))
+  
+  $qa_observer_client = base
+  $run_on_browser = opt.browser
+  $environment = opt.environment.to_sym
+  $standalone = false
+  TEST_CASE_DIR = "#{base}/sites/#{opt.site}/test_cases"
+  
+  if opt.file_name
+    file = "#{TEST_CASE_DIR}/#{opt.file_name}"
+    raise ArgumentError, "Could not fine file: #{file} unless" unless File.exists?(file)
+  else
+    puts "FIXME: need to impl"
+  end
+end
+
+content = File.readlines(file).to_s
+
+method_names = TCDoc.method_names_from_file(content)
+
+if opt.execute_methods == 'all'
+  $job = {:methods => method_names}
+else
+  $job = {:methods => opt.execute_methods.split(',')}
+end
+
+if opt.format == 'junit'
+  $junit_format = true
+
+  reqs = <<-EOF
+    puts "Calling modified code"
+    puts "$qa_observer_client set from test_runner: \#{$qa_observer_client}"
+    base = File.expand_path(File.dirname(__FILE__))
+    
+    $qa_observer_client = '#{base}'
+    $junit_format = true      
+    $run_on_browser = '#{opt.browser}'
+    $environment = :#{opt.environment.to_sym}
+    $standalone = false
+    TEST_CASE_DIR = '#{base}/sites/#{opt.site}/test_cases'
+    PROXY = #{PROXY.inspect}
+    
+  EOF
+
+  content = File.read(file)
+  
+  # lets add reqs after base in orig_content
+  content.gsub!("base = File.expand_path(File.dirname(__FILE__))", reqs)
+
+  tmp_file = "#{file}_#{Time.now.tv_sec}"
+  
+  fd = File.open(tmp_file, 'w+')
+  fd.puts content.to_s
+  fd.close
+  results=`ruby #{tmp_file}`
+  
+  FileUtils.rm_f tmp_file
+
+else
+  load file
+end
+
+if $junit_format
+   
+  FileUtils.mkdir 'junit_results' unless File.directory?('junit_results')
+  
+  junit_xml = results.to_s.scan(/<JUNIT>(.*)<\/JUNIT>/m)
+  
+  fd = File.open("junit_results/#{$current_test_class}_#{$current_test_method}_#{Time.to_md5}.xml", 'w+')
+  fd.puts junit_xml
+  fd.close
+end

data/remote_unix/helpers/constants.rb

@@ -0,0 +1,8 @@
+module Constants
+  module NFS
+    EXPORT_FILE='/etc/exports'
+  end
+  module FileTransfer
+    NUM_RETRIES = 1
+  end
+end

data/remote_unix/helpers/out_xforms.rb

@@ -0,0 +1,48 @@
+module RemoteUnix
+  # outputer to parse output from echoed commands piped into script/console
+  class RailsConsoleOutput
+    attr_reader :unparsed
+    def initialize(out)
+      @unparsed = out
+    end
+    # given a generic output item from script/console such as:
+    # some prior items
+    # => [id1, id2, id3]
+    # transform the string to array
+    
+    # when we have STDOUT comming back from ssh session in format
+    # [1,2,3] translate the string to a ruby Array obj
+    def to_a
+      unless @unparsed.grep(/.*\[.*\]/).nitems > 0
+        raise ArgumentError, "Tried to convert output to_a when not in correct format"
+      end
+      @unparsed.to_s.split(/\n/).to_s.split('=>').last.gsub(/[\[\]" ]/, '').split('>>').first.split(',')
+    end
+    
+    def format
+      out = @unparsed.to_s.split(/\n/).to_s.split('=>').last.gsub(/[\[\] "]/, '').split('>>')
+
+      unless out.nitems > 0
+        return nil
+      end
+      # if we get here we found a result to return
+      out.first
+    end
+  end
+  
+  class GenericShellOutput
+    # return an array for the output executed excluding any other
+    # control information, such as command executed or shell prompt
+    def self.to_lines(out, command_executed)
+      lines = out.first[command_executed.length..out.first.length].split(/\n/)
+        
+      # empty array elem from stripping out command executed, deleting
+      lines.delete_at(0)
+      
+      # last item will be shell prompt, delete
+      lines.delete_at(lines.length-1)
+      lines
+    end
+  end
+  
+end

data/remote_unix/lib/common.rb

@@ -0,0 +1,52 @@
+module RemoteUnix
+  module Common
+    def set_platform
+      @platform = {}
+      nav_path = [
+                   {:execute => "uname -a",
+                    :expected_output => /linux/i, :timeout => 1}
+                 ]
+  
+      uname = @ssh.navigate(nav_path).last.grep(/linux/i).first
+      uname_split = uname.split(' ')[2].split(".").last
+  
+      # RHEL/CentOS
+      if uname_split =~ /el[0-5]/
+        @platform[:distro] = 'RH'
+        @platform[:prompt] = "]#"
+        @platform[:iscsi_packages] = ['iscsi-initiator-utils', 'sg3_utils.i386']
+        @platform[:install_iscsi_cmd] = "yum install -y"
+      # debian based
+      elsif uname =~ /ubuntu/i
+        @platform[:distro] = 'DEB'
+        @platform[:prompt] = "$"
+        @platform[:iscsi_packages] = ['open-iscsi', 'iscsitarget']
+        @platform[:install_iscsi_cmd] = "sudo apt-get install -y"
+        
+      # TODO: check for /etc/redhat-release
+      # can't detec for SL as custom kernel without RH in uname -a
+      else
+        @platform[:distro] = 'DEB'
+        @platform[:prompt] = "#"
+        @platform[:iscsi_packages] = ['open-iscsi', 'iscsitarget']
+        @platform[:install_iscsi_cmd] = "apt-get install -y"
+        
+        nav_path = [
+             {:execute => "if [ -f /etc/redhat-release ] ; then echo \"RH\"; else echo \"DEB\"; fi",
+              :timeout => 2}
+           ]
+  
+        version = @ssh.navigate(nav_path).last.grep(/linux/i).first
+ 
+        if version =~ /RH/
+          @platform[:distro] = 'RH'
+        elsif version =~ /DEB/
+          @platform[:distro] = 'DEB'
+        end
+      end
+      @expected_prompt = Regexp.escape(@platform[:prompt].to_s)
+    end
+  
+  end
+
+end

data/remote_unix/lib/error_defn.rb

@@ -0,0 +1,4 @@
+class RemoteUnixError < StandardError ; end
+class LockedUserError < StandardError ; end
+class FileNotFoundError < StandardError ; end
+class FileTransferError < StandardError ; end

data/remote_unix/lib/general_unix.rb

@@ -0,0 +1,308 @@
+module RemoteUnix
+  # commands which return information such as initiator name
+  class GeneralUnix
+    include Common
+    def initialize(params={})
+      @host = params[:host]
+      @user = params[:user]
+      @password = params[:password]
+      @ssh = SSH.new(@host, @user, @password)
+      set_platform
+    end
+    
+    def is_alive?(host)
+      ping_out = `ping -c 5 #{host}`
+      if ping_out =~ /100% packet loss/ 
+        return false
+      else
+        return true        
+      end
+    end
+ 
+    def wait_till_alive(host, to=15)
+      timeout(to) {
+        while !is_alive?(host)
+          sleep 0.3
+        end
+      }
+    end
+    
+    def wait_till_dead(host, to=15)
+      timeout(to) {
+        while is_alive?(host)
+          sleep 0.3
+        end
+      }
+    end
+    
+    # if we don't care about results and just want to exex a remote command
+    def exec(cmd)
+      nav_path = [{:execute => cmd, :timeout => 1}]
+      
+      begin
+        @ssh.navigate(nav_path)
+      rescue => e
+        puts "IGNORE: #{e}"
+      end
+
+    end
+    
+    def get_num_lines_in_file(file)
+      nav_path = [{:execute => "wc -l #{file}", :timeout => 1}]
+    
+      begin
+        return GenericShellOutput.to_lines(@ssh.navigate(nav_path), 
+                                          nav_path.first[:execute]).pp.split(' ').first.to_i        
+      rescue => e
+        puts "IGNORE: #{e}"
+      end
+      
+    end
+    
+    def ls(item)
+      nav_path = [{:execute => "ls #{item}", :timeout => 1}]                  
+      begin
+        content = RemoteUnix::GenericShellOutput.to_lines(@ssh.navigate(nav_path), nav_path.first[:execute])
+      rescue => e
+        puts "IGNORE: #{e}"
+      end
+      content
+    end
+   
+    # assumes standard /etc/init.d/* start|stop|restart
+    def service(params={})
+      valid_commands = ['start', 'stop', 'restart']
+      
+      unless params.has_key?(:name) && params.has_key?(:command)
+        raise ArgumentError
+      end
+      
+      raise ArgumentError unless valid_commands.include?(params[:command])
+      
+      nav_path = [{:execute => "/etc/init.d/#{params[:name]} #{params[:command]}", :timeout => 2}]
+      
+      begin
+        @ssh.navigate(nav_path)
+      rescue => e
+        puts "IGNORE: #{e}"
+      end
+      
+    end
+    
+    # :ip --> host where the NFS export resides
+    # :share
+    # :mount_point --> local mount point
+    def mount_nfs(params={})
+      
+      unless params.has_key?(:ip) && params.has_key?(:mount_point)
+        raise ArgumentError
+      end
+      
+      nav_path = [{:execute => "mount #{params[:ip]}:#{params[:share]} #{params[:mount_point]}", :timeout => 1}]
+      
+      begin
+        @ssh.navigate(nav_path)
+      rescue => e
+        puts "IGNORE: #{e}"
+      end
+      
+    end
+    
+    # return an array of content from remote file
+    def get_file_content(file)
+      unless file_exists?(file)
+        raise FileNotFoundError, "Could not find file #{file}"
+      end
+      
+      nav_path = [{:execute => "cat #{file}", :timeout => 1}]                  
+      begin
+        content = RemoteUnix::GenericShellOutput.to_lines(@ssh.navigate(nav_path), nav_path.first[:execute])
+      rescue => e
+        puts "IGNORE: #{e}"
+      end
+      content
+    end
+    
+    def put_file_content(file, content)
+      tmp=''
+      
+      # if content passed in by array, assumes each array elem is a line in a file
+      # and add \n
+      if content.kind_of?(Array)
+        content.each { |i| tmp += "#{i}\n" }
+      end
+      content = tmp
+      
+      tmp_file = "#{Time.now}"
+      fd = File.open(tmp_file, 'w+')
+      
+      fd.puts content
+      fd.close
+      
+      SCP::Upload.new(@host, @user, @password, tmp_file, file )
+      FileUtils.rm_f tmp_file
+      
+    end
+    
+    def flush_iptables
+      nav_path = [{:execute => "iptables -X", :timeout => 1},
+                  {:execute => "iptables -F", :timeout => 1}]
+      begin
+        @ssh.navigate(nav_path)
+      rescue => e
+        puts "IGNORE: #{e}"
+      end
+      
+    end
+
+    # params[:path] --> path to add to /etc/exports
+    # params[:allowed_host] --> string of host to allow access to the share (optional)
+    #                           not impl yet but will be added in future version as well
+    #                           as an additional param for options    
+    def add_nfs_export(params={})
+      raise ArgumentError unless params.has_key?(:path)
+      
+      begin
+        content = get_file_content(Constants::NFS::EXPORT_FILE)
+      rescue FileNotFoundError => e
+        content = []
+      end
+      
+      updated_content = []
+      ops = '*(rw,sync)'
+      
+      # if content already contains a share path lets delete old and add new
+      updated_content = delete_nfs_export(params[:path], content)
+      
+      # append out path to the updated content
+      updated_content << "#{params[:path]} #{ops}"
+      
+      # write content to exprts
+      put_file_content(Constants::NFS::EXPORT_FILE, updated_content)
+
+      service(:name => 'nfs', :command => 'restart')
+      sleep 0.75
+      
+      # reread exports so it's active
+      nav_path = [{:execute => "/usr/sbin/exportfs -ra", :timeout => 1}]
+                  
+      begin
+        @ssh.navigate(nav_path)
+      rescue => e
+        puts "IGNORE: #{e}"
+      end
+
+    end
+    
+    def delete_nfs_export(path, content=nil)
+      content = get_file_content(Constants::NFS::EXPORT_FILE) unless content 
+
+      # if the path exists delete, else no need to perform additional cycles
+      if content.pp =~ /#{path}/
+        updated_content = []
+        ops = '*(rw,sync)'
+        
+        # if content already contains a share path lets delete old and add new
+        content.each { |line|
+          updated_content << line unless line =~ /#{path}/
+        }
+        
+        put_file_content(Constants::NFS::EXPORT_FILE, updated_content)
+        
+        return updated_content
+      else
+        return content
+      end
+
+    end
+    
+    def md5sum(file)
+      nav_path = [{:execute => "md5sum #{file}", :timeout => 1}]
+      begin
+        sum = RemoteUnix::GenericShellOutput.to_lines(@ssh.navigate(nav_path), nav_path.first[:execute]).first.split(' ').first
+      rescue => e
+        puts "IGNORE: #{e}"
+      end
+      sum
+    end
+    
+    def rm_rf(loc)
+      nav_path = [{:execute => "rm -rf #{loc}", :timeout => 1}]
+      begin
+        out = RemoteUnix::GenericShellOutput.to_lines(@ssh.navigate(nav_path), nav_path.first[:execute])
+      rescue => e
+        puts "IGNORE: #{e}"
+      end
+      out
+    end
+    
+    def reboot
+      nav_path = [{:execute => "shutdown -r now", :timeout => 1}]
+      begin
+        puts RemoteUnix::GenericShellOutput.to_lines(@ssh.navigate(nav_path), nav_path.first[:execute]).pp
+      rescue => e
+        puts "IGNORE: #{e}"
+      end
+    end
+
+    def date
+      date = {}
+      nav_path = [{:execute => "date", :timeout => 1}]
+      begin
+        tmp = RemoteUnix::GenericShellOutput.to_lines(@ssh.navigate(nav_path), nav_path.first[:execute]).pp
+        
+      rescue => e
+        puts "IGNORE: #{e}"
+      end
+       Time.parse(tmp)
+     end
+   
+    def hostname
+      nav_path = [{:execute => "hostname", :timeout => 1}]
+      begin
+        hostname = RemoteUnix::GenericShellOutput.to_lines(@ssh.navigate(nav_path), nav_path.first[:execute]).pp
+      rescue => e
+        puts "IGNORE: #{e}"
+      end
+      hostname  
+    end
+     
+    def file_exists?(file)
+      nav_path = [{:execute => "if [ -f #{file} ] ; then echo 'FOUND'; else echo 'NOT_FOUND'; fi", :timeout => 1}]
+      begin
+        out = RemoteUnix::GenericShellOutput.to_lines(@ssh.navigate(nav_path), nav_path.first[:execute]).pp
+      rescue => e
+        puts "IGNORE: #{e}"
+      end
+      if out == "FOUND"
+        return true
+      elsif out == "NOT_FOUND"
+        return false
+      else
+        raise ArgumentError, "Couldn't find file #{file}"
+      end
+      
+    end
+    
+    def redhat_release
+      nav_path = [{:execute => "cat /etc/redhat-release", :timeout => 1}]
+      begin
+        out = RemoteUnix::GenericShellOutput.to_lines(@ssh.navigate(nav_path), nav_path.first[:execute]).pp
+      rescue => e
+        puts "IGNORE: #{e}"
+      end
+      out
+    end
+    
+    def kernel_version
+      nav_path = [{:execute => "uname -a", :timeout => 1}]
+      begin
+        out = RemoteUnix::GenericShellOutput.to_lines(@ssh.navigate(nav_path), nav_path.first[:execute]).pp
+      rescue => e
+        puts "IGNORE: #{e}"
+      end
+      out.split(' ')[2]
+    end
+    
+  end
+end