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
 import contextlib
 import itertools
 import logging
 import os
 import shutil
 import signal
 import sys
+import tempfile
 import threading
 import traceback
 import unittest
 
 # Import _strptime before threaded code. datetime.datetime.strptime is
 # threadsafe except for the initial import of the _strptime module.
 # See http://crbug.com/724524 and https://bugs.python.org/issue7980.
 import _strptime  # pylint: disable=unused-import
 
 from pylib.constants import host_paths
 
 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 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 pylib.utils import test_output_saver_factory
 
 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'))
 
 
 def AddTestLauncherOptions(parser):
   """Adds arguments mirroring //base/test/launcher.
@@ skipping 79 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 624 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.
 
+  test_output_saver = test_output_saver_factory.CreateTestOutputSaver(args)
   env = environment_factory.CreateEnvironment(args, infra_error)
   test_instance = test_instance_factory.CreateTestInstance(args, infra_error)
   test_run = test_run_factory.CreateTestRun(
-      args, env, test_instance, infra_error)
+      args, env, test_instance, test_output_saver, infra_error)
 
   ### 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
@@ skipping 43 matching lines @@
           all_pass += 1
 
       logging.critical('%s of %s tests passed in all %s runs',
                        str(all_pass),
                        str(tot_tests),
                        str(iteration_count))
 
   if args.command == 'perf' and (args.steps or args.single_step):
     return 0
 
+  if args.local_output:

[jbudorick, 2017/06/20 14:12:55]

We won't write local output on exception w/ this.

[mikecase (-- gone --), 2017/07/10 17:11:11]

Like, if the test_runner itself throws an exception? hmmm, maybe I should put
this in a finally block?

+    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)
+    with tempfile.NamedTemporaryFile() as html_tmp:
+      html_tmp.write(result_html_string)
+      html_tmp.flush()
+      link = test_output_saver.Save(
+          html_tmp.name,
+          'test_results_presentation.html',
+          'test_results_presentation',
+          test_output_saver_factory.Datatype.HTML)
+      logging.critical('TEST RESULTS: %s', link)
+
   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():
     reraiser_thread.LogThreadStack(thread)
 
 
 def main():
@@ skipping 69 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())