Add InputApi.is_committing to be able to return a failure or notification, depending on the check.

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 86 matching lines @@
 
 class PresubmitUnittest(PresubmitTestsBase):
   """General presubmit_support.py tests (excluding InputApi and OutputApi)."""
   def testMembersChanged(self):
     self.mox.ReplayAll()
     members = [
       'AffectedFile', 'DoPresubmitChecks', 'GclChange', 'InputApi',
       'ListRelevantPresubmitFiles', 'Main', 'NotImplementedException',
       'OutputApi', 'ParseFiles', 'PresubmitExecuter',
       'ScanSubDirs', 'SvnAffectedFile',
-      'cPickle', 'cStringIO', 'deprecated', 'exceptions',
+      'cPickle', 'cStringIO', 'exceptions',
       'fnmatch', 'gcl', 'gclient', 'glob', 'marshal', 'normpath', 'optparse',
       'os', 'pickle', 'presubmit_canned_checks', 're', 'subprocess', 'sys',
-      'tempfile', 'types', 'unittest', 'urllib2', 'warnings',
+      'tempfile', 'traceback', 'types', 'unittest', 'urllib2', 'warnings',
     ]
     # If this test fails, you should add the relevant test.
     self.compareMembers(presubmit, members)
 
   def testListRelevantPresubmitFiles(self):
     join = presubmit.os.path.join
     files = [
       'blat.cc',
       join('foo', 'haspresubmit', 'yodle', 'smart.h'),
       join('moo', 'mat', 'gat', 'yo.h'),
@@ skipping 348 matching lines @@
     affected_files_and_dirs = change.AffectedFiles(include_dirs=True)
     self.failUnless(len(affected_files_and_dirs) == 2)
 
   def testTags(self):
     DEFAULT_SCRIPT = """
 def CheckChangeOnUpload(input_api, output_api):
  if input_api.change.tags['BUG'] != 'boo':
    return [output_api.PresubmitError('Tag parsing failed. 1')]
  if input_api.change.tags['STORY'] != 'http://tracker.com/42':
    return [output_api.PresubmitError('Tag parsing failed. 2')]
+ if input_api.change.BUG != 'boo':
+   return [output_api.PresubmitError('Tag parsing failed. 6')]
+ if input_api.change.STORY != 'http://tracker.com/42':
+   return [output_api.PresubmitError('Tag parsing failed. 7')]
  if 'TEST' in input_api.change.tags:
    return [output_api.PresubmitError('Tag parsing failed. 3')]
  if input_api.change.DescriptionText() != 'Blah Blah':
    return [output_api.PresubmitError('Tag parsing failed. 4 ' + 
                                      input_api.change.DescriptionText())]
  if (input_api.change.FullDescriptionText() !=
      'Blah Blah\\n\\nSTORY=http://tracker.com/42\\nBUG=boo\\n'):
    return [output_api.PresubmitError('Tag parsing failed. 5 ' +
                                      input_api.change.FullDescriptionText())]
  return [output_api.PresubmitNotifyResult(input_api.change.tags['STORY'])]
@@ skipping 21 matching lines @@
 
 class InputApiUnittest(PresubmitTestsBase):
   """Tests presubmit.InputApi."""
   def testMembersChanged(self):
     self.mox.ReplayAll()
     members = [
       'AbsoluteLocalPaths', 'AffectedFiles', 'AffectedTextFiles',
       'DepotToLocalPath', 'LocalPaths', 'LocalToDepotPath',
       'PresubmitLocalPath', 'RightHandSideLines', 'ServerPaths',
       'basename', 'cPickle', 'cStringIO', 'canned_checks', 'change',
-      'marshal', 'os_path', 'pickle', 'platform',
-      're', 'subprocess', 'tempfile', 'unittest', 'urllib2', 'version',
+      'is_committing', 'marshal', 'os_path', 'pickle', 'platform',
+      're', 'subprocess', 'tempfile', 'traceback', 'unittest', 'urllib2',
+      'version',
     ]
     # If this test fails, you should add the relevant test.
-    self.compareMembers(presubmit.InputApi(None, './.'), members)
+    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({})
     self.mox.ReplayAll()
 
-    path = presubmit.InputApi(None, './p').DepotToLocalPath('svn://foo/smurf')
+    path = presubmit.InputApi(None, './p', False).DepotToLocalPath(
+        'svn://foo/smurf')
     self.failUnless(path == 'prout')
-    path = presubmit.InputApi(None, './p').DepotToLocalPath(
+    path = presubmit.InputApi(None, './p', False).DepotToLocalPath(
         'svn:/foo/notfound/burp')
     self.failUnless(path == None)
 
   def testLocalToDepotPath(self):
     presubmit.gclient.CaptureSVNInfo('smurf').AndReturn({'URL': 'svn://foo'})
     presubmit.gclient.CaptureSVNInfo('notfound-food').AndReturn({})
     self.mox.ReplayAll()
 
-    path = presubmit.InputApi(None, './p').LocalToDepotPath('smurf')
+    path = presubmit.InputApi(None, './p', False).LocalToDepotPath('smurf')
     self.assertEqual(path, 'svn://foo')
-    path = presubmit.InputApi(None, './p').LocalToDepotPath('notfound-food')
+    path = presubmit.InputApi(None, './p', False).LocalToDepotPath(
+        'notfound-food')
     self.failUnless(path == None)
 
   def testInputApiConstruction(self):
     self.mox.ReplayAll()
     # Fudge the change object, it's not used during construction anyway
-    api = presubmit.InputApi(change=42, presubmit_path='foo/path/PRESUBMIT.py')
+    api = presubmit.InputApi(change=42, presubmit_path='foo/path/PRESUBMIT.py',
+                             is_committing=False)
     self.assertEquals(api.PresubmitLocalPath(), 'foo/path')
     self.assertEquals(api.change, 42)
 
   def testInputApiPresubmitScriptFiltering(self):
     join = presubmit.os.path.join
     description_lines = ('Hello there',
                          'this is a change',
                          'BUG=123',
                          ' STORY =http://foo/  \t',
                          'and some more regular text')
@@ skipping 24 matching lines @@
     presubmit.gcl.GetSVNFileProperty(blat, 'svn:mime-type').AndReturn(None)
     presubmit.gcl.GetSVNFileProperty(binary, 'svn:mime-type').AndReturn(
         'application/octet-stream')
     presubmit.gcl.ReadFile(blat).AndReturn('whatever\ncookie')
     self.mox.ReplayAll()
 
     ci = presubmit.gcl.ChangeInfo(name='mychange', issue=0, patchset=0,
                                   description='\n'.join(description_lines),
                                   files=files)
     change = presubmit.GclChange(ci)
-    api = presubmit.InputApi(change, 'foo/PRESUBMIT.py')
+    api = presubmit.InputApi(change, 'foo/PRESUBMIT.py', False)
     affected_files = api.AffectedFiles()
     self.assertEquals(len(affected_files), 3)
     self.assertEquals(affected_files[0].LocalPath(),
                       presubmit.normpath('foo/blat.cc'))
     self.assertEquals(affected_files[1].LocalPath(),
                       presubmit.normpath('foo/blat/binary.dll'))
     self.assertEquals(affected_files[2].LocalPath(),
                       presubmit.normpath('foo/mat/beingdeleted.txt'))
     rhs_lines = []
     for line in api.RightHandSideLines():
@@ skipping 29 matching lines @@
     # Absolute paths should be prefixed
     self.assertEquals(affected_files[0].AbsoluteLocalPath(),
                       normpath(join(self.fake_root_dir, 'isdir')))
     self.assertEquals(affected_files[1].AbsoluteLocalPath(),
                       normpath(join(self.fake_root_dir, 'isdir/blat.cc')))
 
     # New helper functions need to work
     paths_from_change = change.AbsoluteLocalPaths(include_dirs=True)
     self.assertEqual(len(paths_from_change), 3)
     presubmit_path = join(self.fake_root_dir, 'isdir', 'PRESUBMIT.py')
-    api = presubmit.InputApi(change=change, presubmit_path=presubmit_path)
+    api = presubmit.InputApi(change=change,
+                             presubmit_path=presubmit_path,
+                             is_committing=True)
     paths_from_api = api.AbsoluteLocalPaths(include_dirs=True)
     self.assertEqual(len(paths_from_api), 2)
     for absolute_paths in [paths_from_change, paths_from_api]:
       self.assertEqual(absolute_paths[0],
                        normpath(join(self.fake_root_dir, 'isdir')))
       self.assertEqual(absolute_paths[1],
                        normpath(join(self.fake_root_dir, 'isdir', 'blat.cc')))
 
   def testDeprecated(self):
     presubmit.warnings.warn(mox.IgnoreArg(), category=mox.IgnoreArg(),
                             stacklevel=2)
     self.mox.ReplayAll()
     change = presubmit.GclChange(
         presubmit.gcl.ChangeInfo(name='mychange', issue=0, patchset=0,
                                  description='Bleh\n', files=None))
-    api = presubmit.InputApi(change, 'foo/PRESUBMIT.py')
+    api = presubmit.InputApi(change, 'foo/PRESUBMIT.py', True)
     api.AffectedTextFiles(include_deletes=False)
 
 
 class OuputApiUnittest(PresubmitTestsBase):
   """Tests presubmit.OutputApi."""
   def testMembersChanged(self):
     self.mox.ReplayAll()
     members = [
       'MailTextResult', 'PresubmitError', 'PresubmitNotifyResult',
       'PresubmitPromptWarning', 'PresubmitResult',
@@ skipping 141 matching lines @@
   """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.re = presubmit.re
+    input_api.traceback = presubmit.traceback
     input_api.urllib2 = self.mox.CreateMock(presubmit.urllib2)
     input_api.unittest = unittest
     return input_api
 
   def MakeBasicChange(self, name, description):
     ci = presubmit.gcl.ChangeInfo(name, 0, 0, description, None)
     return presubmit.GclChange(ci, self.fake_root_dir)
 
   def testMembersChanged(self):
     self.mox.ReplayAll()
@@ skipping 104 matching lines @@
     input_api.urllib2.urlopen('url_to_closed').AndReturn(connection)
     connection.read().AndReturn('0')
     connection.close()
     self.mox.ReplayAll()
     results = presubmit_canned_checks.CheckTreeIsOpen(
         input_api, presubmit.OutputApi, url='url_to_closed', closed='0')
     self.assertEquals(len(results), 1)
     self.assertEquals(results[0].__class__,
                       presubmit.OutputApi.PresubmitError)
 
-  def testRunPythonUnitTests1(self):
+  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 testRunPythonUnitTests2(self):
+  def testRunPythonUnitTestsNonExistent1(self):
     input_api = self.MockInputApi()
+    input_api.is_committing = False
     presubmit_canned_checks._RunPythonUnitTests_LoadTests('_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):
+    input_api = self.MockInputApi()
+    input_api.is_committing = True
+    presubmit_canned_checks._RunPythonUnitTests_LoadTests('_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 testRunPythonUnitTests3(self):
+  def testRunPythonUnitTestsEmpty1(self):
     input_api = self.MockInputApi()
+    input_api.is_committing = False
     test_module = self.mox.CreateMockAnything()
     presubmit_canned_checks._RunPythonUnitTests_LoadTests('test_module'
         ).AndReturn([])
+    self.mox.ReplayAll()
+
+    results = presubmit_canned_checks.RunPythonUnitTests(
+        input_api, presubmit.OutputApi, ['test_module'])
+    self.assertEquals(results, [])
+
+  def testRunPythonUnitTestsEmpty2(self):
+    input_api = self.MockInputApi()
+    input_api.is_committing = True
+    test_module = self.mox.CreateMockAnything()
+    presubmit_canned_checks._RunPythonUnitTests_LoadTests('test_module'
+        ).AndReturn([])
     self.mox.ReplayAll()
 
     results = presubmit_canned_checks.RunPythonUnitTests(
         input_api, presubmit.OutputApi, ['test_module'])
     self.assertEquals(results, [])
 
-  def testRunPythonUnitTests4(self):
+  def testRunPythonUnitTestsFailure1(self):
     input_api = self.MockInputApi()
+    input_api.is_committing = False
     input_api.unittest = self.mox.CreateMock(unittest)
     test = self.mox.CreateMockAnything()
     presubmit_canned_checks._RunPythonUnitTests_LoadTests('test_module'
+        ).AndReturn([test])
+    runner = self.mox.CreateMockAnything()
+    input_api.unittest.TextTestRunner(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 = 2
+    test_result.errors = 3
+    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)
+
+  def testRunPythonUnitTestsFailure2(self):
+    input_api = self.MockInputApi()
+    input_api.is_committing = True
+    input_api.unittest = self.mox.CreateMock(unittest)
+    test = self.mox.CreateMockAnything()
+    presubmit_canned_checks._RunPythonUnitTests_LoadTests('test_module'
         ).AndReturn([test])
     runner = self.mox.CreateMockAnything()
     input_api.unittest.TextTestRunner(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 = 2
     test_result.errors = 3
     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)
 
-  def testRunPythonUnitTests5(self):
+  def testRunPythonUnitTestsSuccess(self):
     input_api = self.MockInputApi()
+    input_api.is_committing = False
     input_api.unittest = self.mox.CreateMock(unittest)
     test = self.mox.CreateMockAnything()
     presubmit_canned_checks._RunPythonUnitTests_LoadTests('test_module'
         ).AndReturn([test])
     runner = self.mox.CreateMockAnything()
     input_api.unittest.TextTestRunner(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()