Add more presubmit support. Add PRESUBMIT.py to depot_tools....

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.py and presubmit_canned_checks.py."""
 
 import os
 import StringIO
+import sys
 import unittest
 
 # Local imports
 import gcl
 import gclient
 import presubmit_support as presubmit
 import presubmit_canned_checks
 
 
 class PresubmitTestsBase(unittest.TestCase):
@@ skipping 52 matching lines @@
                 '  else:\n'
                 '    return ()')
       else:
         return 'one:%s\r\ntwo:%s' % (path, path)
     gcl.ReadFile = MockReadFile
 
     self.original_GetRepositoryRoot = gcl.GetRepositoryRoot
     def MockGetRepositoryRoot():
       return ''
     gcl.GetRepositoryRoot = MockGetRepositoryRoot
+    self._sys_stdout = sys.stdout
+    sys.stdout = StringIO.StringIO()
 
   def tearDown(self):
     os.path.isfile = self.original_IsFile
     gclient.CaptureSVNInfo = self.original_CaptureSVNInfo
     gcl.GetSVNFileProperty = self.original_GetSVNFileProperty
     gcl.ReadFile = self.original_ReadFile
     gcl.GetRepositoryRoot = self.original_GetRepositoryRoot
+    sys.stdout = self._sys_stdout
 
   @staticmethod
   def MakeBasicChange(name, description):
     ci = gcl.ChangeInfo(name=name,
                         description=description,
                         files=[])
     change = presubmit.GclChange(ci)
     return change
 
   def compareMembers(self, object, members):
@@ skipping 193 matching lines @@
     files = [
       ['A', 'haspresubmit\\blat.cc'],
     ]
     ci = gcl.ChangeInfo(name='mychange',
                         description='\n'.join(description_lines),
                         files=files)
 
     output = StringIO.StringIO()
     input = StringIO.StringIO('y\n')
 
-    self.failIf(presubmit.DoPresubmitChecks(ci, False, False, output, input))
+    self.failIf(presubmit.DoPresubmitChecks(ci, False, True, output, input))
     self.failUnless(output.getvalue().count('!!'))
 
   def testDoPresubmitChecksPromptsAfterWarnings(self):
     description_lines = ('Hello there',
                          'this is a change',
                          'NOSUCHKEY=http://tracker/123')
     files = [
       ['A', 'haspresubmit\\blat.cc'],
     ]
     ci = gcl.ChangeInfo(name='mychange',
                         description='\n'.join(description_lines),
                         files=files)
 
     output = StringIO.StringIO()
     input = StringIO.StringIO('n\n')  # say no to the warning
 
-    self.failIf(presubmit.DoPresubmitChecks(ci, False, False, output, input))
+    self.failIf(presubmit.DoPresubmitChecks(ci, False, True, output, input))
     self.failUnless(output.getvalue().count('??'))
 
     output = StringIO.StringIO()
     input = StringIO.StringIO('y\n')  # say yes to the warning
 
     self.failUnless(presubmit.DoPresubmitChecks(ci,
                                                 False,
-                                                False,
+                                                True,
                                                 output,
                                                 input))
     self.failUnless(output.getvalue().count('??'))
 
   def testDoPresubmitChecksNoWarningPromptIfErrors(self):
     description_lines = ('Hello there',
                          'this is a change',
                          'NOSUCHKEY=http://tracker/123',
                          'REALLYNOSUCHKEY=http://tracker/123')
     files = [
       ['A', 'haspresubmit\\blat.cc'],
     ]
     ci = gcl.ChangeInfo(name='mychange',
                         description='\n'.join(description_lines),
                         files=files)
 
     output = StringIO.StringIO()
     input = StringIO.StringIO()  # should be unused
 
-    self.failIf(presubmit.DoPresubmitChecks(ci, False, False, output, input))
+    self.failIf(presubmit.DoPresubmitChecks(ci, False, True, output, input))
     self.failUnless(output.getvalue().count('??'))
     self.failUnless(output.getvalue().count('XX!!XX'))
     self.failIf(output.getvalue().count('(y/N)'))
 
   def testDirectoryHandling(self):
     files = [
       ['A', 'isdir'],
       ['A', 'isdir\\blat.cc'],
     ]
     ci = gcl.ChangeInfo(name='mychange',
@@ skipping 15 matching lines @@
 
 
 class InputApiUnittest(PresubmitTestsBase):
   """Tests presubmit.InputApi."""
   def testMembersChanged(self):
     members = [
       'AbsoluteLocalPaths', 'AffectedFiles', 'AffectedTextFiles',
       'DepotToLocalPath', 'FilterTextFiles', 'LocalPaths', 'LocalToDepotPath',
       'PresubmitLocalPath', 'RightHandSideLines', 'ServerPaths',
       'basename', 'cPickle', 'cStringIO', 'canned_checks', 'change',
-      'current_presubmit_path', 'marshal', 'os_path', 'pickle', 'platform',
+      'marshal', 'os_path', 'pickle', 'platform',
       're', 'subprocess', 'tempfile', 'urllib2',
     ]
     # If this test fails, you should add the relevant test.
-    self.compareMembers(presubmit.InputApi(None, None), members)
+    self.compareMembers(presubmit.InputApi(None, './.'), members)
 
   def testDepotToLocalPath(self):
     path = presubmit.InputApi.DepotToLocalPath('svn:/foo/smurf')
     self.failUnless(path == 'smurf')
     path = presubmit.InputApi.DepotToLocalPath('svn:/foo/notfound/burp')
     self.failUnless(path == None)
 
   def testLocalToDepotPath(self):
     path = presubmit.InputApi.LocalToDepotPath('smurf')
     self.failUnless(path == 'svn:/foo/smurf')
     path = presubmit.InputApi.LocalToDepotPath('notfound-food')
     self.failUnless(path == None)
 
   def testInputApiConstruction(self):
     # Fudge the change object, it's not used during construction anyway
-    api = presubmit.InputApi(change=42, presubmit_path='foo/path')
+    api = presubmit.InputApi(change=42, presubmit_path='foo/path/PRESUBMIT.py')
     self.failUnless(api.PresubmitLocalPath() == 'foo/path')
     self.failUnless(api.change == 42)
 
   def testFilterTextFiles(self):
     class MockAffectedFile(object):
       def __init__(self, path, action):
         self.path = path
         self.action = action
       def Action(self):
         return self.action
@@ skipping 29 matching lines @@
     ]
 
     ci = gcl.ChangeInfo(name='mychange',
                         description='\n'.join(description_lines),
                         files=files)
     change = presubmit.GclChange(ci)
 
     api = presubmit.InputApi(change, 'foo/PRESUBMIT.py')
 
     affected_files = api.AffectedFiles()
-    self.failUnless(len(affected_files) == 3)
-    self.failUnless(affected_files[0].LocalPath() ==
-                    presubmit.normpath('foo/blat.cc'))
-    self.failUnless(affected_files[1].LocalPath() ==
-                    presubmit.normpath('foo/blat/binary.dll'))
-    self.failUnless(affected_files[2].LocalPath() ==
-                    presubmit.normpath('foo/mat/beingdeleted.txt'))
+    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():
       rhs_lines.append(line)
     self.failUnless(len(rhs_lines) == 2)
     self.failUnless(rhs_lines[0][0].LocalPath() ==
                     presubmit.normpath('foo/blat.cc'))
 
   def testGetAbsoluteLocalPath(self):
     # Regression test for bug of presubmit stuff that relies on invoking
@@ skipping 119 matching lines @@
       'CheckChangeHasTestField', 'CheckDoNotSubmit',
       'CheckDoNotSubmitInDescription', 'CheckDoNotSubmitInFiles',
       'CheckLongLines', 'CheckTreeIsOpen',
     ]
     # If this test fails, you should add the relevant test.
     self.compareMembers(presubmit_canned_checks, members)
 
   def testCannedCheckChangeHasBugField(self):
     change = self.MakeBasicChange('foo',
                                   'Foo\nBUG=1234')
-    api = presubmit.InputApi(change, 'PRESUBMIT.py')
+    api = presubmit.InputApi(change, './PRESUBMIT.py')
     self.failIf(presubmit_canned_checks.CheckChangeHasBugField(
         api, presubmit.OutputApi))
 
     change = self.MakeBasicChange('foo',
                                   'Foo\nNEVERTESTED=did some stuff')
-    api = presubmit.InputApi(change, 'PRESUBMIT.py')
+    api = presubmit.InputApi(change, './PRESUBMIT.py')
     self.failUnless(presubmit_canned_checks.CheckChangeHasBugField(
         api, presubmit.OutputApi))
 
   def testCannedCheckChangeHasTestField(self):
     change = self.MakeBasicChange('foo',
                                   'Foo\nTEST=did some stuff')
-    api = presubmit.InputApi(change, 'PRESUBMIT.py')
+    api = presubmit.InputApi(change, './PRESUBMIT.py')
     self.failIf(presubmit_canned_checks.CheckChangeHasTestField(
         api, presubmit.OutputApi))
 
     change = self.MakeBasicChange('foo',
                                   'Foo\nNOTEST=did some stuff')
-    api = presubmit.InputApi(change, 'PRESUBMIT.py')
+    api = presubmit.InputApi(change, './PRESUBMIT.py')
     self.failUnless(presubmit_canned_checks.CheckChangeHasTestField(
         api, presubmit.OutputApi))
 
   def testCannedCheckChangeHasTestedField(self):
     change = self.MakeBasicChange('foo',
                                   'Foo\nTESTED=did some stuff')
-    api = presubmit.InputApi(change, 'PRESUBMIT.py')
+    api = presubmit.InputApi(change, './PRESUBMIT.py')
     self.failIf(presubmit_canned_checks.CheckChangeHasTestedField(
         api, presubmit.OutputApi))
 
     change = self.MakeBasicChange('foo',
                                   'Foo\nNEVERTESTED=did some stuff')
-    api = presubmit.InputApi(change, 'PRESUBMIT.py')
+    api = presubmit.InputApi(change, './PRESUBMIT.py')
     self.failUnless(presubmit_canned_checks.CheckChangeHasTestedField(
         api, presubmit.OutputApi))
 
   def testCannedCheckChangeHasQAField(self):
     change = self.MakeBasicChange('foo',
                                   'Foo\nQA=test floop feature very well')
-    api = presubmit.InputApi(change, 'PRESUBMIT.py')
+    api = presubmit.InputApi(change, './PRESUBMIT.py')
     self.failIf(presubmit_canned_checks.CheckChangeHasQaField(
         api, presubmit.OutputApi))
 
     change = self.MakeBasicChange('foo',
                                   'Foo\nNOTFORQA=test floop feature very well')
-    api = presubmit.InputApi(change, 'PRESUBMIT.py')
+    api = presubmit.InputApi(change, './PRESUBMIT.py')
     self.failUnless(presubmit_canned_checks.CheckChangeHasQaField(
         api, presubmit.OutputApi))
 
   def testCannedCheckDoNotSubmitInDescription(self):
     change = self.MakeBasicChange('foo', 'hello')
-    api = presubmit.InputApi(change, 'PRESUBMIT.py')
+    api = presubmit.InputApi(change, './PRESUBMIT.py')
     self.failIf(presubmit_canned_checks.CheckDoNotSubmitInDescription(
         api, presubmit.OutputApi))
 
     change = self.MakeBasicChange('foo',
                                   'DO NOT ' + 'SUBMIT')
-    api = presubmit.InputApi(change, 'PRESUBMIT.py')
+    api = presubmit.InputApi(change, './PRESUBMIT.py')
     self.failUnless(presubmit_canned_checks.CheckDoNotSubmitInDescription(
         api, presubmit.OutputApi))
 
   def testCannedCheckDoNotSubmitInFiles(self):
     self.failIf(presubmit_canned_checks.CheckDoNotSubmitInFiles(
       self.MockInputApi(['hello', 'there']), presubmit.OutputApi
     ))
     self.failUnless(presubmit_canned_checks.CheckDoNotSubmitInFiles(
       self.MockInputApi(['hello', 'yo, DO NOT ' + 'SUBMIT']),
                       presubmit.OutputApi))
@@ skipping 18 matching lines @@
     self.failIf(presubmit_canned_checks.CheckTreeIsOpen(
       self.MockInputApi(), presubmit.OutputApi, url='url_to_open', closed='0'
     ))
     self.failUnless(presubmit_canned_checks.CheckTreeIsOpen(
       self.MockInputApi(), presubmit.OutputApi, url='url_to_closed', closed='0'
     ))
 
 
 if __name__ == '__main__':
   unittest.main()