Use check_call() instead of Popen() for canned checks.

tests/presubmit_unittest.py

 #!/usr/bin/env python
 # Copyright (c) 2011 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 is too confused.
-# pylint: disable=E1101,E1103,W0212,W0403
+# pylint: disable=E1101,E1103,R0201,W0212,W0403
 
 import StringIO
 import sys
 
 # Fixes include path.
 from super_mox import mox, SuperMoxTestBase
 
 import owners
 import presubmit_support as presubmit
 # Shortcut.
@@ skipping 1219 matching lines @@
     input_api = self.mox.CreateMock(presubmit.InputApi)
     input_api.cStringIO = presubmit.cStringIO
     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.traceback = presubmit.traceback
     input_api.urllib2 = self.mox.CreateMock(presubmit.urllib2)
     input_api.unittest = unittest
     input_api.subprocess = self.mox.CreateMock(presubmit.subprocess)
+    class fake_CalledProcessError(Exception):
+      def __str__(self):
+        return 'foo'
+    input_api.subprocess.CalledProcessError = fake_CalledProcessError
 
     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
     return input_api
 
   def testMembersChanged(self):
@@ skipping 465 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)
-    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'))
+    input_api.subprocess.check_output(
+        ['pyyyyython', '-m', '_non_existent_module'], cwd=None, env=None
+        ).AndRaise(
+            input_api.subprocess.CalledProcessError())
     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)
-    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'))
+    input_api.subprocess.check_output(
+        ['pyyyyython', '-m', '_non_existent_module'], cwd=None, env=None
+        ).AndRaise(
+            input_api.subprocess.CalledProcessError())
     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)
-    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!', ''))
+    input_api.subprocess.check_output(
+        ['pyyyyython', '-m', 'test_module'], cwd=None, env=None).AndRaise(
+            input_api.subprocess.CalledProcessError())
     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,
-                      "Test 'test_module' failed with code -1\nBOO HOO!")
+    self.assertEquals('test_module failed!\nfoo', results[0]._message)
 
   def testRunPythonUnitTestsFailureCommitting(self):
     input_api = self.MockInputApi(None, True)
-    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!', ''))
+    input_api.subprocess.check_output(
+        ['pyyyyython', '-m', 'test_module'], cwd=None, env=None).AndRaise(
+            input_api.subprocess.CalledProcessError())
     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,
-                      "Test 'test_module' failed with code 1\nBOO HOO!")
+    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)
-    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(('', ''))
+    input_api.subprocess.check_output(
+        ['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 testCheckRietveldTryJobExecutionBad(self):
     change = self.mox.CreateMock(presubmit.SvnChange)
     change.scm = 'svn'
     change.issue = 2
@@ skipping 189 matching lines @@
     self.AssertOwnersWorks(approvers=set(['ben@example.com']),
                            uncovered_files=set())
 
   def testCannedRunUnitTests(self):
     change = presubmit.Change(
         'foo1', 'description1', self.fake_root_dir, None, 0, 0)
     input_api = self.MockInputApi(change, False)
     unit_tests = ['allo', 'bar.py']
     input_api.PresubmitLocalPath().AndReturn(self.fake_root_dir)
     input_api.PresubmitLocalPath().AndReturn(self.fake_root_dir)
-    proc1 = self.mox.CreateMockAnything()
-    input_api.subprocess.Popen(['allo'], cwd=self.fake_root_dir,
-        stderr=None, stdout=None).AndReturn(proc1)
-    proc1.returncode = 0
-    proc1.communicate().AndReturn(['baz', None])
-    proc2 = self.mox.CreateMockAnything()
-    input_api.subprocess.Popen(['bar.py'], cwd=self.fake_root_dir,
-        stderr=None, stdout=None).AndReturn(proc2)
-    proc2.returncode = 1
-    proc2.communicate().AndReturn(['bouz', None])
+    input_api.subprocess.check_call(
+        ['allo'], cwd=self.fake_root_dir)
+    input_api.subprocess.check_call(
+        ['bar.py'], cwd=self.fake_root_dir).AndRaise(
+            input_api.subprocess.CalledProcessError())
 
     self.mox.ReplayAll()
     results = presubmit_canned_checks.RunUnitTests(
         input_api,
         presubmit.OutputApi,
         unit_tests,
         verbose=True)
     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)
     input_api = self.MockInputApi(change, False)
     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('.')
-    proc1 = self.mox.CreateMockAnything()
-    input_api.subprocess.Popen(['random_directory/b'], cwd=self.fake_root_dir,
-        stderr=None, stdout=None).AndReturn(proc1)
-    proc1.returncode = 0
-    proc1.communicate().AndReturn(['baz', None])
+    input_api.subprocess.check_call(
+        ['random_directory/b'], cwd=self.fake_root_dir)
 
     self.mox.ReplayAll()
     results = presubmit_canned_checks.RunUnitTestsInDirectory(
         input_api,
         presubmit.OutputApi,
         'random_directory',
         whitelist=['^a$', '^b$'],
         blacklist=['a'],
         verbose=True)
     self.assertEqual(results, [])
     self.checkstdout('Running random_directory/b\n')
 
 
 if __name__ == '__main__':
   import unittest
   unittest.main()