actir 1.0.0

data/lib/actir/parallel_tests/test/logger.rb

@@ -0,0 +1,74 @@
+require 'actir/parallel_tests/test/runner'
+
+module Actir
+  module ParallelTests
+    module Test
+      class Logger
+
+        #为每个进程准备一个变量表示是否需要初始化log文件，暂时先定10个
+        @@prepared = []
+        #不知道为什么代码中export ENV无效，暂时先用10
+        #num = ENV["PARALLEL_TEST_GROUPS"].to_i
+        for i in 1..10
+          @@prepared << false
+        end
+
+        class << self 
+
+          def log(result, process_index)
+            #获取执行环境的当前进程号以及总进程数目
+            #process_index = env["TEST_ENV_NUMBER"]
+            #num_process   = env["PARALLEL_TEST_GROUPS"]
+            prepare(process_index)
+
+            lock(process_index) do
+              File.open(logfile(process_index), 'a') { |f| f.puts result }
+            end
+          end
+
+          # 打印每个进程的log文件内容到屏幕上
+          def show_log(process_index)
+            separator = "\n"
+            File.read(logfile(process_index)).split(separator).map do |line| 
+              if line == ""
+                puts line 
+              else
+                puts "[process_" + process_index.to_s + "] - " + line 
+              end
+            end
+          end
+
+          private
+
+          # ensure folder exists + clean out previous log
+          # this will happen in multiple processes, but should be roughly at the same time
+          # so there should be no log message lost
+          def prepare(process_index)
+            return if @@prepared[process_index]
+            @@prepared[process_index] = true
+            FileUtils.mkdir_p(File.dirname(logfile(process_index)))
+            File.write(logfile(process_index), '')
+          end
+
+          def lock(process_index)
+            File.open(logfile(process_index), 'r') do |f|
+              begin
+                f.flock File::LOCK_EX
+                yield
+              ensure
+                f.flock File::LOCK_UN
+              end
+            end
+          end
+
+          def logfile(process_index)
+            "tmp/parallel_test_p_#{process_index}.log"
+          end
+
+        end
+
+      end
+    end
+  end
+end
+

data/lib/actir/parallel_tests/test/re_run.rb

@@ -0,0 +1,153 @@
+module Actir
+  module ParallelTests
+    module Test
+      class Rerun < Runner
+
+        class << self
+          
+          #
+          # 重新执行失败的测试用例
+          #
+          # 用例执行通过或者达到了重试次数上限后即返回最终的执行结果
+          #
+          # 限制:不管是否在同一文件中,用例名称不能重复,即用例名称全局唯一
+          #
+          # @example : re_run_tests('店铺名称')
+          #
+          # @param test_result   : [String] 商品名称的字符串
+          #
+          #        num_processes : [Fixnum] 并发进程数
+          #
+          #        address       : [String] 执行用例的环境的地址
+          #
+          #        times         : [Fixnum] 执行次数
+          #
+          #       process_number : [Fixnum] 暂时无用
+          #
+          # @return [String] 执行结果字符串
+          #
+          def re_run_tests(test_result, process_number, num_processes, options, address, times)
+              #根据重跑次数重新执行失败用例
+              result = re_run(test_result, process_number, num_processes, options, address, times)
+              #从老的执行结果输出中提取出相关数据
+              old_result = summarize_results(find_results(test_result[:stdout]))
+              #puts "old_result : " + old_result
+              #从新的执行结果中提取出数据,并算出总数
+              #因为若有多个失败用例就有多个执行结果
+              new_result = summarize_results(find_results(result[:stdout]))
+              #puts "new_result : " + new_result
+              #刷新最终的执行结果
+              if old_result == nil || old_result == ""
+                puts "[Debug] test_result : "
+                puts test_result
+              end
+              if new_result == nil || new_result == ""
+                puts "[Debug] result : "
+                puts result
+              end
+              combine_tests_results(old_result, new_result)
+          end
+          
+          private
+
+          def re_run(test_result, process_number, num_processes, options, address, times)
+            result = {}
+            if times > 0
+              #先获取失败用例信息
+              tests = capture_failures_tests(test_result)
+              cmd = ""
+              tests.each do |testcase, testfile|
+                #输出一些打印信息
+                puts "[ Re_Run ] - [ #{testfile} -n #{testcase} ] - Left #{times-1} times - in Process[#{process_number}]"
+                cmd += "#{executable} #{testfile} #{address} -n #{testcase};"
+              end 
+              #执行cmd,获取执行结果输出
+              result = execute_command(cmd, process_number, num_processes, options)
+              #先判断是否还是失败，且未满足重试次数
+              times -= 1
+              if any_test_failed?(result) && times > 0 
+                #递归
+                result = re_run(result, process_number, num_processes, options, address, times)
+              end
+            end
+            #记录log
+            if options[:log]
+              log_str = "[re_run_tests]: \n" + result[:stdout]
+              Actir::ParallelTests::Test::Logger.log(log_str, process_number)
+            end
+            return result
+          end
+
+          #从输出内容中获取失败用例文件名以及用例名称
+          def capture_failures_tests(test_result)
+            result_array = test_result[:stdout].split("\n")
+            failure_tests_hash = {}
+            testcase = ""
+            testfile = ""
+            result_array.each do |result|
+              #取出执行失败的用例文件名称和用例名称
+              case result
+              when failure_tests_name_reg
+                #范例:"testhehe(TestHehe)"
+                testcase = $1
+              when failure_tests_file_reg
+                #范例:"testcode/test_tt/test_hehe.rb:8:in `xxxx'"
+                testfile = $1
+              end
+              #至于为什么采用testcase => testfile的形式是因为…文件名会重复
+              if testcase != "" && testfile != "" 
+                failure_tests_hash[testcase] = testfile
+                testcase = ""
+                testfile = ""
+              end
+            end
+            failure_tests_hash
+          end
+
+          #组合出最新的执行结果
+          #只需要将老结果中的failure和error的数据替换成新结果中的数据即可
+          def combine_tests_results(old_result, new_result)
+            if old_result == nil || old_result == ""
+              puts "new_result : " + new_result
+              raise "old_result is nil" 
+            end
+            #取出新结果中的failure和error的数据
+            new_result =~ failure_error_reg
+            failure_error_str = $1
+            failure_data      = $2
+            error_data        = $3
+            #替换老结果中的失败数据
+            comb_result = old_result.gsub(failure_error_reg, failure_error_str)
+            #按照{:stdout => '', :exit_status => 0}的格式输出内容，不然原有代码不兼容
+            #其中exit_status = 0 表示用例全部执行成功,反之则有失败
+            exitstatus = ( (failure_data.to_i + error_data.to_i) == 0 ) ? 0 : 1
+            {:stdout => comb_result + "\n", :exit_status => exitstatus}
+          end
+
+          #判断是否有用例失败
+          def any_test_failed?(result)
+            result[:exit_status] != 0
+          end
+
+          #获取失败用例文件名的正则
+          def failure_tests_file_reg
+            /(.+\/test.+rb):\d+:in\s`.+'/
+            #/^Loaded\ssuite\s(.+)/
+          end
+
+          #获取失败用例名的正则
+          def failure_tests_name_reg
+            /(test.+)\(.+\)/
+          end
+
+          #获取失败数据的正则
+          def failure_error_reg
+            /((\d+)\sfailure.*,\s(\d+)\serror)/
+          end
+
+        end
+
+      end
+    end
+  end
+end

data/lib/actir/parallel_tests/test/runner.rb

@@ -0,0 +1,224 @@
+module Actir
+  module ParallelTests
+    module Test
+      class Runner
+        NAME = 'Test'
+
+        class << self
+          # --- usually overwritten by other runners
+
+          def name
+            NAME
+          end
+          
+          # modify by Hub
+          # 修改正则表达式使得使用我们目前的测试脚本文件命名 : test_xxx.rb
+          def test_suffix
+           # /_(test|spec).rb$/
+           /test.*\.rb$/
+          end
+
+          def test_file_name
+            "test"
+          end
+
+          # modify by Hub 
+          # add param address to ruby script as ARGV[0]
+          # modify cmd to exec ruby test script 
+          def run_tests(test_files, process_number, num_processes, options, address)
+            #require_list = test_files.map { |file| file.sub(" ", "\\ ") }.join(" ")
+            #cmd = "#{executable} -Itest -e '%w[#{require_list}].each { |f| require %{./\#{f}}}' #{address}"
+            #execute_command(cmd, process_number, num_processes, options)
+            cmd = ""
+            test_files.each do |file|
+              cmd += "#{executable} #{file} #{address};"
+            end 
+            cmd += "\n"
+            result = execute_command(cmd, process_number, num_processes, options)
+            #记录log
+            if options[:log]
+              log_str = "[run_tests]: \n" + result[:stdout]
+              Actir::ParallelTests::Test::Logger.log(log_str, process_number)
+            end
+            result
+          end
+
+          def line_is_result?(line)
+            line.gsub!(/[.F*]/,'')
+            line =~ /\d+ failure/
+          end
+
+          # --- usually used by other runners
+
+          # finds all tests and partitions them into groups
+          def tests_in_groups(tests, num_groups, options={})
+            tests = find_tests(tests, options)
+
+            case options[:group_by]
+            when :found
+              tests.map! { |t| [t, 1] }
+            when :filesize
+              sort_by_filesize(tests)
+            when nil
+              sort_by_filesize(tests)
+            else
+              raise ArgumentError, "Unsupported option #{options[:group_by]}"
+            end
+
+            Grouper.in_even_groups_by_size(tests, num_groups, options)
+          end
+
+          def execute_command(cmd, process_number, num_processes, options)
+            env = (options[:env] || {}).merge(
+              #"TEST_ENV_NUMBER" => test_env_number(process_number),
+              "TEST_ENV_NUMBER" => process_number,
+              "PARALLEL_TEST_GROUPS" => num_processes
+            )
+            cmd = "nice #{cmd}" if options[:nice]
+            cmd = "#{cmd} 2>&1" if options[:combine_stderr]
+            puts cmd if options[:verbose]
+
+            execute_command_and_capture_output(env, cmd, options[:serialize_stdout])
+          end
+
+          def execute_command_and_capture_output(env, cmd, silence)
+            # make processes descriptive / visible in ps -ef
+            separator = ';'
+            exports = env.map do |k,v|
+              "export #{k}=#{v}"
+            end.join(separator)
+            cmd = "#{exports}#{separator}#{cmd}"
+            output = open("|#{cmd}", "r") { |output| capture_output(output, silence) }
+
+            #modify by Hub
+            #exitstatus = $?.exitstatus
+            #"$?.exitstatus" 返回的值有时有问题，不能明确标示用例执行结果是否成功
+            #改成判断结果数据中是否有failure和error
+            exitstatus = get_test_failed_num(find_results(output).join)
+            {:stdout => output, :exit_status => exitstatus}
+          end
+
+          def find_results(test_output)
+            test_output.split("\n").map {|line|
+              line.gsub!(/\e\[\d+m/,'')
+              next unless line_is_result?(line)
+              line
+            }.compact
+          end
+
+          def test_env_number(process_number)
+            process_number == 0 ? '' : process_number + 1
+          end
+
+          def summarize_results(results)
+            sums = sum_up_results(results)
+            sums.to_a.map{|word, number|  "#{number} #{word}#{'s' if number != 1}" }.join(', ')
+            #sums.sort.map{|word, number|  "#{number} #{word}#{'s' if number != 1}" }.join(', ')
+          end
+
+          protected
+
+          def executable
+            ENV['PARALLEL_TESTS_EXECUTABLE'] || determine_executable
+          end
+
+          def determine_executable
+            if Actir::Remote.is_local?
+              "ruby"
+            else
+              #TO-DO jenkins服务器上的ruby是用rvm管理的,这里有个坑，在jenkins中调用ruby命令会报找不到
+              #后续考虑更换rvm至rbenv
+              #jenkins服务器上的ruby所在地址
+              "/usr/local/rvm/rubies/ruby-2.0.0-p598/bin/ruby"
+            end
+          end
+
+          #
+          # 通过结果判断是否有用例失败
+          # 返回失败用例的数目 
+          #
+          def get_test_failed_num(result)
+            #获取结果字符串中的failure和error用例数
+            failed_num = 0
+            result.scan(/(\d+)\s(failure|error)/).each do |failed|
+              failed_num += failed[0].to_i
+            end
+            failed_num
+          end
+
+          def sum_up_results(results)
+            results = results.join(' ').gsub(/s\b/,'') # combine and singularize results
+            #results = results.join(' ')
+            counts = results.scan(/(\d+) (\w+)/)
+            counts.inject(Hash.new(0)) do |sum, (number, word)|
+              sum[word] += number.to_i
+              sum
+            end
+          end
+
+          # read output of the process and print it in chunks
+          def capture_output(out, silence)
+            result = ""
+            loop do
+              begin
+                read = out.readpartial(1000000) # read whatever chunk we can get
+                if Encoding.default_internal
+                  read = read.force_encoding(Encoding.default_internal)
+                end
+                result << read
+                unless silence
+                  $stdout.print read
+                  $stdout.flush
+                end
+              end
+            end rescue EOFError
+            result
+          end
+
+          def sort_by_filesize(tests)
+            tests.sort!
+            tests.map! { |test| [test, File.stat(test).size] }
+          end
+
+          # modify by Hub
+          # 由原来的包含路径的文件名直接进行正则匹配改为取出文件的文件名进行匹配,更准确,不受文件夹命名的影响
+          def find_tests(tests, options = {})
+            (tests || []).map do |file_or_folder|
+              if File.directory?(file_or_folder)
+                #取出文件和文件夹名字
+                files_and_folder = files_in_folder(file_or_folder, options)
+                #去掉文件夹名字
+                files = files_and_folder.grep(test_suffix)
+                #去掉不以test开头的测试脚本
+                files_2_delete = Array.new
+                files.each do |file|
+                  file_name = File.basename(file)
+                  #不能在遍历数组时进行delete操作
+                  #记录要删除的元素名称
+                  files_2_delete << file unless file_name =~ /^test.*\.rb$/
+                  #files.delete(file) unless file_name =~ /^test.*\.rb$/
+                end
+                files_2_delete.each { |file_2_delete| files.delete(file_2_delete) }
+                files
+              else
+                file_or_folder
+              end
+            end.flatten.uniq
+          end
+
+          # modify by Hub
+          # Bug Fix
+          # lack of method 'glob'
+          def files_in_folder(folder, options={})
+            pattern = "**{,/*/**}/*"
+            # modify by Hub
+            # add method glod : Dir.glob
+            #Dir[File.join(folder, pattern)].uniq
+            Dir.glob(File.join(folder, pattern)).uniq
+          end
+
+        end
+      end
+    end
+  end
+end