Fixes RunPythonUnitTests output.

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 random
 import string
@@ skipping 907 matching lines @@
 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):
     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
     return input_api
 
   def testMembersChanged(self):
     self.mox.ReplayAll()
     members = [
       'CheckChangeHasBugField', 'CheckChangeHasNoCR', 'CheckChangeHasNoTabs',
       'CheckChangeHasQaField', 'CheckChangeHasTestedField',
       'CheckChangeHasTestField', 'CheckDoNotSubmit',
       'CheckDoNotSubmitInDescription', 'CheckDoNotSubmitInFiles',
       'CheckLongLines', 'CheckTreeIsOpen', 'RunPythonUnitTests',
     ]
     # If this test fails, you should add the relevant test.
     self.compareMembers(presubmit_canned_checks, members)
 
-  def TestDescription(self, check, description1, description2, error_type):
+  def DescriptionTest(self, check, description1, description2, error_type):
     input_api1 = self.MockInputApi()
     input_api1.change = self.MakeBasicChange('foo', 'Foo\n' + description1)
     input_api2 = self.MockInputApi()
     input_api2.change = self.MakeBasicChange('foo', 'Foo\n' + description2)
     self.mox.ReplayAll()
 
     results1 = check(input_api1, presubmit.OutputApi)
     self.assertEquals(results1, [])
     results2 = check(input_api2, presubmit.OutputApi)
     self.assertEquals(len(results2), 1)
     self.assertEquals(results2[0].__class__, error_type)
 
-  def TestContent(self, check, content1, content2, error_type):
+  def ContentTest(self, check, content1, content2, error_type):
     input_api1 = self.MockInputApi()
     input_api1.change = self.MakeBasicChange('foo', 'Foo\n')
     affected_file = self.mox.CreateMock(presubmit.SvnAffectedFile)
     affected_file.LocalPath().AndReturn('foo.cc')
     output1 = [
       (affected_file, 42, 'yo, ' + content1),
       (affected_file, 43, 'yer'),
       (affected_file, 23, 'ya'),
     ]
     input_api1.RightHandSideLines(mox.IgnoreArg()).AndReturn(output1)
     input_api2 = self.MockInputApi()
     input_api2.change = self.MakeBasicChange('foo', 'Foo\n')
     output2 = [
       (affected_file, 42, 'yo, ' + content2),
       (affected_file, 43, 'yer'),
       (affected_file, 23, 'ya'),
     ]
     input_api2.RightHandSideLines(mox.IgnoreArg()).AndReturn(output2)
     self.mox.ReplayAll()
 
     results1 = check(input_api1, presubmit.OutputApi, None)
     self.assertEquals(results1, [])
     results2 = check(input_api2, presubmit.OutputApi, None)
     self.assertEquals(len(results2), 1)
     self.assertEquals(results2[0].__class__, error_type)
 
   def testCannedCheckChangeHasBugField(self):
-    self.TestDescription(presubmit_canned_checks.CheckChangeHasBugField,
+    self.DescriptionTest(presubmit_canned_checks.CheckChangeHasBugField,
                          'BUG=1234', '',
                          presubmit.OutputApi.PresubmitNotifyResult)
 
   def testCannedCheckChangeHasTestField(self):
-    self.TestDescription(presubmit_canned_checks.CheckChangeHasTestField,
+    self.DescriptionTest(presubmit_canned_checks.CheckChangeHasTestField,
                          'TEST=did some stuff', '',
                          presubmit.OutputApi.PresubmitNotifyResult)
 
   def testCannedCheckChangeHasTestedField(self):
-    self.TestDescription(presubmit_canned_checks.CheckChangeHasTestedField,
+    self.DescriptionTest(presubmit_canned_checks.CheckChangeHasTestedField,
                          'TESTED=did some stuff', '',
                          presubmit.OutputApi.PresubmitError)
 
   def testCannedCheckChangeHasQAField(self):
-    self.TestDescription(presubmit_canned_checks.CheckChangeHasQaField,
+    self.DescriptionTest(presubmit_canned_checks.CheckChangeHasQaField,
                          'QA=BSOD your machine', '',
                          presubmit.OutputApi.PresubmitError)
 
   def testCannedCheckDoNotSubmitInDescription(self):
-    self.TestDescription(presubmit_canned_checks.CheckDoNotSubmitInDescription,
+    self.DescriptionTest(presubmit_canned_checks.CheckDoNotSubmitInDescription,
                          'DO NOTSUBMIT', 'DO NOT ' + 'SUBMIT',
                          presubmit.OutputApi.PresubmitError)
 
   def testCannedCheckDoNotSubmitInFiles(self):
-    self.TestContent(
+    self.ContentTest(
         lambda x,y,z: presubmit_canned_checks.CheckDoNotSubmitInFiles(x, y),
         'DO NOTSUBMIT', 'DO NOT ' + 'SUBMIT',
         presubmit.OutputApi.PresubmitError)
 
   def testCheckChangeHasNoCR(self):
     input_api1 = self.MockInputApi()
     self.mox.StubOutWithMock(input_api1, 'ReadFile')
     input_api1.change = self.MakeBasicChange('foo', 'Foo\n')
     affected_file1 = self.mox.CreateMock(presubmit.SvnAffectedFile)
     input_api1.AffectedSourceFiles(None).AndReturn([affected_file1])
@@ skipping 10 matching lines @@
     results = presubmit_canned_checks.CheckChangeHasNoCR(
         input_api1, presubmit.OutputApi, None)
     self.assertEquals(results, [])
     results2 = presubmit_canned_checks.CheckChangeHasNoCR(
         input_api2, presubmit.OutputApi, None)
     self.assertEquals(len(results2), 1)
     self.assertEquals(results2[0].__class__,
                       presubmit.OutputApi.PresubmitPromptWarning)
   
   def testCannedCheckChangeHasNoTabs(self):
-    self.TestContent(presubmit_canned_checks.CheckChangeHasNoTabs,
+    self.ContentTest(presubmit_canned_checks.CheckChangeHasNoTabs,
                      'blah blah', 'blah\tblah',
                      presubmit.OutputApi.PresubmitPromptWarning)
 
   def testCannedCheckLongLines(self):
     check = lambda x,y,z: presubmit_canned_checks.CheckLongLines(x, y, 10, z)
-    self.TestContent(check, '', 'blah blah blah',
+    self.ContentTest(check, '', 'blah blah blah',
                      presubmit.OutputApi.PresubmitPromptWarning)
 
   def testCannedCheckTreeIsOpenOpen(self):
     input_api = self.MockInputApi()
     input_api.is_committing = True
     connection = self.mox.CreateMockAnything()
     input_api.urllib2.urlopen('url_to_open').AndReturn(connection)
     connection.read().AndReturn('1')
     connection.close()
     self.mox.ReplayAll()
@@ skipping 16 matching lines @@
                       presubmit.OutputApi.PresubmitPromptWarning)
 
   def testRunPythonUnitTestsNoTest(self):
     input_api = self.MockInputApi()
     input_api.is_committing = False
     self.mox.ReplayAll()
     results = presubmit_canned_checks.RunPythonUnitTests(
         input_api, presubmit.OutputApi, [])
     self.assertEquals(results, [])
 
-  def testRunPythonUnitTestsNonExistent1(self):
+  def testRunPythonUnitTestsNonExistentUpload(self):
     input_api = self.MockInputApi()
     input_api.is_committing = False
     presubmit_canned_checks._RunPythonUnitTests_LoadTests(
         input_api, '_non_existent_module').AndRaise(
             exceptions.ImportError('Blehh'))
     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 testRunPythonUnitTestsNonExistent2(self):
+  def testRunPythonUnitTestsNonExistentCommitting(self):
     input_api = self.MockInputApi()
     input_api.is_committing = True
     presubmit_canned_checks._RunPythonUnitTests_LoadTests(
         input_api, '_non_existent_module').AndRaise(
             exceptions.ImportError('Blehh'))
     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 testRunPythonUnitTestsEmpty1(self):
+  def testRunPythonUnitTestsEmptyUpload(self):
     input_api = self.MockInputApi()
     input_api.is_committing = 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 testRunPythonUnitTestsEmpty2(self):
+  def testRunPythonUnitTestsEmptyCommitting(self):
     input_api = self.MockInputApi()
     input_api.is_committing = 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 testRunPythonUnitTestsFailure1(self):
+  def testRunPythonUnitTestsFailureUpload(self):
     input_api = self.MockInputApi()
     input_api.is_committing = 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()
-    input_api.unittest.TextTestRunner(verbosity=0).AndReturn(runner)
+    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]
     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!')
 
-  def testRunPythonUnitTestsFailure2(self):
+  def testRunPythonUnitTestsFailureCommitting(self):
     input_api = self.MockInputApi()
     input_api.is_committing = 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()
-    input_api.unittest.TextTestRunner(verbosity=0).AndReturn(runner)
+    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]
     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!')
 
   def testRunPythonUnitTestsSuccess(self):
     input_api = self.MockInputApi()
     input_api.is_committing = 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()
-    input_api.unittest.TextTestRunner(verbosity=0).AndReturn(runner)
+    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
     self.mox.ReplayAll()
 
     results = presubmit_canned_checks.RunPythonUnitTests(
         input_api, presubmit.OutputApi, ['test_module'])
     self.assertEquals(len(results), 0)
 
 
 if __name__ == '__main__':
   unittest.main()