Add support for parallel presubmit unit testing.

presubmit_canned_checks.py

 # Copyright (c) 2012 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.
 
 """Generic presubmit checks that can be reused by other presubmit checks."""
 
 import os as _os
 _HERE = _os.path.dirname(_os.path.abspath(__file__))
 
 
@@ skipping 465 matching lines @@
       connection.close()
       if input_api.re.match(closed, status):
         long_text = status + '\n' + url
         return [output_api.PresubmitError('The tree is closed.',
                                           long_text=long_text)]
   except IOError as e:
     return [output_api.PresubmitError('Error fetching tree status.',
                                       long_text=str(e))]
   return []
 
-
-def RunUnitTestsInDirectory(
+def GetUnitTestsInDirectory(
     input_api, output_api, directory, whitelist=None, blacklist=None):
   """Lists all files in a directory and runs them. Doesn't recurse.
 
   It's mainly a wrapper for RunUnitTests. USe whitelist and blacklist to filter
   tests accordingly.
   """
   unit_tests = []
   test_path = input_api.os_path.abspath(
       input_api.os_path.join(input_api.PresubmitLocalPath(), directory))
 
@@ skipping 12 matching lines @@
       continue
     unit_tests.append(input_api.os_path.join(directory, filename))
     to_run += 1
   input_api.logging.debug('Found %d files, running %d' % (found, to_run))
   if not to_run:
     return [
         output_api.PresubmitPromptWarning(
           'Out of %d files, found none that matched w=%r, b=%r in directory %s'
           % (found, whitelist, blacklist, directory))
     ]
-  return RunUnitTests(input_api, output_api, unit_tests)
+  return GetUnitTests(input_api, output_api, unit_tests)
 
 
-def RunUnitTests(input_api, output_api, unit_tests):
+def GetUnitTests(input_api, output_api, unit_tests):
   """Runs all unit tests in a directory.
 
   On Windows, sys.executable is used for unit tests ending with ".py".
   """
   # We don't want to hinder users from uploading incomplete patches.
   if input_api.is_committing:
     message_type = output_api.PresubmitError
   else:
     message_type = output_api.PresubmitPromptWarning
 
   results = []
   for unit_test in unit_tests:
     cmd = []
     if input_api.platform == 'win32' and unit_test.endswith('.py'):
       # Windows needs some help.
       cmd = [input_api.python_executable]
     cmd.append(unit_test)
     if input_api.verbose:
       print('Running %s' % unit_test)
       cmd.append('--verbose')
-    try:
-      if input_api.verbose:
-        input_api.subprocess.check_call(cmd, cwd=input_api.PresubmitLocalPath())
-      else:
-        input_api.subprocess.check_output(
-            cmd,
-            stderr=input_api.subprocess.STDOUT,
-            cwd=input_api.PresubmitLocalPath())
-    except (OSError, input_api.subprocess.CalledProcessError), e:
-      results.append(message_type('%s failed!\n%s' % (unit_test, e)))
+    results.append(input_api.Command(
+        name=unit_test,
+        cmd=cmd,
+        kwargs={'cwd': input_api.PresubmitLocalPath()},
+        message=message_type))
   return results
 
-
-def RunPythonUnitTests(input_api, output_api, unit_tests):
+def GetPythonUnitTests(input_api, output_api, unit_tests):
   """Run the unit tests out of process, capture the output and use the result
   code to determine success.
 
   DEPRECATED.
   """
   # We don't want to hinder users from uploading incomplete patches.
   if input_api.is_committing:
     message_type = output_api.PresubmitError
   else:
     message_type = output_api.PresubmitNotifyResult
@@ skipping 15 matching lines @@
       unit_test = input_api.os_path.basename(unit_test)
       env = input_api.environ.copy()
       # At least on Windows, it seems '.' must explicitly be in PYTHONPATH
       backpath = [
           '.', input_api.os_path.pathsep.join(['..'] * (cwd.count('/') + 1))
         ]
       if env.get('PYTHONPATH'):
         backpath.append(env.get('PYTHONPATH'))
       env['PYTHONPATH'] = input_api.os_path.pathsep.join((backpath))
     cmd = [input_api.python_executable, '-m', '%s' % unit_test]
-    try:
-      input_api.subprocess.check_output(
-          cmd, stderr=input_api.subprocess.STDOUT, cwd=cwd, env=env)
-    except (OSError, input_api.subprocess.CalledProcessError), e:
-      results.append(message_type('%s failed!\n%s' % (unit_test_name, e)))
+    results.append(input_api.Command(
+        name=unit_test_name,
+        cmd=cmd,
+        kwargs={'env': env, 'cwd': cwd},
+        message=message_type))
   return results
 
 
+def RunUnitTestsInDirectory(input_api, *args, **kwargs):
+  """Run tests in a directory serially.
+
+  For better performance, use GetUnitTestsInDirectory and then
+  pass to input_api.RunTests.
+  """
+  return input_api.RunTests(
+      GetUnitTestsInDirectory(input_api, *args, **kwargs), False)
+
+
+def RunUnitTests(input_api, *args, **kwargs):
+  """Run tests serially.
+
+  For better performance, use GetUnitTests and then pass to
+  input_api.RunTests.
+  """
+  return input_api.RunTests(GetUnitTests(input_api, *args, **kwargs), False)
+
+
+def RunPythonUnitTests(input_api, *args, **kwargs):
+  """Run python tests in a directory serially.
+
+  DEPRECATED
+  """
+  return input_api.RunTests(
+      GetPythonUnitTests(input_api, *args, **kwargs), False)
+
+
 def _FetchAllFiles(input_api, white_list, black_list):
   """Hack to fetch all files."""
   # We cannot use AffectedFiles here because we want to test every python
   # file on each single python change. It's because a change in a python file
   # can break another unmodified file.
   # Use code similar to InputApi.FilterSourceFile()
   def Find(filepath, filters):
     for item in filters:
       if input_api.re.match(item, filepath):
         return True
     return False
 
   files = []
   path_len = len(input_api.PresubmitLocalPath())
   for dirpath, dirnames, filenames in input_api.os_walk(
       input_api.PresubmitLocalPath()):
     # Passes dirnames in black list to speed up search.
     for item in dirnames[:]:
       filepath = input_api.os_path.join(dirpath, item)[path_len + 1:]
       if Find(filepath, black_list):
         dirnames.remove(item)
     for item in filenames:
       filepath = input_api.os_path.join(dirpath, item)[path_len + 1:]
       if Find(filepath, white_list) and not Find(filepath, black_list):
         files.append(filepath)
   return files
 
 
-def RunPylint(input_api, output_api, white_list=None, black_list=None,
+def GetPylint(input_api, output_api, white_list=None, black_list=None,
               disabled_warnings=None, extra_paths_list=None):
   """Run pylint on python files.
 
   The default white_list enforces looking only at *.py files.
   """
   white_list = tuple(white_list or ('.*\.py$',))
   black_list = tuple(black_list or input_api.DEFAULT_BLACK_LIST)
   extra_paths_list = extra_paths_list or []
 
   if input_api.is_committing:
@@ skipping 22 matching lines @@
     input_api.logging.info('Skipping pylint: no matching changes.')
     return []
 
   extra_args = ['--rcfile=%s' % input_api.os_path.join(_HERE, 'pylintrc')]
   if disabled_warnings:
     extra_args.extend(['-d', ','.join(disabled_warnings)])
 
   files = _FetchAllFiles(input_api, white_list, black_list)
   if not files:
     return []
+  files.sort()
 
   input_api.logging.info('Running pylint on %d files', len(files))
   input_api.logging.debug('Running pylint on: %s', files)
   # Copy the system path to the environment so pylint can find the right
   # imports.
   env = input_api.environ.copy()
   import sys
   env['PYTHONPATH'] = input_api.os_path.pathsep.join(
       extra_paths_list + sys.path).encode('utf8')
 
-  def run_lint(files):
-    # We can't import pylint directly due to licensing issues, so we run
-    # it in another process. Windows needs help running python files so we
-    # explicitly specify the interpreter to use. It also has limitations on
-    # the size of the command-line, so we pass arguments via a pipe.
-    command = [input_api.python_executable,
-               input_api.os_path.join(_HERE, 'third_party', 'pylint.py'),
-               '--args-on-stdin']
-    try:
-      child = input_api.subprocess.Popen(command, env=env,
-          stdin=input_api.subprocess.PIPE)
+  def GetPylintCmd(files):
+    # Windows needs help running python files so we explicitly specify
+    # the interpreter to use. It also has limitations on the size of
+    # the command-line, so we pass arguments via a pipe.
+    if len(files) == 1:
+      description = files[0]
+    else:
+      description = '%s files' % len(files)
 
-      # Dump the arguments to the child process via a pipe.
-      for filename in files:
-        child.stdin.write(filename + '\n')
-      for arg in extra_args:
-        child.stdin.write(arg + '\n')
-      child.stdin.close()
+    return input_api.Command(
+        name='Pylint (%s)' % description,
+        cmd=[input_api.python_executable,
+             input_api.os_path.join(_HERE, 'third_party', 'pylint.py'),
+             '--args-on-stdin'],
+        kwargs={'env': env, 'stdin': '\n'.join(files + extra_args)},
+        message=error_type)
 
-      child.communicate()
-      return child.returncode
-    except OSError:
-      return 'Pylint failed!'
-
-  result = None
   # Always run pylint and pass it all the py files at once.
   # Passing py files one at time is slower and can produce
   # different results.  input_api.verbose used to be used
   # to enable this behaviour but differing behaviour in
   # verbose mode is not desirable.
   # Leave this unreachable code in here so users can make
   # a quick local edit to diagnose pylint issues more
   # easily.
   if True:
-    print('Running pylint on %d files.' % len(files))
-    result = run_lint(sorted(files))
+    return [GetPylintCmd(files)]
   else:
-    for filename in sorted(files):
-      print('Running pylint on %s' % filename)
-      result = run_lint([filename]) or result
-  if isinstance(result, basestring):
-    return [error_type(result)]
-  elif result:
-    return [error_type('Fix pylint errors first.')]
-  return []
+    return map(GetPylintCmd, files)
+
+
+def RunPylint(input_api, *args, **kwargs):
+  """Legacy presubmit function.
+
+  For better performance, get all tests and then pass to
+  input_api.RunTests.
+  """
+  return input_api.RunTests(GetPylint(input_api, *args, **kwargs), False)
 
 
 # TODO(dpranke): Get the host_url from the input_api instead
 def CheckRietveldTryJobExecution(dummy_input_api, dummy_output_api,
                                  dummy_host_url, dummy_platforms,
                                  dummy_owner):
   # Temporarily 'fix' the check while the Rietveld API is being upgraded to
   # something sensible.
   return []
 
@@ skipping 269 matching lines @@
     snapshot("checking description")
     results.extend(input_api.canned_checks.CheckChangeHasDescription(
         input_api, output_api))
     results.extend(input_api.canned_checks.CheckDoNotSubmitInDescription(
         input_api, output_api))
     snapshot("checking do not submit in files")
     results.extend(input_api.canned_checks.CheckDoNotSubmitInFiles(
         input_api, output_api))
   snapshot("done")
   return results