Add local results details pages.

build/android/test_runner.py

 #!/usr/bin/env python
 #
 # Copyright 2013 The Chromium Authors. All rights reserved.
 # Use of this source code is governed by a BSD-style license that can be
 # found in the LICENSE file.
 
 """Runs all types of tests from one unified interface."""
 
 import argparse
 import collections
@@ skipping 18 matching lines @@
 if host_paths.DEVIL_PATH not in sys.path:
   sys.path.append(host_paths.DEVIL_PATH)
 
 from devil import base_error
 from devil.utils import reraiser_thread
 from devil.utils import run_tests_helper
 
 from pylib import constants
 from pylib.base import base_test_result
 from pylib.base import environment_factory
+from pylib.base import output_manager
+from pylib.base import output_manager_factory
 from pylib.base import test_instance_factory
 from pylib.base import test_run_factory
 from pylib.results import json_results
 from pylib.results import report_results
+from pylib.results.presentation import test_results_presentation
 from pylib.utils import logdog_helper
 from pylib.utils import logging_utils
 
 from py_utils import contextlib_ext
 
 
 _DEVIL_STATIC_CONFIG_FILE = os.path.abspath(os.path.join(
     host_paths.DIR_SOURCE_ROOT, 'build', 'android', 'devil_config.json'))
 
 
@@ skipping 93 matching lines @@
       help='Run the test scripts in platform mode, which '
            'conceptually separates the test runner from the '
            '"device" (local or remote, real or emulated) on '
            'which the tests are running. [experimental]')
 
   parser.add_argument(
       '-e', '--environment',
       default='local', choices=constants.VALID_ENVIRONMENTS,
       help='Test environment to run in (default: %(default)s).')
 
+  parser.add_argument(
+      '--local-output',
+      action='store_true',
+      help='Whether to archive test output locally and generate '
+           'a local results detail page.')
+
   class FastLocalDevAction(argparse.Action):
     def __call__(self, parser, namespace, values, option_string=None):
       namespace.verbose_count = max(namespace.verbose_count, 1)
       namespace.num_retries = 0
       namespace.enable_device_cache = True
       namespace.enable_concurrent_adb = True
       namespace.skip_clear_data = True
       namespace.extract_test_list_from_filter = True
 
   parser.add_argument(
@@ skipping 656 matching lines @@
             logging.critical(
                 'Logcat: %s', logdog_helper.get_viewer_url('unified_logcats'))
 
 
   logcats_uploader = contextlib_ext.Optional(
       upload_logcats_file(),
       'upload_logcats_file' in args and args.upload_logcats_file)
 
   ### Set up test objects.
 
-  env = environment_factory.CreateEnvironment(args, infra_error)
+  out_manager = output_manager_factory.CreateOutputManager(args)
+  env = environment_factory.CreateEnvironment(
+      args, out_manager, infra_error)
   test_instance = test_instance_factory.CreateTestInstance(args, infra_error)
   test_run = test_run_factory.CreateTestRun(
       args, env, test_instance, infra_error)
 
   ### Run.
+  with out_manager:
+    with json_writer, logcats_uploader, env, test_instance, test_run:
 
-  with json_writer, logcats_uploader, env, test_instance, test_run:
+      repetitions = (xrange(args.repeat + 1) if args.repeat >= 0
+                     else itertools.count())
+      result_counts = collections.defaultdict(
+          lambda: collections.defaultdict(int))
+      iteration_count = 0
+      for _ in repetitions:
+        raw_results = test_run.RunTests()
+        if not raw_results:
+          continue
 
-    repetitions = (xrange(args.repeat + 1) if args.repeat >= 0
-                   else itertools.count())
-    result_counts = collections.defaultdict(
-        lambda: collections.defaultdict(int))
-    iteration_count = 0
-    for _ in repetitions:
-      raw_results = test_run.RunTests()
-      if not raw_results:
-        continue
+        all_raw_results.append(raw_results)
 
-      all_raw_results.append(raw_results)
+        iteration_results = base_test_result.TestRunResults()
+        for r in reversed(raw_results):
+          iteration_results.AddTestRunResults(r)
+        all_iteration_results.append(iteration_results)
 
-      iteration_results = base_test_result.TestRunResults()
-      for r in reversed(raw_results):
-        iteration_results.AddTestRunResults(r)
-      all_iteration_results.append(iteration_results)
+        iteration_count += 1
+        for r in iteration_results.GetAll():
+          result_counts[r.GetName()][r.GetType()] += 1
+        report_results.LogFull(
+            results=iteration_results,
+            test_type=test_instance.TestType(),
+            test_package=test_run.TestPackage(),
+            annotation=getattr(args, 'annotations', None),
+            flakiness_server=getattr(args, 'flakiness_dashboard_server',
+                                     None))
+        if args.break_on_failure and not iteration_results.DidRunPass():
+          break
 
-      iteration_count += 1
-      for r in iteration_results.GetAll():
-        result_counts[r.GetName()][r.GetType()] += 1
-      report_results.LogFull(
-          results=iteration_results,
-          test_type=test_instance.TestType(),
-          test_package=test_run.TestPackage(),
-          annotation=getattr(args, 'annotations', None),
-          flakiness_server=getattr(args, 'flakiness_dashboard_server',
-                                   None))
-      if args.break_on_failure and not iteration_results.DidRunPass():
-        break
+      if iteration_count > 1:
+        # display summary results
+        # only display results for a test if at least one test did not pass
+        all_pass = 0
+        tot_tests = 0
+        for test_name in result_counts:
+          tot_tests += 1
+          if any(result_counts[test_name][x] for x in (
+              base_test_result.ResultType.FAIL,
+              base_test_result.ResultType.CRASH,
+              base_test_result.ResultType.TIMEOUT,
+              base_test_result.ResultType.UNKNOWN)):
+            logging.critical(
+                '%s: %s',
+                test_name,
+                ', '.join('%s %s' % (str(result_counts[test_name][i]), i)
+                          for i in base_test_result.ResultType.GetTypes()))
+          else:
+            all_pass += 1
 
-    if iteration_count > 1:
-      # display summary results
-      # only display results for a test if at least one test did not pass
-      all_pass = 0
-      tot_tests = 0
-      for test_name in result_counts:
-        tot_tests += 1
-        if any(result_counts[test_name][x] for x in (
-            base_test_result.ResultType.FAIL,
-            base_test_result.ResultType.CRASH,
-            base_test_result.ResultType.TIMEOUT,
-            base_test_result.ResultType.UNKNOWN)):
-          logging.critical(
-              '%s: %s',
-              test_name,
-              ', '.join('%s %s' % (str(result_counts[test_name][i]), i)
-                        for i in base_test_result.ResultType.GetTypes()))
-        else:
-          all_pass += 1
+        logging.critical('%s of %s tests passed in all %s runs',
+                         str(all_pass),
+                         str(tot_tests),
+                         str(iteration_count))
 
-      logging.critical('%s of %s tests passed in all %s runs',
-                       str(all_pass),
-                       str(tot_tests),
-                       str(iteration_count))
+    if args.local_output and args.json_results_file:
+      with out_manager.ArchivedTempfile(
+          'test_results_presentation.html',
+          'test_results_presentation',
+          output_manager.Datatype.HTML) as results_detail_file:
+        result_html_string, _, _ = test_results_presentation.result_details(
+            json_path=args.json_results_file,
+            test_name=args.command,
+            cs_base_url='http://cs.chromium.org',
+            local_output=True)
+        results_detail_file.write(result_html_string)
+        results_detail_file.flush()
+      logging.critical('TEST RESULTS: %s', results_detail_file.Link())
 
   if args.command == 'perf' and (args.steps or args.single_step):
     return 0
 
   return (0 if all(r.DidRunPass() for r in all_iteration_results)
           else constants.ERROR_EXIT_CODE)
 
 
 def DumpThreadStacks(_signal, _frame):
   for thread in threading.enumerate():
@@ skipping 81 matching lines @@
     if e.is_infra_error:
       return constants.INFRA_EXIT_CODE
     return constants.ERROR_EXIT_CODE
   except: # pylint: disable=W0702
     logging.exception('Unrecognized error occurred.')
     return constants.ERROR_EXIT_CODE
 
 
 if __name__ == '__main__':
   sys.exit(main())