testability-driver-runner 0.9.2

data/lib/tdrunner_cucumber_runners.rb

@@ -0,0 +1,35 @@
+############################################################################
+## 
+## Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies). 
+## All rights reserved. 
+## Contact: Nokia Corporation (testabilitydriver@nokia.com) 
+## 
+## This file is part of Testability Driver.
+## 
+## If you have questions regarding the use of this file, please contact 
+## Nokia at testabilitydriver@nokia.com . 
+## 
+## This library is free software; you can redistribute it and/or 
+## modify it under the terms of the GNU Lesser General Public 
+## License version 2.1 as published by the Free Software Foundation 
+## and appearing in the file LICENSE.LGPL included in the packaging 
+## of this file. 
+## 
+############################################################################
+
+
+module TDRunner
+  module TDRunnerCucumber
+    module TDRunnerCucumberRunners
+      def tdrunner_loaded_features()
+        $tdrunner_loaded_features
+      end
+      def set_tdrunner_loaded_features(feature_folder,cucumber_runner)
+        if $tdrunner_loaded_features==nil
+          $tdrunner_loaded_features=[['.'],['.']]
+          end
+        $tdrunner_loaded_features << [[feature_folder],[cucumber_runner]]
+      end
+    end
+  end
+end

data/lib/tdrunner_file_finder.rb

@@ -0,0 +1,45 @@
+############################################################################
+## 
+## Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies). 
+## All rights reserved. 
+## Contact: Nokia Corporation (testabilitydriver@nokia.com) 
+## 
+## This file is part of Testability Driver.
+## 
+## If you have questions regarding the use of this file, please contact 
+## Nokia at testabilitydriver@nokia.com . 
+## 
+## This library is free software; you can redistribute it and/or 
+## modify it under the terms of the GNU Lesser General Public 
+## License version 2.1 as published by the Free Software Foundation 
+## and appearing in the file LICENSE.LGPL included in the packaging 
+## of this file. 
+## 
+############################################################################
+
+
+class TDRunnerFileFinder
+  def initialize(find_file_extension)
+    @exclude_folders_pattern = [ '.*', '_*' ]
+    @include_files_pattern = [ "*/*.#{find_file_extension}" ]
+  end
+  def file_pattern_matches?( patterns, filepath )
+    patterns.each{ | pattern | return true if File.fnmatch( pattern, filepath ) }; false
+  end
+  def get_files( folder, files_list = [] )
+    if File.directory?( folder )
+      folder = File.expand_path( folder )
+      Dir.open( folder ).each { | entry |
+        # create full filepath
+        filepath = "#{ folder }/#{ entry }"
+        # file: add file to required files list
+        files_list.push( filepath ) if file_pattern_matches?( @include_files_pattern, filepath )
+        # directory: go deeper in folder stack structure if exclusion pattern does not meet
+        files_list |= get_files("#{ filepath }/") if File.directory?( filepath ) and not file_pattern_matches?( @exclude_folders_pattern, entry )
+      }
+      files_list
+    else
+      folder
+    end
+  end
+end

data/lib/tdrunner_monitor.rb

@@ -0,0 +1,473 @@
+############################################################################
+##
+## Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies).
+## All rights reserved.
+## Contact: Nokia Corporation (testabilitydriver@nokia.com)
+##
+## This file is part of Testability Driver.
+##
+## If you have questions regarding the use of this file, please contact
+## Nokia at testabilitydriver@nokia.com .
+##
+## This library is free software; you can redistribute it and/or
+## modify it under the terms of the GNU Lesser General Public
+## License version 2.1 as published by the Free Software Foundation
+## and appearing in the file LICENSE.LGPL included in the packaging
+## of this file.
+##
+############################################################################
+require 'yaml'
+
+module TDRunner
+  #TDRunner monitor module for controlling the SIERRA execution
+  module TDRunnerMonitor
+
+    def add_failed_testunit_tests(tdrunner_parameters,case_contents_array,index)
+      if(tdrunner_parameters.failed_execution_profile != nil)
+        failed_case = case_contents_array[index].at(0).to_s
+        if tdrunner_parameters.tdrunner_ordered==false
+          #i.e. no dependencies
+          add_tc_to_failed_array(tdrunner_parameters,failed_case)
+        else
+          add_dependent_tcs_to_failed_array(tdrunner_parameters,case_contents_array,index)
+        end
+      end
+    end
+
+    def add_dependent_tcs_to_failed_array(tdrunner_parameters,case_contents_array,index)
+      temp_array=Array.new
+
+      failed_case = case_contents_array[index].at(0).to_s
+      pos = case_contents_array[index].at(2).count( "-").to_i
+      temp_array<<get_pos_string(pos) + get_test_name(failed_case)+ "(" + get_test_class(failed_case) + ")=1"
+      i = index.to_i - 1
+
+      while( i>0 ||  i==0 )
+        prev_pos = case_contents_array[i].at(2).count( "-").to_i
+        prev_failed_case = case_contents_array[i].at(0).to_s
+
+        if (pos>prev_pos && prev_pos!=0 )
+          temp_array<<get_pos_string(prev_pos) + get_test_name(prev_failed_case)+ "(" + get_test_class(prev_failed_case) + ")=1"
+        end
+
+        if(prev_pos==0)
+          temp_array<<get_pos_string(prev_pos) + get_test_name(prev_failed_case)+ "(" + get_test_class(prev_failed_case) + ")=1"
+          break
+        end
+        i=i-1
+      end
+
+      $failed_tests ||= Array.new
+      if !$failed_tests.include?  temp_array.reverse!
+        class_name = get_test_class(failed_case) + "=1"
+        $failed_tests <<class_name if !value_exists_in_array($failed_tests , class_name)
+        $failed_tests<<temp_array
+      end
+    end
+
+    def add_tc_to_failed_array(tdrunner_parameters,testcase)
+      $failed_tests ||= Array.new
+      tc_class=get_test_class(testcase)
+      tc_name=get_test_name(testcase)
+      class_name = tc_class + "=1"
+      tc_name = tc_name+ "(" + tc_class + ")=1"
+
+      if !$failed_tests.include? tc_name
+        $failed_tests <<class_name if !$failed_tests.include? class_name
+        $failed_tests << tc_name
+      end
+    end
+
+    def get_pos_string(pos)
+      pos_str=""
+      if(pos>0)
+        pos_str=Array.new(pos, "-").join.to_s
+      end
+      return pos_str
+    end
+
+    def get_test_name(testcase_name)
+      name=testcase_name.gsub(/[)]/,'')
+      name_arr=name.split('(')
+      return name_arr[0].to_s
+    end
+
+    def get_test_class(testcase_name)
+      name=testcase_name.gsub(/[)]/,'')
+      name_arr=name.split('(')
+      return name_arr[1].to_s
+    end
+
+    def write_failed_sip_file(tdrunner_parameters)
+      if($failed_tests!=nil && tdrunner_parameters.failed_execution_profile != nil && !$failed_tests.empty?)
+        file = File.open(tdrunner_parameters.failed_execution_profile.to_s,'w')
+        $failed_tests.flatten.each { |x| file.write(x.to_s+"\n")}
+        file.close
+        puts 'Failed execution profile created: '+ tdrunner_parameters.failed_execution_profile
+      end
+    end
+
+    def trap_pause
+      puts "\nExecution paused...\n"
+      puts "\nStop execution Yes or No?:"
+      response=STDIN.gets
+      if response.capitalize == "Yes\n" || response.capitalize == "Y\n"
+        $tdrunner_interrupted=true
+        STDERR.puts "\nFinalizing test... Please wait...\n"
+        STDERR.puts "\nPress ctrl+Break to interrupt immediately\n"
+        exit
+      elsif response.capitalize == "No\n" || response.capitalize == "N\n"
+        STDERR.puts "\nContinuing execution..."
+      else
+        STDERR.puts "\nIncorrect answer"
+        trap_pause
+      end
+    end
+    def trap_interrupt
+      trap('INT') do
+        trap_pause
+      end
+    end
+
+    #Method for checking how many seconds TDRunner has run
+    def format_execution_duration(duration_value)
+      secs=0
+      if (/^\d+:\d+$/.match(duration_value.to_s))
+        secs = (duration_value.split(':') [0].to_i*3600) + (duration_value.split(':') [1].to_i*60)
+      elsif (/^\d+\.\d+$/.match(duration_value.to_s))
+        secs = 3600*duration_value.to_f
+      else (/^\d+$/.match(duration_value.to_s))
+        secs=60*duration_value.to_f
+      end
+      secs
+    end
+
+    def exit_tdrunner_execution(message)
+      puts message
+    end
+
+    def remove_extra_ends_from_implementation(found_implementation, ends_to_remove)
+      removed_ends=0
+      current_index=found_implementation.length
+      found_implementation.reverse_each do |reverse_line|
+        current_index-=1
+        if removed_ends < ends_to_remove
+          if reverse_line.include?('end')
+            found_implementation.delete_at(current_index)
+            removed_ends+=1
+          end
+        end
+      end
+      found_implementation
+    end
+
+    def find_missing_method_from_ruby_file(method, loaded_test_files, method_name=nil)
+      found_implementation=Array.new
+      found_setup_implementation=Array.new
+      found_teardown_implementation=Array.new
+
+      loaded_test_files.each do |test_file|
+        if found_implementation == []
+          f = File.open(test_file) or die "Unable to open file..."
+          b_method_found=false
+
+          f.each_line do |line|
+            if b_method_found==true
+              if line.include?('def ')
+                b_method_found=false
+              end
+            end
+
+            if b_method_found==true
+              found_implementation << line
+            end
+
+            if line=~/def #{method}(.*)$/
+              if method_name==nil
+                found_implementation << line
+                found_setup_implementation << find_missing_method_from_ruby_file('setup',test_file,"setup_#{method}")
+                found_teardown_implementation << find_missing_method_from_ruby_file('teardown',test_file,"teardown_#{method}")
+              else
+                found_implementation << line.gsub(method, method_name)
+              end
+              b_method_found=true
+            end
+          end
+
+          if b_method_found==true
+            found_implementation=remove_extra_ends_from_implementation(found_implementation,1)
+            b_method_found=false
+          elsif found_implementation.length > 1 && b_method_found==false
+            #found_implementation=remove_extra_ends_from_implementation(found_implementation,1)
+            b_method_found=false
+          end
+
+        end
+      end
+      found_implementation << found_setup_implementation
+      found_implementation << found_teardown_implementation
+      found_implementation
+    end
+
+    def add_missing_methods(original_test_class,missing_methods,loaded_test_files)
+      ObjectSpace.each_object( Class ){ | test_class |
+        if test_class.ancestors.include?( Test::Unit::TestCase ) && test_class != Test::Unit::TestCase
+          test_class.public_instance_methods( true ).sort.each{ | method |
+            if method =~ /^test_/
+              missing_methods.each do |missing_method|
+                if missing_method.to_s == method
+                  method_implementation=find_missing_method_from_ruby_file(method,loaded_test_files)
+                  original_test_class.class_eval("module TestModule_#{missing_method.to_s}
+                  #{method_implementation.to_s}
+                  end")
+                  original_test_class.class_eval("include TestModule_#{missing_method.to_s}")
+                end
+              end
+            end
+          }
+        end
+      }
+      original_test_class
+    end
+
+    def get_missing_methods(test_class, case_name_array)
+      missing_methods_arr=Array.new
+      case_name_array.each do |test_case|
+        tc_line_arr=test_case.gsub(')','(').split('(')
+        if tc_line_arr.length > 1
+          if tc_line_arr[1].to_s==test_class.name.to_s
+            b_method_exists=false
+            test_class.public_instance_methods( true ).sort.each{ | method |
+              if method =~ /^test_/
+                if tc_line_arr[0].to_s==method.to_s
+                  b_method_exists=true
+                end
+              end
+            }
+            if b_method_exists==false
+              missing_methods_arr << tc_line_arr[0].to_s
+            end
+          end
+        end
+      end
+      missing_methods_arr
+    end
+
+    #adds missing test methods in to the test class based on tdrunner execution profile
+    def add_missing_methods_in_to_test_class(test_class,tdrunner_parameters,loaded_test_files)
+
+      f = File.open(tdrunner_parameters.execution_profile) or die "Unable to open file..."
+      case_name_array=[]
+      b_profile_file_exist=false
+      f.each_line do |line|
+        case_arr=line.split('=')
+        if case_arr.length > 1
+          case_name_array << case_arr[0].gsub('-','')
+          b_profile_file_exist=true
+        end
+      end
+      if b_profile_file_exist==true
+        missing_methods=get_missing_methods(test_class, case_name_array)
+        test_class=add_missing_methods(test_class,missing_methods,loaded_test_files)
+      end
+      test_class
+    end
+
+
+    #Removes duplicates and existing randomizations if found
+    def flatten_tests(tests)
+      clean_test_arr=[]
+      tests.each do |test_case|
+        unless clean_test_arr.include? test_case
+          clean_test_arr.push test_case
+        end
+      end
+      clean_test_arr
+    end
+
+    def get_test_classes(tests)
+      test_classes=[]
+      tests.each do |test_case|
+        if test_case.to_s.include?('(')==false
+          test_classes.push test_case
+        end
+      end
+      test_classes
+    end
+
+    def is_class_included(case_contents_array,class_name)
+      b_class_added=false
+      case_contents_array.each do | case_content|
+        if case_content[0]==class_name
+          b_class_added=true
+        end
+        break if b_class_added==true
+      end
+      b_class_added
+    end
+
+    def order_the_tests(tests,case_contents_array)
+      ordered_tests=[]
+      ordered_contents=[]
+      tests_to_string=[]
+      not_found_tests=[]
+      tests.each do |tc|
+        tests_to_string << tc.to_s
+      end
+      test_classes=get_test_classes(tests)
+      case_contents_array.each  do|tc|
+        if not_found_tests.include?(tc[0].to_s)==false
+          index=tests_to_string.index tc[0].to_s
+          if index!=nil
+            ordered_tests.push tests[index]
+            ordered_contents.push tc
+          else
+            tests_to_be_added=tests.find_all{|item| item.to_s % item.to_s == tc[0].to_s }
+            if tests_to_be_added!=[]
+              ordered_tests.push tests_to_be_added.first
+              ordered_contents.push tc
+            else
+              not_found_tests << tc[0].to_s
+            end
+          end
+        end
+      end
+      test_classes.each do |test_class|
+        if is_class_included(case_contents_array,test_class.to_s)==false
+          ordered_tests.push test_class
+          ordered_contents.push [test_class.to_s,nil,test_class.to_s,'not run']
+        end
+      end
+      return ordered_tests, ordered_contents
+    end
+
+    def organize_tests(tests,case_contents_array,case_name_array,tdrunner_parameters)
+      organized_tests=[]
+      test_classes=get_test_classes(tests)
+      tests.each do |test_case|
+        profile_index=case_name_array.index test_case.to_s
+        if profile_index == nil
+          File.open(tdrunner_parameters.execution_profile, 'a') { |file| file.write("\n"+test_case.to_s+"=1") } if tdrunner_parameters.execution_mode=='-m'
+        else
+          case_contents_array.each do |test|
+            if test_case.to_s==test[0].to_s
+
+              organized_tests.push test_case
+
+            end
+          end
+        end
+
+      end
+      test_classes.each do |test_class|
+        organized_tests.push test_class
+      end
+      organized_tests
+    end
+
+    def value_exists_in_array(current_array,value)
+      b_exists=false
+      current_array.each do |arr_value|
+        if arr_value.include?(value)
+          b_exists=true
+        end
+      end
+      b_exists
+    end
+
+    #method for randomizing the executed tests
+    def randomize_test_cases(tests,tdrunner_parameters)
+      tests=flatten_tests(tests)
+      if tdrunner_parameters.execution_profile!=nil
+        f = File.open(tdrunner_parameters.execution_profile) or die "Unable to open file..."
+        @case_contents_array=[]   # start with an empty array
+        case_name_array=[]
+        b_profile_file_exist=false
+
+        f.each_line do |line|
+          case_arr=line.split('=')
+          if case_arr.length == 2
+            for i in (1..case_arr[1].to_i)
+              @case_contents_array << [case_arr[0].gsub('-',''),nil,case_arr[0],'not run'] #name, parameters, place in tree, test result
+              case_name_array << case_arr[0].gsub('-','')
+            end
+            b_profile_file_exist=true
+          elsif case_arr.length == 3
+            for i in (1..case_arr[1].to_i)
+              @case_contents_array << [case_arr[0].gsub('-',''),case_arr[2],case_arr[0],'not run'] #name, parameters, place in tree, test result
+              case_name_array << case_arr[0].gsub('-','')
+            end
+            b_profile_file_exist=true
+          end
+        end
+        tests=organize_tests(tests,@case_contents_array,case_name_array,tdrunner_parameters)
+
+      end
+
+      if tdrunner_parameters.tdrunner_ordered==false
+        if b_profile_file_exist==true
+          @case_contents_array=@case_contents_array.shuffle
+          tests,@case_contents_array=order_the_tests(tests, @case_contents_array)
+        end
+      else
+        if b_profile_file_exist==true
+          tests,@case_contents_array=order_the_tests(tests, @case_contents_array)
+        end
+      end
+      return tests, @case_contents_array
+
+    end
+
+    #Method to check how long tdrunner run is active
+    #TDRunner mode is checked from initialized TDRunnerParameters class
+    def tdrunner_active(run_start_time,iteration,tdrunner_parameters)
+      current_run_time=Time.now-run_start_time
+      case tdrunner_parameters.execution_mode
+      when '-H'
+        if (current_run_time<format_execution_duration(tdrunner_parameters.duration_value))
+          true
+        else
+          false
+        end
+      when '-i'
+        if iteration<tdrunner_parameters.lpt_run
+          true
+        else
+          false
+        end
+      when '-d'
+        if Time.now<tdrunner_parameters.lpt_run
+          true
+        else
+          false
+        end
+      when '-m'
+        #exit_tdrunner_execution('Execution profile created: '+ tdrunner_parameters.execution_profile)
+        false
+      when '-e'
+        if iteration<tdrunner_parameters.lpt_run
+          true
+        else
+          false
+        end
+      end
+    end
+
+
+    #Formater for displaying the execution time
+    def format_duration(seconds)
+      m, s = seconds.divmod(60)
+      "#{m}m#{'%.3f' % s}s"
+    end
+
+    def wait_for_starttime(tdrunner_parameters)
+      #If the start time is defined then only start execution at this time
+      if tdrunner_parameters.start_time!=nil
+        while Time.now < tdrunner_parameters.start_time
+          sleep(1)
+        end
+      end
+    end
+
+  end
+end