soda 1.0.7 → 1.0.8

data/bin/SodaSuite

@@ -130,7 +130,7 @@ class SodaSuite
 		result = soda.RunAllSuites(suites)
 	
 		return result
-end
+   end
 
 ###############################################################################
 # Execute -- Medhod
@@ -247,6 +247,8 @@ Optional Flags:
 
    --help:  Prints this message and exits.
 
+   --nonzippytext: This turns on zippy text entry for Watir.
+
    --version: Print the Soda Version string.
 
 HLP
@@ -472,6 +474,7 @@ def Main
    test_files = []
    hijacks = {}
    params = {
+      'nonzippytext' => false,
       'sugarwait' => false,
       'verbose' => false,
       'browser' => nil,
@@ -534,6 +537,7 @@ def Main
                [ '--restarttest', '-2', GetoptLong::OPTIONAL_ARGUMENT],
                [ '--reruntest', '-3', GetoptLong::OPTIONAL_ARGUMENT ],
 					[ '--skipcsserrors', '-4', GetoptLong::OPTIONAL_ARGUMENT],
+               [ '--nonzippytext', '-6', GetoptLong::OPTIONAL_ARGUMENT],
                [ '--version', '-5', GetoptLong::OPTIONAL_ARGUMENT]
             )
 
@@ -578,6 +582,8 @@ def Main
                rerun_test_script = arg
 				when "--skipcsserrors"
 					params['errorskip'].push("css")
+            when "--nonzippytext"
+               params['nonzippytext'] = true
             when "--version"
                print "(*)SODA Version: #{SODA_GEM_VERSION}\n\n"
                return 0
@@ -614,6 +620,7 @@ def Main
    SodaUtils.PrintSoda("SodaSuite Settings:\n--)Browser:" +
       " #{params['browser']}\n--)Debug: #{params['debug']}\n--)Verbose:"+
       " #{params['verbose']}\n" +
+      "--)NonZippyText: #{params['nonzippytext']}\n" +
       "--)Watir Version: #{Watir::VERSION}\n")
    SodaUtils.PrintSoda("Starting testing...\n")
 

data/lib/Soda.rb

@@ -99,6 +99,7 @@ class Soda
       @currentTestFile = "" 
       @exceptionExit = false
       @ieHwnd = 0
+      @nonzippytext = false
       $global_time = Time.now()
       $mutex = Mutex.new()
       @whiteList = []
@@ -124,6 +125,7 @@ class Soda
       @sugarFlavor = params['flavor'] if (params.key?('flavor'))
       @resultsDir = params['resultsdir'] if (params.key?('resultsdir'))
       @globalVars = params['gvars'] if (params.key?('gvars'))
+      @nonzippytext = params['nonzippytext'] if (params.key?('nonzippytext'))
 
       if (@globalVars.key?('scriptsdir'))
          blocked_file_list = "#{@globalVars['scriptsdir']}/modules/" +
@@ -408,12 +410,16 @@ class Soda
       if (value.instance_of?(Hash))
          msg << " Hash:{"
          value.each do |k ,v|
-            msg << "'#{k}'=>'#{v}',"
+            tmp_k = k.gsub("\n", '\n')
+            tmp_v = v.gsub("\n", '\n')
+            msg << "'#{tmp_k}'=>'#{tmp_v}',"
          end
          msg = msg.chop()
          msg << "}\n" 
       else
-         msg << " \"#{value}\"\n"
+         tmp_value = "#{value}"
+         tmp_value = tmp_value.gsub("\n", '\n')
+         msg << " \"#{tmp_value}\"\n"
       end
 
       PrintDebug(msg)
@@ -483,7 +489,9 @@ class Soda
             " \"#{val}\" to \"#{@hiJacks["#{org_name}"]}\"\n")
          val = @hiJacks["#{org_name}"]
       else
-         PrintDebug("Value for \"#{tmp_name}\" => \"#{val}\".\n")
+         tmp_val = "#{val}"
+         tmp_val = tmp_val.gsub("\n", '\n')
+         PrintDebug("Value for \"#{tmp_name}\" => \"#{tmp_val}\".\n")
       end
 
       val = "" if (val == nil) # default it to be an empty string. #
@@ -820,11 +828,19 @@ class Soda
 
       if (@non_lib_test_count >= @restart_count)
          @rep.log("Restarting browser.\n")
-         @browser.close()
-         sleep(1)
+        
+         begin 
+            @browser.close()
+            sleep(1)
+         rescue Exception => e
+         end
 
          RestartGlobalTime()
 
+         if (@params['browser'] =~ /firefox/i)
+            SodaFireFox.KillProcesses()
+         end
+
          err = NewBrowser()
          if (err != 0)
             @rep.ReportFailure("Failed to restart browser!\n")
@@ -1055,7 +1071,11 @@ class Soda
       end
 
       if (org_str != str)
-         PrintDebug("Replacing string '#{org_str}' with '#{str}'\n")
+         tmp_org_str = "#{org_str}"
+         tmp_org_str = tmp_org_str.gsub("\n", '\n')
+         tmp_str = "#{str}"
+         tmp_str = tmp_str.gsub("\n", '\n')
+         PrintDebug("Replacing string '#{tmp_org_str}' with '#{tmp_str}'\n")
       end
 
       return str  
@@ -2128,7 +2148,7 @@ JSCode
          foundaction = event['do']
       end
 
-      if (event.key?("alert") )
+      if (event.key?("alert"))
        if (event['alert'] =~ /true/i)
           @rep.log("Enabling Alert Hack\n")
           fieldType.alertHack(true, true) 
@@ -2144,7 +2164,7 @@ JSCode
          js = replaceVars(event['jscriptevent'])
       end
 
-      case foundaction
+      case (foundaction)
          when "append"
             result = fieldType.append(@curEl, replaceVars(event['append']))
             if (result != 0)
@@ -2213,8 +2233,12 @@ JSCode
                end
             end
          when "set"
-            PrintDebug("Setting value to #{event['set']}\n")
-            result = fieldType.set(@curEl, event['set'])
+            if (@curEl.class.to_s =~ /textfield/i)
+               result = fieldType.set(@curEl, event['set'], @nonzippytext)
+            else
+               result = fieldType.set(@curEl, event['set'])
+            end
+
             if (result != 0)
                event['current_test_file'] = @currentTestFile
                e_dump = SodaUtils.DumpEvent(event)
@@ -2674,22 +2698,31 @@ JSCode
 #     file: The Soda test file.
 #     rerun: true/false, this tells soda that this tests is a rerun of a
 #        failed test.
+#     suitename: The name of the suite to group the results into.
 #
 # Results:
 #     returns a SodaReport object.
 #
 ############################################################################### 
-   def run(file, rerun = false, genhtml = true)
+   def run(file, rerun = false, genhtml = true, suitename = nil)
       result = 0
       master_result = 0
       thread_soda = nil
       thread_timeout = (60 * 10) # 10 minutes #
       time_check = nil
+      resultsdir = nil
+
+      if (suitename != nil)
+         resultsdir = "#{@resultsDir}/#{suitename}"
+      else
+         resultsdir = @resultsDir
+      end
 
       @currentTestFile = file
       @exceptionExit = false      
       @fileStack.push(file)
-      @rep = SodaReporter.new(file, @saveHtml, @resultsDir, 0, nil, rerun);
+
+      @rep = SodaReporter.new(file, @saveHtml, resultsdir, 0, nil, rerun);
       SetGlobalVars()
        
       script = getScript(file)
@@ -2818,12 +2851,11 @@ JSCode
    def RunSuite(suitefile)
       parser = nil
       doc = nil
+      test_order = 0
       result = {}
       tests = []
-      setup_test = nil
-      cleanup_test = nil
-      setup_results = 0
-
+      suite_name = File.basename(suitefile, ".xml")
+      
       begin
          parser = LibXML::XML::Parser.file(suitefile)
          doc = parser.parse()
@@ -2838,7 +2870,7 @@ JSCode
                tests.push(attrs['file'])
             elsif (attrs.key?('fileset'))
                files = File.join(attrs['fileset'], "*.xml")
-               files = Dir.glob(files)
+               files = Dir.glob(files).sort_by{|f| File.stat(f).mtime}
                files.each do |f|
                   tests.push(f)
                end
@@ -2851,39 +2883,26 @@ JSCode
       ensure
       end   
 
-      if (setup_test != nil)
-         setup_result = run(setup_test, false, false)
-         if (setup_result != 0)
-            SodaUtils.PrintSoda("Failed calling setup test: "+
-               "'#{setup_test}'!\n", SodaUtils::ERROR)
-            result[setup_test] = {'result' => -1}
-            setup_result = false
+      tests.each do |test|
+         test_order += 1
+         tmp_result = {}
+         tmp_result['result'] = run(test, false, true, suite_name)
+         tmp_result['Test_Order'] = test_order
+         tmp_result.merge!(@rep.GetRawResults)
+         tmp_result['Real_Test_Name'] = test
+         test_basename = File.basename(test, ".xml")
+         logfile = tmp_result['Test Log File']
+         if (logfile =~ /#{test_basename}-\d+/)
+            test =~ /(.*\/)#{test_basename}/
+            ran_test_name = $1
+            ran_test_name << File.basename(logfile, ".log")
+            ran_test_name << ".xml"
          else
-            setup_result = true
-            result[setup_test] = {'result' => 0}
+            ran_test_name = test
          end
-      else
-         setup_result = true
-      end
 
-      if (setup_result)
-         tests.each do |test|
-            result[test] = {}
-            result[test]['result'] = run(test, false)
-            result[test].merge!(@rep.GetRawResults)
-            @rep.ZeroTestResults()
-         end
-      end
-
-      if (cleanup_test != nil)
-         cleanup_result = run(cleanup_test, false, false)
-         if (cleanup_result != 0)
-            SodaUtils.PrintSoda("Failed calling cleanup test: "+
-               "'#{cleanup_test}'!\n", SodaUtils::ERROR)
-            result[cleanup_test] = {'result' => -1}
-         else
-            result[cleanup_test] = {'result' => 0}
-         end
+         result[ran_test_name] = tmp_result
+         @rep.ZeroTestResults()
       end
 
       return result

data/lib/SodaCSV.rb

@@ -72,6 +72,7 @@ class SodaCSV
             if (!data[k].to_s.empty?)
                all_nil = false
             end
+            data[k] = data[k].gsub('\n', "\n")
             record[@fieldMap[k]] = data[k]
          end
       else 

data/lib/SodaFireFox.rb

@@ -116,5 +116,143 @@ JS
 
 end
 
+###############################################################################
+# KillProcessWindows -- function
+#     This function find all running firefox processes and then tries to 
+#     kill them.
+#
+# Input:
+#     None.
+#
+# Output:
+#     returns -1 on error else 0 on success.
+#
+###############################################################################
+def SodaFireFox.KillProcessWindows()
+   firefox = []
+   tmp = nil
+   result = 0
+
+   tmp = Kernel.open("| tasklist /NH")
+   lines = tmp.readlines()
+   tmp.close()
+
+   lines.each do |l|
+      l = l.chomp()
+      if (l =~ /firefox/i)
+         hash = {
+            'pid' => nil,
+            'name' => nil
+         }
+         data = l.split(/\s+/)
+         hash['name'] = data[0]
+         hash['pid'] = data[1].to_i()
+         firefox.push(hash)
+      end
+   end
+
+   if (firefox.length < 1)
+      $curSoda.rep.log("No firefox processes to kill, browser closed clean.\n")
+   end
+
+   firefox.each do |hash|
+      begin
+         $curSoda.rep.log("Killing Process ID: #{hash['pid']}, Name:"+
+            "#{hash['name']}\n")
+         Process.kill("KILL", hash['pid'])
+      rescue Exception => e
+         $curSoda.rep.ReportException(e, true, false)
+         result = -1
+      end
+   end
+
+   return result
+end
+
+###############################################################################
+# KillProcessUnix -- function
+#     This function find all running firefox processes and then tries to 
+#     kill them.
+#
+# Input:
+#     None.
+#
+# Output:
+#     returns -1 on error else 0 on success.
+#
+###############################################################################
+def SodaFireFox.KillProcessUnix()
+   firefox = []
+   tmp = nil
+   result = 0
+
+   tmp = Kernel.open("| ps -e")
+   lines = tmp.readlines()
+   tmp.close()
+
+   lines.shift()
+   lines.each do |l|
+      l = l.chomp()
+      l = l.gsub(/^\s+/, "")
+
+      if (l =~ /firefox/i)
+         print "(*)#{l}\n"
+         hash = {
+            'pid' => nil,
+            'name' => nil
+         }
+
+         data = l.split(/\s+/)
+         hash['pid'] = data[0].to_i()
+         hash['name'] = data[3]
+         firefox.push(hash)
+      end
+   end
+
+   if (firefox.length < 1)
+      $curSoda.rep.log("No firefox processes to kill, browser closed clean.\n")
+   end
+
+   firefox.each do |hash|
+      begin
+         $curSoda.rep.log("Killing Process ID: #{hash['pid']}, Name:"+
+            "#{hash['name']}\n")
+         Process.kill("KILL", hash['pid'])
+      rescue Exception => e
+         $curSoda.rep.ReportException(e, true, false)
+         result = -1
+      end
+   end
+
+   return result
+end
+
+###############################################################################
+# KillProcesses -- function
+#     This function kills all firefox processes.
+#
+# Input:
+#     None.
+#
+# Output:
+#     returns -1 on error else 0 on success.
+#
+###############################################################################
+def SodaFireFox.KillProcesses()
+   os = nil
+   err = 0
+
+   os = SodaUtils.GetOsType()
+   case (os)
+      when /linux/i
+         err = KillProcessUnix()
+      when /windows/i
+         err = KillProcessWindows()
+   end
+
+   return err
+
+end
+
 end # end module #
 

data/lib/SodaReportSummery.rb

@@ -198,7 +198,6 @@ def GenerateReportData(files)
 
    return test_info
 end
-
    private :GenerateReportData
 
 ###############################################################################
@@ -330,16 +329,13 @@ table
 <tr class="tr_header">
 \t<td>Test File:<br>
 \tClick link for full report</td>
-\t<td>Test Count:</td>
-\t<td>Test Skip Count:</td>
-\t<td>Failure Count:</td>
+\t<td>Test Failure Count:</td>
 \t<td>CSS Error Count:</td>
 \t<td>JavaScript Error Count:</td>
 \t<td>Assert Failures:</td>
 \t<td>Event Count:</td>
 \t<td>Assert Count:</td>
 \t<td>Exceptions:</td>
-\t<td>Major Exceptions:</td>
 \t<td>Running Time:<br>(hh:mm:ss):</td>
 </tr>
 HTML
@@ -361,8 +357,6 @@ HTML
          rpt['report_hash']['Test Assert Count'].to_i()
       totals['Test Exceptions'] += 
          rpt['report_hash']['Test Exceptions'].to_i()
-      totals['Test Major Exceptions'] +=
-         rpt['report_hash']['Test Major Exceptions'].to_i()
       totals['Test Count'] += rpt['report_hash']['Test Count'].to_i()
       totals['Test Skip Count'] += rpt['report_hash']['Test Skip Count'].to_i()
 
@@ -407,8 +401,6 @@ HTML
          "onMouseOver=\"this.className='highlight'\" "+
          "onMouseOut=\"this.className='tr_normal'\">\n" +
          "\t<td class=\"td_file\">#{log_file_td}</td>\n" +
-         "\t<td>#{rpt['report_hash']['Test Count']}</td>\n"+
-         "\t<td>#{rpt['report_hash']['Test Skip Count']}</td>\n"+
          "\t<td>#{rpt['report_hash']['Test Failure Count']}</td>\n"+
          "\t<td>#{rpt['report_hash']['Test CSS Error Count']}</td>\n" +
          "\t<td>#{rpt['report_hash']['Test JavaScript Error Count']}</td>\n" +
@@ -416,7 +408,6 @@ HTML
          "\t<td>#{rpt['report_hash']['Test Event Count']}</td>\n" +
          "\t<td>#{rpt['report_hash']['Test Assert Count']}</td>\n" +
          "\t<td>#{rpt['report_hash']['Test Exceptions']}</td>\n" +
-         "\t<td>#{rpt['report_hash']['Test Major Exceptions']}</td>\n" +
          "\t<td>#{hours}:#{minutes}:#{seconds}</td>\n</tr>\n"
          fd.write(str)
    end
@@ -440,8 +431,6 @@ HTML
    test_totals = totals['Test Count'] + totals['Test Skip Count']
    sub_totals = "<tr class=\"tr_header\">\n"+
       "\t<td>Totals:</td>\n"+
-      "\t<td>#{totals['Test Count']}</td>\n"+
-      "\t<td>#{totals['Test Skip Count']}</td>\n"+
       "\t<td>#{totals['Test Failure Count']}</td>\n"+
       "\t<td>#{totals['Test CSS Error Count']}</td>\n"+
       "\t<td>#{totals['Test JavaScript Error Count']}</td>\n"+
@@ -449,12 +438,11 @@ HTML
       "\t<td>#{totals['Test Event Count']}</td>\n"+
       "\t<td>#{totals['Test Assert Count']}</td>\n"+
       "\t<td>#{totals['Test Exceptions']}</td>\n"+
-      "\t<td>#{totals['Test Major Exceptions']}</td>\n"+
       "\t<td>#{hours}:#{minutes}:#{seconds}</td>\n"+
-      "</tr>\n" +
-      "<tr class=\"tr_header\">\n"+
-      "\t<td>Total Test Count:</td>\n"+
-      "\t<td colspan=\"2\">#{test_totals}</td>\n</tr>\n"
+      "</tr>\n"
+#      "<tr class=\"tr_header\">\n"+
+#      "\t<td>Total Test Count:</td>\n"+
+#      "\t<td colspan=\"2\">#{test_totals}</td>\n</tr>\n"
 
    fd.write(sub_totals)
    fd.write("</table>\n</body>\n</html>\n")