Change RunPythonUnitTests() to run the unit tests in a separate process.

tests/presubmit_unittest.py

 #!/usr/bin/python
 # Copyright (c) 2006-2009 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."""
 
 import exceptions
 import os
 import StringIO
@@ skipping 476 matching lines @@
   """Tests presubmit.InputApi."""
   def testMembersChanged(self):
     self.mox.ReplayAll()
     members = [
       'AbsoluteLocalPaths', 'AffectedFiles', 'AffectedSourceFiles',
       'AffectedTextFiles',
       'DEFAULT_BLACK_LIST', 'DEFAULT_WHITE_LIST',
       'DepotToLocalPath', 'FilterSourceFile', 'LocalPaths',
       'LocalToDepotPath',
       'PresubmitLocalPath', 'ReadFile', 'RightHandSideLines', 'ServerPaths',
-      'basename', 'cPickle', 'cStringIO', 'canned_checks', 'change',
+      'basename', 'cPickle', 'cStringIO', 'canned_checks', 'change', 'environ',
       'is_committing', 'marshal', 'os_path', 'pickle', 'platform',
+      'python_executable',
       're', 'subprocess', 'tempfile', 'traceback', 'unittest', 'urllib2',
       'version',
     ]
     # If this test fails, you should add the relevant test.
     self.compareMembers(presubmit.InputApi(None, './.', False), members)
 
   def testDepotToLocalPath(self):
     presubmit.gclient.CaptureSVNInfo('svn://foo/smurf').AndReturn(
         {'Path': 'prout'})
     presubmit.gclient.CaptureSVNInfo('svn:/foo/notfound/burp').AndReturn({})
@@ skipping 459 matching lines @@
     change = presubmit.Change('foo', 'foo', self.fake_root_dir, [('M', 'AA')],
                               0, 0)
     self.compareMembers(change, members)
 
 
 class CannedChecksUnittest(PresubmitTestsBase):
   """Tests presubmit_canned_checks.py."""
 
   def setUp(self):
     PresubmitTestsBase.setUp(self)
-    self.mox.StubOutWithMock(presubmit_canned_checks,
-                         '_RunPythonUnitTests_LoadTests')
 
   def MockInputApi(self, change, committing):
     input_api = self.mox.CreateMock(presubmit.InputApi)
     input_api.cStringIO = presubmit.cStringIO
     input_api.re = presubmit.re
     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.change = change
     input_api.is_committing = committing
+    input_api.python_executable = 'pyyyyython'
     return input_api
 
   def testMembersChanged(self):
     self.mox.ReplayAll()
     members = [
       'CheckChangeHasBugField', 'CheckChangeHasDescription',
       'CheckChangeHasNoStrayWhitespace',
       'CheckChangeHasOnlyOneEol', 'CheckChangeHasNoCR',
       'CheckChangeHasNoCrAndHasOnlyOneEol', 'CheckChangeHasNoTabs',
       'CheckChangeHasQaField', 'CheckChangeHasTestedField',
@@ skipping 264 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)
-    presubmit_canned_checks._RunPythonUnitTests_LoadTests(
-        input_api, '_non_existent_module').AndRaise(
-            exceptions.ImportError('Blehh'))
+    process = self.mox.CreateMockAnything()
+    process.returncode = 2
+    input_api.subprocess.Popen(
+        ['pyyyyython', '-m', '_non_existent_module'], cwd=None, env=None,
+        stderr=presubmit.subprocess.PIPE, stdin=presubmit.subprocess.PIPE,
+        stdout=presubmit.subprocess.PIPE).AndReturn(process)
+    process.communicate().AndReturn(
+        ('', 'pyyython: module _non_existent_module not found'))
     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)
-    presubmit_canned_checks._RunPythonUnitTests_LoadTests(
-        input_api, '_non_existent_module').AndRaise(
-            exceptions.ImportError('Blehh'))
+    process = self.mox.CreateMockAnything()
+    process.returncode = 2
+    input_api.subprocess.Popen(
+        ['pyyyyython', '-m', '_non_existent_module'], cwd=None, env=None,
+        stderr=presubmit.subprocess.PIPE, stdin=presubmit.subprocess.PIPE,
+        stdout=presubmit.subprocess.PIPE).AndReturn(process)
+    process.communicate().AndReturn(
+        ('', 'pyyython: module _non_existent_module not found'))
     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 testRunPythonUnitTestsEmptyUpload(self):
-    input_api = self.MockInputApi(None, False)
-    test_module = self.mox.CreateMockAnything()
-    presubmit_canned_checks._RunPythonUnitTests_LoadTests(
-        input_api, 'test_module').AndReturn([])
-    self.mox.ReplayAll()
-
-    results = presubmit_canned_checks.RunPythonUnitTests(
-        input_api, presubmit.OutputApi, ['test_module'])
-    self.assertEquals(results, [])
-
-  def testRunPythonUnitTestsEmptyCommitting(self):
-    input_api = self.MockInputApi(None, True)
-    test_module = self.mox.CreateMockAnything()
-    presubmit_canned_checks._RunPythonUnitTests_LoadTests(
-        input_api, 'test_module').AndReturn([])
-    self.mox.ReplayAll()
-
-    results = presubmit_canned_checks.RunPythonUnitTests(
-        input_api, presubmit.OutputApi, ['test_module'])
-    self.assertEquals(results, [])
-
   def testRunPythonUnitTestsFailureUpload(self):
     input_api = self.MockInputApi(None, False)
     input_api.unittest = self.mox.CreateMock(unittest)
     input_api.cStringIO = self.mox.CreateMock(presubmit.cStringIO)
-    test = self.mox.CreateMockAnything()
-    presubmit_canned_checks._RunPythonUnitTests_LoadTests(
-        input_api, 'test_module').AndReturn([test])
-    runner = self.mox.CreateMockAnything()
-    buffer = self.mox.CreateMockAnything()
-    input_api.cStringIO.StringIO().AndReturn(buffer)
-    buffer.getvalue().AndReturn('BOO HOO!')
-    input_api.unittest.TextTestRunner(stream=buffer, verbosity=0
-        ).AndReturn(runner)
-    suite = self.mox.CreateMockAnything()
-    input_api.unittest.TestSuite([test]).AndReturn(suite)
-    test_result = self.mox.CreateMockAnything()
-    runner.run(suite).AndReturn(test_result)
-    test_result.wasSuccessful().AndReturn(False)
-    test_result.failures = [None, None]
-    test_result.errors = [None, None, None]
+    process = self.mox.CreateMockAnything()
+    process.returncode = -1
+    input_api.subprocess.Popen(
+        ['pyyyyython', '-m', 'test_module'], cwd=None, env=None,
+        stderr=presubmit.subprocess.PIPE, stdin=presubmit.subprocess.PIPE,
+        stdout=presubmit.subprocess.PIPE).AndReturn(process)
+    process.communicate().AndReturn(('BOO HOO!', ''))
     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(results[0]._long_text, 'BOO HOO!')
+    self.assertEquals(results[0]._long_text,
+                      "Test 'test_module' failed with code -1\nBOO HOO!")
 
   def testRunPythonUnitTestsFailureCommitting(self):
     input_api = self.MockInputApi(None, True)
-    input_api.unittest = self.mox.CreateMock(unittest)
-    input_api.cStringIO = self.mox.CreateMock(presubmit.cStringIO)
-    test = self.mox.CreateMockAnything()
-    presubmit_canned_checks._RunPythonUnitTests_LoadTests(
-        input_api, 'test_module').AndReturn([test])
-    runner = self.mox.CreateMockAnything()
-    buffer = self.mox.CreateMockAnything()
-    input_api.cStringIO.StringIO().AndReturn(buffer)
-    buffer.getvalue().AndReturn('BOO HOO!')
-    input_api.unittest.TextTestRunner(stream=buffer, verbosity=0
-        ).AndReturn(runner)
-    suite = self.mox.CreateMockAnything()
-    input_api.unittest.TestSuite([test]).AndReturn(suite)
-    test_result = self.mox.CreateMockAnything()
-    runner.run(suite).AndReturn(test_result)
-    test_result.wasSuccessful().AndReturn(False)
-    test_result.failures = [None, None]
-    test_result.errors = [None, None, None]
+    process = self.mox.CreateMockAnything()
+    process.returncode = 1
+    input_api.subprocess.Popen(
+        ['pyyyyython', '-m', 'test_module'], cwd=None, env=None,
+        stderr=presubmit.subprocess.PIPE, stdin=presubmit.subprocess.PIPE,
+        stdout=presubmit.subprocess.PIPE).AndReturn(process)
+    process.communicate().AndReturn(('BOO HOO!', ''))
     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(results[0]._long_text, 'BOO HOO!')
+    self.assertEquals(results[0]._long_text,
+                      "Test 'test_module' failed with code 1\nBOO HOO!")
 
   def testRunPythonUnitTestsSuccess(self):
     input_api = self.MockInputApi(None, False)
     input_api.cStringIO = self.mox.CreateMock(presubmit.cStringIO)
     input_api.unittest = self.mox.CreateMock(unittest)
-    test = self.mox.CreateMockAnything()
-    presubmit_canned_checks._RunPythonUnitTests_LoadTests(
-        input_api, 'test_module').AndReturn([test])
-    runner = self.mox.CreateMockAnything()
-    buffer = self.mox.CreateMockAnything()
-    input_api.cStringIO.StringIO().AndReturn(buffer)
-    input_api.unittest.TextTestRunner(stream=buffer, verbosity=0
-        ).AndReturn(runner)
-    suite = self.mox.CreateMockAnything()
-    input_api.unittest.TestSuite([test]).AndReturn(suite)
-    test_result = self.mox.CreateMockAnything()
-    runner.run(suite).AndReturn(test_result)
-    test_result.wasSuccessful().AndReturn(True)
-    test_result.failures = 0
-    test_result.errors = 0
+    process = self.mox.CreateMockAnything()
+    process.returncode = 0
+    input_api.subprocess.Popen(
+        ['pyyyyython', '-m', 'test_module'], cwd=None, env=None,
+        stderr=presubmit.subprocess.PIPE, stdin=presubmit.subprocess.PIPE,
+        stdout=presubmit.subprocess.PIPE).AndReturn(process)
+    process.communicate().AndReturn(('', ''))
     self.mox.ReplayAll()
 
     results = presubmit_canned_checks.RunPythonUnitTests(
         input_api, presubmit.OutputApi, ['test_module'])
     self.assertEquals(len(results), 0)
 
 
 if __name__ == '__main__':
   unittest.main()