Add support for parallel presubmit unit testing.

tests/presubmit_unittest.py

 #!/usr/bin/env python
 # 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.
 
 """Unit tests for presubmit_support.py and presubmit_canned_checks.py."""
 
 # pylint: disable=E1101,E1103
 
 import logging
 import os
 import StringIO
-import subprocess
 import sys
 import time
+import unittest
 
 _ROOT = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
 sys.path.insert(0, _ROOT)
 
 from testing_support.super_mox import mox, SuperMoxTestBase
 
 import owners
+import subprocess2 as subprocess
 import presubmit_support as presubmit
 import rietveld
 
 # Shortcut.
 presubmit_canned_checks = presubmit.presubmit_canned_checks
 
 
 # Access to a protected member XXX of a client class
 # pylint: disable=W0212
 
@@ skipping 117 matching lines @@
 
 class PresubmitUnittest(PresubmitTestsBase):
   """General presubmit_support.py tests (excluding InputApi and OutputApi)."""
 
   _INHERIT_SETTINGS = 'inherit-review-settings-ok'
 
   def testMembersChanged(self):
     self.mox.ReplayAll()
     members = [
       'AffectedFile', 'Change', 'DoGetTrySlaves', 'DoPresubmitChecks',
-      'GetTrySlavesExecuter', 'GitAffectedFile',
+      'GetTrySlavesExecuter', 'GitAffectedFile', 'CallCommand', 'CommandData',
       'GitChange', 'InputApi', 'ListRelevantPresubmitFiles', 'Main',
       'NonexistantCannedCheckFilter', 'OutputApi', 'ParseFiles',
       'PresubmitFailure', 'PresubmitExecuter', 'PresubmitOutput', 'ScanSubDirs',
       'SvnAffectedFile', 'SvnChange', 'cPickle', 'cpplint', 'cStringIO',
       'contextlib', 'canned_check_filter', 'fix_encoding', 'fnmatch',
       'gclient_utils', 'glob', 'inspect', 'json', 'load_files', 'logging',
       'marshal', 'normpath', 'optparse', 'os', 'owners', 'pickle',
       'presubmit_canned_checks', 'random', 're', 'rietveld', 'scm',
       'subprocess', 'sys', 'tempfile', 'time', 'traceback', 'types', 'unittest',
-      'urllib2', 'warn',
+      'urllib2', 'warn', 'collections', 'multiprocessing',
     ]
     # If this test fails, you should add the relevant test.
     self.compareMembers(presubmit, members)
 
   def testCannedCheckFilter(self):
     canned = presubmit.presubmit_canned_checks
     orig = canned.CheckOwners
     with presubmit.canned_check_filter(['CheckOwners']):
       self.assertNotEqual(canned.CheckOwners, orig)
       self.assertEqual(canned.CheckOwners(None, None), [])
@@ skipping 693 matching lines @@
 
 class InputApiUnittest(PresubmitTestsBase):
   """Tests presubmit.InputApi."""
   def testMembersChanged(self):
     self.mox.ReplayAll()
     members = [
       'AbsoluteLocalPaths', 'AffectedFiles', 'AffectedSourceFiles',
       'AffectedTextFiles',
       'DEFAULT_BLACK_LIST', 'DEFAULT_WHITE_LIST',
       'DepotToLocalPath', 'FilterSourceFile', 'LocalPaths',
-      'LocalToDepotPath',
+      'LocalToDepotPath', 'Command', 'RunTests',
       'PresubmitLocalPath', 'ReadFile', 'RightHandSideLines', 'ServerPaths',
       'basename', 'cPickle', 'cpplint', 'cStringIO', 'canned_checks', 'change',
       'environ', 'glob', 'host_url', 'is_committing', 'json', 'logging',
       'marshal', 'os_listdir', 'os_walk', 'os_path', 'owners_db', 'pickle',
       'platform', 'python_executable', 're', 'rietveld', 'subprocess', 'tbr',
       'tempfile', 'time', 'traceback', 'unittest', 'urllib2', 'version',
       'verbose',
     ]
     # If this test fails, you should add the relevant test.
     self.compareMembers(
@@ skipping 583 matching lines @@
     self.assertEquals('foo2', change.DescriptionText())
     self.assertEquals('foo3', change.author_email)
     self.assertEquals('ro', change.DRU)
     self.assertEquals(3, change.issue)
     self.assertEquals(5, change.patchset)
     self.assertEquals(self.fake_root_dir, change.RepositoryRoot())
     self.assertEquals(1, len(change.AffectedFiles(include_dirs=True)))
     self.assertEquals('Y', change.AffectedFiles(include_dirs=True)[0].Action())
 
 
+def CommHelper(input_api, cmd, ret=None, **kwargs):
+  ret = ret or (('', None), 0)
+  input_api.subprocess.communicate(
+      cmd, stdout=subprocess.PIPE, stderr=subprocess.STDOUT, **kwargs
+      ).AndReturn(ret)
+
+
 class CannedChecksUnittest(PresubmitTestsBase):
   """Tests presubmit_canned_checks.py."""
 
   def MockInputApi(self, change, committing):
     # pylint: disable=R0201
     input_api = self.mox.CreateMock(presubmit.InputApi)
     input_api.cStringIO = presubmit.cStringIO
     input_api.json = presubmit.json
     input_api.logging = logging
     input_api.os_listdir = self.mox.CreateMockAnything()
     input_api.os_walk = self.mox.CreateMockAnything()
     input_api.os_path = presubmit.os.path
     input_api.re = presubmit.re
     input_api.rietveld = self.mox.CreateMock(rietveld.Rietveld)
     input_api.traceback = presubmit.traceback
     input_api.urllib2 = self.mox.CreateMock(presubmit.urllib2)
     input_api.unittest = unittest
-    input_api.subprocess = self.mox.CreateMock(presubmit.subprocess)
+    input_api.subprocess = self.mox.CreateMock(subprocess)
+    presubmit.subprocess = input_api.subprocess
     class fake_CalledProcessError(Exception):
       def __str__(self):
         return 'foo'
     input_api.subprocess.CalledProcessError = fake_CalledProcessError
     input_api.verbose = False
 
     input_api.change = change
     input_api.host_url = 'http://localhost'
     input_api.is_committing = committing
     input_api.tbr = False
     input_api.python_executable = 'pyyyyython'
     input_api.platform = sys.platform
     input_api.time = time
     input_api.canned_checks = presubmit_canned_checks
+    input_api.Command = presubmit.CommandData
+    input_api.RunTests = presubmit.InputApi.RunTests
     return input_api
 
   def testMembersChanged(self):
     self.mox.ReplayAll()
     members = [
       'CheckBuildbotPendingBuilds',
       'CheckChangeHasBugField', 'CheckChangeHasDescription',
       'CheckChangeHasNoStrayWhitespace',
       'CheckChangeHasOnlyOneEol', 'CheckChangeHasNoCR',
       'CheckChangeHasNoCrAndHasOnlyOneEol', 'CheckChangeHasNoTabs',
       'CheckChangeTodoHasOwner',
       'CheckChangeHasQaField', 'CheckChangeHasTestedField',
       'CheckChangeHasTestField',
       'CheckChangeLintsClean',
       'CheckChangeSvnEolStyle',
       'CheckChangeWasUploaded',
       'CheckDoNotSubmit',
       'CheckDoNotSubmitInDescription', 'CheckDoNotSubmitInFiles',
       'CheckLongLines', 'CheckTreeIsOpen', 'PanProjectChecks',
       'CheckLicense',
       'CheckOwners',
       'CheckRietveldTryJobExecution',
       'CheckSingletonInHeaders',
       'CheckSvnModifiedDirectories',
       'CheckSvnForCommonMimeTypes', 'CheckSvnProperty',
       'RunPythonUnitTests', 'RunPylint',
       'RunUnitTests', 'RunUnitTestsInDirectory',
+      'GetPythonUnitTests', 'GetPylint',
+      'GetUnitTests', 'GetUnitTestsInDirectory',
     ]
     # If this test fails, you should add the relevant test.
     self.compareMembers(presubmit_canned_checks, members)
 
   def DescriptionTest(self, check, description1, description2, error_type,
                       committing):
     change1 = presubmit.Change(
         'foo1', description1, self.fake_root_dir, None, 0, 0, None)
     input_api1 = self.MockInputApi(change1, committing)
     change2 = presubmit.Change(
@@ skipping 553 matching lines @@
 
   def testRunPythonUnitTestsNoTest(self):
     input_api = self.MockInputApi(None, False)
     self.mox.ReplayAll()
     results = presubmit_canned_checks.RunPythonUnitTests(
         input_api, presubmit.OutputApi, [])
     self.assertEquals(results, [])
 
   def testRunPythonUnitTestsNonExistentUpload(self):
     input_api = self.MockInputApi(None, False)
-    input_api.subprocess.check_output(
-        ['pyyyyython', '-m', '_non_existent_module'], cwd=None, env=None,
-        stderr=input_api.subprocess.STDOUT).AndRaise(
-            input_api.subprocess.CalledProcessError())
+    CommHelper(input_api, ['pyyyyython', '-m', '_non_existent_module'],
+                    ret=(('foo', None), 1), cwd=None, env=None)
     self.mox.ReplayAll()
 
     results = presubmit_canned_checks.RunPythonUnitTests(
         input_api, presubmit.OutputApi, ['_non_existent_module'])
     self.assertEquals(len(results), 1)
     self.assertEquals(results[0].__class__,
                       presubmit.OutputApi.PresubmitNotifyResult)
 
   def testRunPythonUnitTestsNonExistentCommitting(self):
     input_api = self.MockInputApi(None, True)
-    input_api.subprocess.check_output(
-        ['pyyyyython', '-m', '_non_existent_module'], cwd=None, env=None,
-        stderr=input_api.subprocess.STDOUT).AndRaise(
-            input_api.subprocess.CalledProcessError())
+    CommHelper(input_api, ['pyyyyython', '-m', '_non_existent_module'],
+                    ret=(('foo', None), 1), cwd=None, env=None)
     self.mox.ReplayAll()
 
     results = presubmit_canned_checks.RunPythonUnitTests(
         input_api, presubmit.OutputApi, ['_non_existent_module'])
     self.assertEquals(len(results), 1)
     self.assertEquals(results[0].__class__, presubmit.OutputApi.PresubmitError)
 
   def testRunPythonUnitTestsFailureUpload(self):
     input_api = self.MockInputApi(None, False)
     input_api.unittest = self.mox.CreateMock(unittest)
     input_api.cStringIO = self.mox.CreateMock(presubmit.cStringIO)
-    input_api.subprocess.check_output(
-        ['pyyyyython', '-m', 'test_module'], cwd=None, env=None,
-        stderr=input_api.subprocess.STDOUT).AndRaise(
-            input_api.subprocess.CalledProcessError())
+    CommHelper(input_api, ['pyyyyython', '-m', 'test_module'],
+                    ret=(('foo', None), 1), cwd=None, env=None)
     self.mox.ReplayAll()
 
     results = presubmit_canned_checks.RunPythonUnitTests(
         input_api, presubmit.OutputApi, ['test_module'])
     self.assertEquals(len(results), 1)
     self.assertEquals(results[0].__class__,
                       presubmit.OutputApi.PresubmitNotifyResult)
-    self.assertEquals('test_module failed!\nfoo', results[0]._message)
+    self.assertEquals('test_module failed\nfoo', results[0]._message)
 
   def testRunPythonUnitTestsFailureCommitting(self):
     input_api = self.MockInputApi(None, True)
-    input_api.subprocess.check_output(
-        ['pyyyyython', '-m', 'test_module'], cwd=None, env=None,
-        stderr=input_api.subprocess.STDOUT).AndRaise(
-            input_api.subprocess.CalledProcessError())
+    CommHelper(input_api, ['pyyyyython', '-m', 'test_module'],
+                    ret=(('foo', None), 1), cwd=None, env=None)
     self.mox.ReplayAll()
 
     results = presubmit_canned_checks.RunPythonUnitTests(
         input_api, presubmit.OutputApi, ['test_module'])
     self.assertEquals(len(results), 1)
     self.assertEquals(results[0].__class__, presubmit.OutputApi.PresubmitError)
-    self.assertEquals('test_module failed!\nfoo', results[0]._message)
+    self.assertEquals('test_module failed\nfoo', results[0]._message)
 
   def testRunPythonUnitTestsSuccess(self):
     input_api = self.MockInputApi(None, False)
     input_api.cStringIO = self.mox.CreateMock(presubmit.cStringIO)
     input_api.unittest = self.mox.CreateMock(unittest)
-    input_api.subprocess.check_output(
-        ['pyyyyython', '-m', 'test_module'], cwd=None, env=None,
-        stderr=input_api.subprocess.STDOUT)
+    CommHelper(input_api, ['pyyyyython', '-m', 'test_module'],
+                    cwd=None, env=None)
     self.mox.ReplayAll()
 
     results = presubmit_canned_checks.RunPythonUnitTests(
         input_api, presubmit.OutputApi, ['test_module'])
     self.assertEquals(len(results), 0)
 
   def testCannedRunPylint(self):
     input_api = self.MockInputApi(None, True)
     input_api.environ = self.mox.CreateMock(os.environ)
     input_api.environ.copy().AndReturn({})
     input_api.AffectedSourceFiles(mox.IgnoreArg()).AndReturn(True)
     input_api.PresubmitLocalPath().AndReturn('/foo')
     input_api.PresubmitLocalPath().AndReturn('/foo')
     input_api.os_walk('/foo').AndReturn([('/foo', [], ['file1.py'])])
     pylint = os.path.join(_ROOT, 'third_party', 'pylint.py')
     pylintrc = os.path.join(_ROOT, 'pylintrc')
 
-    # Create a mock Popen object, and set up its expectations.
-    child = self.mox.CreateMock(subprocess.Popen)
-    child.stdin = self.mox.CreateMock(file)
-    child.stdin.write('file1.py\n')
-    child.stdin.write('--rcfile=%s\n' % pylintrc)
-    child.stdin.close()
-    child.communicate()
-    child.returncode = 0
-
-    input_api.subprocess.Popen(['pyyyyython', pylint, '--args-on-stdin'],
-        env=mox.IgnoreArg(), stdin=subprocess.PIPE).AndReturn(child)
+    CommHelper(input_api,
+        ['pyyyyython', pylint, '--args-on-stdin'],
+        env=mox.IgnoreArg(), stdin='file1.py\n--rcfile=%s' % pylintrc)
     self.mox.ReplayAll()
 
     results = presubmit_canned_checks.RunPylint(
         input_api, presubmit.OutputApi)
     self.assertEquals([], results)
-    self.checkstdout('Running pylint on 1 files.\n')
+    self.checkstdout('')
 
   def testCheckBuildbotPendingBuildsBad(self):
     input_api = self.MockInputApi(None, True)
     connection = self.mox.CreateMockAnything()
     input_api.urllib2.urlopen('uurl').AndReturn(connection)
     connection.read().AndReturn('foo')
     connection.close()
     self.mox.ReplayAll()
 
     results = presubmit_canned_checks.CheckBuildbotPendingBuilds(
@@ skipping 221 matching lines @@
                            uncovered_files=set())
 
   def testCannedRunUnitTests(self):
     change = presubmit.Change(
         'foo1', 'description1', self.fake_root_dir, None, 0, 0, None)
     input_api = self.MockInputApi(change, False)
     input_api.verbose = True
     unit_tests = ['allo', 'bar.py']
     input_api.PresubmitLocalPath().AndReturn(self.fake_root_dir)
     input_api.PresubmitLocalPath().AndReturn(self.fake_root_dir)
-    input_api.subprocess.check_call(
-        ['allo', '--verbose'], cwd=self.fake_root_dir)
+    CommHelper(input_api, ['allo', '--verbose'], cwd=self.fake_root_dir)
     cmd = ['bar.py', '--verbose']
     if input_api.platform == 'win32':
       cmd.insert(0, input_api.python_executable)
-    input_api.subprocess.check_call(
-        cmd, cwd=self.fake_root_dir).AndRaise(
-            input_api.subprocess.CalledProcessError())
+    CommHelper(input_api, cmd, cwd=self.fake_root_dir, ret=(('', None), 1))
 
     self.mox.ReplayAll()
     results = presubmit_canned_checks.RunUnitTests(
         input_api,
         presubmit.OutputApi,
         unit_tests)
     self.assertEqual(1, len(results))
     self.assertEqual(
         presubmit.OutputApi.PresubmitPromptWarning, results[0].__class__)
     self.checkstdout('Running allo\nRunning bar.py\n')
 
   def testCannedRunUnitTestsInDirectory(self):
     change = presubmit.Change(
         'foo1', 'description1', self.fake_root_dir, None, 0, 0, None)
     input_api = self.MockInputApi(change, False)
     input_api.verbose = True
     input_api.logging = self.mox.CreateMock(logging)
     input_api.PresubmitLocalPath().AndReturn(self.fake_root_dir)
     input_api.PresubmitLocalPath().AndReturn(self.fake_root_dir)
     path = presubmit.os.path.join(self.fake_root_dir, 'random_directory')
     input_api.os_listdir(path).AndReturn(['.', '..', 'a', 'b', 'c'])
     input_api.os_path.isfile = lambda x: not x.endswith('.')
-    input_api.subprocess.check_call(
+    CommHelper(
+        input_api,
         [presubmit.os.path.join('random_directory', 'b'), '--verbose'],
         cwd=self.fake_root_dir)
     input_api.logging.debug('Found 5 files, running 1')
 
     self.mox.ReplayAll()
     results = presubmit_canned_checks.RunUnitTestsInDirectory(
         input_api,
         presubmit.OutputApi,
         'random_directory',
         whitelist=['^a$', '^b$'],
@@ skipping 38 matching lines @@
         owners_check=False)
     self.assertEqual(1, len(results))
     self.assertEqual(
         'Found line ending with white spaces in:', results[0]._message)
     self.checkstdout('')
 
 
 if __name__ == '__main__':
   import unittest
   unittest.main()