Modified output format to be accepted by Pulse. Updated DEPS to include newer...

tests/selenium/test_runner.py

 #!/usr/bin/python2.4
 # Copyright 2009, Google Inc.
 # All rights reserved.
 #
 # Redistribution and use in source and binary forms, with or without
 # modification, are permitted provided that the following conditions are
 # met:
 #
 #     * Redistributions of source code must retain the above copyright
 # notice, this list of conditions and the following disclaimer.
@@ skipping 56 matching lines @@
     self.write("\n")
   def get(self):
     get_data = self.data
     self.data = ""
     return get_data
 
 class TestResult(unittest.TestResult):
   """A specialized class that prints formatted text results to a stream.
 
   """
-  separator1 = "=" * 70
-  separator2 = "-" * 70
+  separator1 = "=" * 30
+  separator2 = "-" * 30
 
-  def __init__(self, stream, browser):
+  def __init__(self, stream, browser, verbose):
     unittest.TestResult.__init__(self)
     self.stream = stream
     # Dictionary of start times
     self.start_times = {}
     # Dictionary of results
     self.results = {}
     self.browser = browser
+    self.verbose = verbose
 
   def getDescription(self, test):
     """Gets description of test."""
     return test.shortDescription() or str(test)
 
   def startTest(self, test):
     """Starts test."""
     # Records the start time
     self.start_times[test] = time.time()
     # Default testresult if success not called
     self.results[test] = "FAIL"
     unittest.TestResult.startTest(self, test)
-    self.stream.writeln()
-    self.stream.writeln(self.separator2)
-    self.stream.write(self.getDescription(test))
-    self.stream.writeln(" ... ")
+    if self.verbose:
+      self.stream.writeln()
+      self.stream.writeln(self.separator2)
+      self.stream.write(self.getDescription(test))
+      self.stream.writeln(" ... ")
 
   def stopTest(self, test):
     """Called when test is ended."""
     time_taken = time.time() - self.start_times[test]
     result = self.results[test]
     self.stream.writeln("SELENIUMRESULT %s <%s> [%.3fs]: %s"
                         % (test, self.browser, time_taken, result))
+    self.printErrors()
 
   def addSuccess(self, test):
     """Adds success result to TestResult."""
     unittest.TestResult.addSuccess(self, test)
     self.results[test] = "PASS"
 
   def addError(self, test, err):
     """Adds error result to TestResult."""
     unittest.TestResult.addError(self, test, err)
     self.results[test] = "FAIL"
 
   def addFailure(self, test, err):
     """Adds failure result to TestResult."""
     unittest.TestResult.addFailure(self, test, err)
     self.results[test] = "FAIL"
 
   def noResponse(self, test):
     """Configures the result for a test that did not respond."""
     self.results[test] = "FAIL"
     self.testsRun += 1
     self.errors.append("No response from test")
 
-    self.stream.writeln()
-    self.stream.writeln(self.separator2)
-    self.stream.write(self.getDescription(test))
-    self.stream.writeln(" ... ")
-    self.stream.writeln("SELENIUMRESULT %s <%s> [?s]: FAIL (HUNG?)"
+    if self.verbose:
+      self.stream.writeln()
+      self.stream.writeln(self.separator2)
+      self.stream.write(self.getDescription(test))
+      self.stream.writeln(" ... ")
+    self.stream.writeln("SELENIUMRESULT %s <%s> [0s]: FAIL"
                         % (test, self.browser))
-    self.stream.writeln()
+    self.stream.writeln("Test was aborted due to timeout")
 
   def printErrors(self):
     """Prints all errors and failures."""
-    self.stream.writeln()
-    self.printErrorList("ERROR", self.errors)
-    self.printErrorList("FAIL", self.failures)
+    if self.errors:
+      self.printErrorList("ERROR", self.errors)
+    if self.failures:
+      self.printErrorList("FAIL", self.failures)
 
   def printErrorList(self, flavour, errors):
     """Prints a given list of errors."""
     for test, err in errors:
       self.stream.writeln("%s:" % flavour)
       self.stream.writeln("%s" % err)
 
   def printAll(self, stream):
     """Prints the entire stream to the given stream."""
     stream.write(self.stream.data)
@@ skipping 12 matching lines @@
 
 class TestRunnerThread(threading.Thread):
   """Abstract test runner class.  Launches its own thread for running tests.
   Formats test results.
 
   Members:
     completely_done_event: event that occurs just before thread exits.
     test: the currently running test.
     browser: selenium_name of browser that will be tested.
   """
-  def __init__(self):
+  def __init__(self, verbose):
     threading.Thread.__init__(self)
     # This thread is a daemon so that the program can exit even if the
     # thread has not finished.
     self.setDaemon(True)
     self.completely_done_event = threading.Event()
-    self.test_copy = None
+    self.test = None
     self.browser = "default_browser"
+    self.verbose = verbose
 
   def IsCompletelyDone(self):
     """Returns true if this test runner is completely done."""
     return self.completely_done_event.isSet()
 
   def run(self):
     pass
     
   def SetBrowser(self, browser):
     """Sets the browser name."""
     self.browser = browser
 
   def GetNoResponseResult(self):
     """Returns a generic no response result for last test."""
     result = TestResult(StringBuffer(), self.browser)
     result.noResponse(self.test)
     return result
 
   def RunTest(self, test):
     "Run the given test case or test suite."
     self.test = test
 
     stream = StringBuffer()
-    result = TestResult(stream, self.browser)
+    result = TestResult(stream, self.browser, self.verbose)
     startTime = time.time()
     test(result)
     stopTime = time.time()
     timeTaken = stopTime - startTime
-    result.printErrors()
+    if self.verbose:
+      result.printErrors()
     run = result.testsRun
-    stream.writeln("Took %.2fs" % timeTaken)
-    stream.writeln()
     return result
   
 
 class PDiffTestRunner(TestRunnerThread):
   """Test runner for Perceptual Diff tests. Polls a test queue and launches
   given tests. Adds result to given queue.
 
   Members:
     pdiff_queue: list of tests to run, when they arrive.
     result_queue: queue of our tests results.
     browser: selenium name of browser to be tested.
     end_testing_event: event that occurs when we are guaranteed no more tests
       will be added to the queue.
   """
-  def __init__(self, pdiff_queue, result_queue, browser):
-    TestRunnerThread.__init__(self)
+  def __init__(self, pdiff_queue, result_queue, browser, verbose):
+    TestRunnerThread.__init__(self, verbose)
     self.pdiff_queue = pdiff_queue
     self.result_queue = result_queue
     self.browser = browser
     
     self.end_testing_event = threading.Event()
 
   def EndTesting(self):
     """Called to notify thread that no more tests will be added to the test
     queue."""
     self.end_testing_event.set()
@@ skipping 27 matching lines @@
     can_continue_lock: lock for |can_continue|.
     can_continue: is True when main thread permits the test runner to continue.
     sel_builder: builder that constructs new selenium sessions, as needed.
     browser: selenium name of browser to be tested.
     session: current selenium session being used in tests, can be None.
     test_queue: queue of tests to run.
     pdiff_queue: queue of perceptual diff tests to run. We add a perceptual
       diff test to the queue when the related selenium test passes.
     deadline: absolute time of when the test should be done.
   """
-  def __init__(self, sel_builder, browser, test_queue, pdiff_queue):
-    TestRunnerThread.__init__(self)
+  def __init__(self, sel_builder, browser, test_queue, pdiff_queue, verbose):
+    TestRunnerThread.__init__(self, verbose)
 
     # Synchronization.
     self.testing_event = threading.Event()
     self.finished_event = threading.Event()
     self.can_continue_lock = threading.Lock()
     self.can_continue = False
     
     # Selenium variables.
     self.sel_builder = sel_builder
     self.browser = browser
@@ skipping 96 matching lines @@
             # Add the dependent perceptual diff test.
             self.pdiff_queue.put(pdiff_test)       
         
       except Queue.Empty:
         break
 
     self._StopSession()      
     self.completely_done_event.set()