Add verbose support throught presubmit 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,R0201,W0212,W0403
 
@@ skipping 121 matching lines @@
   """General presubmit_support.py tests (excluding InputApi and OutputApi)."""
 
   _INHERIT_SETTINGS = 'inherit-review-settings-ok'
 
   def testMembersChanged(self):
     self.mox.ReplayAll()
     members = [
       'AffectedFile', 'Change', 'DoGetTrySlaves', 'DoPresubmitChecks',
       'GetTrySlavesExecuter', 'GitAffectedFile',
       'GitChange', 'InputApi', 'ListRelevantPresubmitFiles', 'Main',
-      'NotImplementedException', 'OutputApi', 'ParseFiles',
+      'OutputApi', 'ParseFiles', 'PresubmitFailure',
       'PresubmitExecuter', 'PresubmitOutput', 'ScanSubDirs',
       'SvnAffectedFile', 'SvnChange', 'cPickle', 'cStringIO',
-      'exceptions', 'fix_encoding', 'fnmatch', 'gclient_utils', 'glob', 'json',
+      'fix_encoding', 'fnmatch', 'gclient_utils', 'glob', 'json',
       'load_files',
       'logging', 'marshal', 'normpath', 'optparse', 'os', 'owners', 'pickle',
       'presubmit_canned_checks', 'random', 're', 'scm', 'subprocess',
       'sys', 'tempfile', 'time', 'traceback', 'types', 'unittest', 'urllib2',
       'warn',
     ]
     # If this test fails, you should add the relevant test.
     self.compareMembers(presubmit, members)
 
   def testListRelevantPresubmitFiles(self):
@@ skipping 182 matching lines @@
                          'this is a change',
                          'STORY=http://tracker/123')
     files = [
       ['A', 'foo\\blat.cc'],
     ]
     fake_presubmit = presubmit.os.path.join(self.fake_root_dir, 'PRESUBMIT.py')
     self.mox.ReplayAll()
 
     change = presubmit.Change('mychange', '\n'.join(description_lines),
                               self.fake_root_dir, files, 0, 0)
-    executer = presubmit.PresubmitExecuter(change, False, False, None)
+    executer = presubmit.PresubmitExecuter(change, False, False, None, False)
     self.failIf(executer.ExecPresubmitScript('', fake_presubmit))
     # No error if no on-upload entry point
     self.failIf(executer.ExecPresubmitScript(
       ('def CheckChangeOnCommit(input_api, output_api):\n'
        '  return (output_api.PresubmitError("!!"))\n'),
       fake_presubmit
     ))
 
-    executer = presubmit.PresubmitExecuter(change, True, False, None)
+    executer = presubmit.PresubmitExecuter(change, True, False, None, False)
     # No error if no on-commit entry point
     self.failIf(executer.ExecPresubmitScript(
       ('def CheckChangeOnUpload(input_api, output_api):\n'
        '  return (output_api.PresubmitError("!!"))\n'),
       fake_presubmit
     ))
 
     self.failIf(executer.ExecPresubmitScript(
       ('def CheckChangeOnUpload(input_api, output_api):\n'
        '  if not input_api.change.STORY:\n'
        '    return (output_api.PresubmitError("!!"))\n'
        '  else:\n'
        '    return ()'),
       fake_presubmit
     ))
 
     self.failUnless(executer.ExecPresubmitScript(
       ('def CheckChangeOnCommit(input_api, output_api):\n'
        '  if not input_api.change.NOSUCHKEY:\n'
        '    return [output_api.PresubmitError("!!")]\n'
        '  else:\n'
        '    return ()'),
       fake_presubmit
     ))
 
-    self.assertRaises(presubmit.exceptions.RuntimeError,
+    self.assertRaises(presubmit.PresubmitFailure,
       executer.ExecPresubmitScript,
       'def CheckChangeOnCommit(input_api, output_api):\n'
       '  return "foo"',
       fake_presubmit)
 
-    self.assertRaises(presubmit.exceptions.RuntimeError,
+    self.assertRaises(presubmit.PresubmitFailure,
       executer.ExecPresubmitScript,
       'def CheckChangeOnCommit(input_api, output_api):\n'
       '  return ["foo"]',
       fake_presubmit)
 
   def testDoPresubmitChecks(self):
     join = presubmit.os.path.join
     description_lines = ('Hello there',
                          'this is a change',
                          'STORY=http://tracker/123')
@@ skipping 211 matching lines @@
                        '\n'
                        '** Presubmit Messages **\n'
                        'http://tracker.com/42\n'
                        '\n'
                        'Presubmit checks passed.\n'))
 
   def testGetTrySlavesExecuter(self):
     self.mox.ReplayAll()
 
     executer = presubmit.GetTrySlavesExecuter()
-    self.assertEqual([], executer.ExecPresubmitScript(''))
-    self.assertEqual([], executer.ExecPresubmitScript('def foo():\n  return\n'))
+    self.assertEqual([], executer.ExecPresubmitScript('', ''))
+    self.assertEqual(
+        [], executer.ExecPresubmitScript('def foo():\n  return\n', ''))
 
     # bad results
     starts_with_space_result = ['  starts_with_space']
     not_list_result1 = "'foo'"
     not_list_result2 = "('a', 'tuple')"
     for result in starts_with_space_result, not_list_result1, not_list_result2:
-      self.assertRaises(presubmit.exceptions.RuntimeError,
+      self.assertRaises(presubmit.PresubmitFailure,
                         executer.ExecPresubmitScript,
-                        self.presubmit_tryslave % result)
+                        self.presubmit_tryslave % result, '')
 
     # good results
     expected_result = ['1', '2', '3']
     empty_result = []
     space_in_name_result = ['foo bar', '1\t2 3']
     for result in expected_result, empty_result, space_in_name_result:
-      self.assertEqual(result,
-                       executer.ExecPresubmitScript(self.presubmit_tryslave %
-                                                    str(result)))
+      self.assertEqual(
+          result,
+          executer.ExecPresubmitScript(self.presubmit_tryslave % result, ''))
 
   def testDoGetTrySlaves(self):
     join = presubmit.os.path.join
     filename = 'foo.cc'
     filename_linux = join('linux_only', 'penguin.cc')
     root_presubmit = join(self.fake_root_dir, 'PRESUBMIT.py')
     linux_presubmit = join(self.fake_root_dir, 'linux_only', 'PRESUBMIT.py')
     inherit_path = presubmit.os.path.join(self.fake_root_dir,
                                           self._INHERIT_SETTINGS)
 
@@ skipping 72 matching lines @@
       'AbsoluteLocalPaths', 'AffectedFiles', 'AffectedSourceFiles',
       'AffectedTextFiles',
       'DEFAULT_BLACK_LIST', 'DEFAULT_WHITE_LIST',
       'DepotToLocalPath', 'FilterSourceFile', 'LocalPaths',
       'LocalToDepotPath',
       'PresubmitLocalPath', 'ReadFile', 'RightHandSideLines', 'ServerPaths',
       'basename', 'cPickle', 'cStringIO', 'canned_checks', 'change', 'environ',
       'host_url', 'is_committing', 'json', 'marshal', 'os_listdir', 'os_walk',
       'os_path', 'owners_db', 'pickle', 'platform', 'python_executable', 're',
       'subprocess', 'tbr', 'tempfile', 'time', 'traceback', 'unittest',
-      'urllib2', 'version',
+      'urllib2', 'version', 'verbose',
     ]
     # If this test fails, you should add the relevant test.
-    self.compareMembers(presubmit.InputApi(self.fake_change, './.', False,
-                                           False, None),
-                        members)
+    self.compareMembers(
+        presubmit.InputApi(self.fake_change, './.', False, False, None, False),
+        members)
 
   def testDepotToLocalPath(self):
     presubmit.scm.SVN.CaptureInfo('svn://foo/smurf').AndReturn(
         {'Path': 'prout'})
     presubmit.scm.SVN.CaptureInfo('svn:/foo/notfound/burp').AndReturn({})
     self.mox.ReplayAll()
 
-    path = presubmit.InputApi(self.fake_change, './p', False, False,
-        None).DepotToLocalPath('svn://foo/smurf')
+    path = presubmit.InputApi(
+        self.fake_change, './p', False, False, None, False).DepotToLocalPath(
+            'svn://foo/smurf')
     self.failUnless(path == 'prout')
-    path = presubmit.InputApi(self.fake_change, './p', False, False,
-        None).DepotToLocalPath('svn:/foo/notfound/burp')
+    path = presubmit.InputApi(
+        self.fake_change, './p', False, False, None, False).DepotToLocalPath(
+            'svn:/foo/notfound/burp')
     self.failUnless(path == None)
 
   def testLocalToDepotPath(self):
     presubmit.scm.SVN.CaptureInfo('smurf').AndReturn({'URL': 'svn://foo'})
     presubmit.scm.SVN.CaptureInfo('notfound-food').AndReturn({})
     self.mox.ReplayAll()
-    path = presubmit.InputApi(self.fake_change, './p', False, False,
-        None).LocalToDepotPath('smurf')
+    path = presubmit.InputApi(
+        self.fake_change, './p', False, False, None, False).LocalToDepotPath(
+            'smurf')
     self.assertEqual(path, 'svn://foo')
-    path = presubmit.InputApi(self.fake_change, './p', False, False,
-        None).LocalToDepotPath('notfound-food')
-    self.failUnless(path == None)
+    path = presubmit.InputApi(
+        self.fake_change, './p', False, False, None, False).LocalToDepotPath(
+            'notfound-food')
+    self.assertEquals(path, None)
 
   def testInputApiConstruction(self):
     self.mox.ReplayAll()
-    api = presubmit.InputApi(self.fake_change,
-                             presubmit_path='foo/path/PRESUBMIT.py',
-                             is_committing=False, tbr=False, host_url=None)
+    api = presubmit.InputApi(
+        self.fake_change,
+        presubmit_path='foo/path/PRESUBMIT.py',
+        is_committing=False, tbr=False, host_url=None, verbose=False)
     self.assertEquals(api.PresubmitLocalPath(), 'foo/path')
     self.assertEquals(api.change, self.fake_change)
     self.assertEquals(api.host_url, 'http://codereview.chromium.org')
 
   def testInputApiPresubmitScriptFiltering(self):
     join = presubmit.os.path.join
     description_lines = ('Hello there',
                          'this is a change',
                          'BUG=123',
                          ' STORY =http://foo/  \t',
@@ skipping 35 matching lines @@
     presubmit.scm.SVN.GetFileProperty(another, 'svn:mime-type').AndReturn(None)
     presubmit.scm.SVN.GetFileProperty(third_party, 'svn:mime-type'
         ).AndReturn(None)
     presubmit.scm.SVN.GenerateDiff([blat]).AndReturn(self.presubmit_diffs)
     presubmit.scm.SVN.GenerateDiff([another]).AndReturn(self.presubmit_diffs)
 
     self.mox.ReplayAll()
 
     change = presubmit.SvnChange('mychange', '\n'.join(description_lines),
                                  self.fake_root_dir, files, 0, 0)
-    input_api = presubmit.InputApi(change,
-                                   join(self.fake_root_dir, 'foo',
-                                        'PRESUBMIT.py'),
-                                   False, False, None)
+    input_api = presubmit.InputApi(
+        change,
+        join(self.fake_root_dir, 'foo', 'PRESUBMIT.py'),
+        False, False, None, False)
     # Doesn't filter much
     got_files = input_api.AffectedFiles()
     self.assertEquals(len(got_files), 7)
     self.assertEquals(got_files[0].LocalPath(), presubmit.normpath(files[0][1]))
     self.assertEquals(got_files[1].LocalPath(), presubmit.normpath(files[1][1]))
     self.assertEquals(got_files[2].LocalPath(), presubmit.normpath(files[2][1]))
     self.assertEquals(got_files[3].LocalPath(), presubmit.normpath(files[3][1]))
     self.assertEquals(got_files[4].LocalPath(), presubmit.normpath(files[4][1]))
     self.assertEquals(got_files[5].LocalPath(), presubmit.normpath(files[5][1]))
     self.assertEquals(got_files[6].LocalPath(), presubmit.normpath(files[6][1]))
@@ skipping 64 matching lines @@
           f('a/.git'),
           f('b.c/.git'),
           f('a/.git/bleh.py'),
           f('.git/bleh.py'),
         ],
         [
           # Expected.
         ],
       ),
     ]
-    input_api = presubmit.InputApi(self.fake_change, './PRESUBMIT.py', False,
-        False, None)
+    input_api = presubmit.InputApi(
+        self.fake_change, './PRESUBMIT.py', False,
+        False, None, False)
     self.mox.ReplayAll()
 
     self.assertEqual(len(input_api.DEFAULT_WHITE_LIST), 22)
     self.assertEqual(len(input_api.DEFAULT_BLACK_LIST), 9)
     for item in files:
       results = filter(input_api.FilterSourceFile, item[0])
       for i in range(len(results)):
         self.assertEquals(results[i].LocalPath(),
                           presubmit.normpath(item[1][i]))
       # Same number of expected results.
       self.assertEquals(sorted([f.LocalPath().replace(presubmit.os.sep, '/')
                                 for f in results]),
                         sorted(item[1]))
 
   def testCustomFilter(self):
     def FilterSourceFile(affected_file):
       return 'a' in affected_file.LocalPath()
     files = [('A', 'eeaee'), ('M', 'eeabee'), ('M', 'eebcee')]
     for _, item in files:
       item = presubmit.os.path.join(self.fake_root_dir, item)
       presubmit.os.path.exists(item).AndReturn(True)
       presubmit.os.path.isdir(item).AndReturn(False)
       presubmit.scm.SVN.GetFileProperty(item, 'svn:mime-type').AndReturn(None)
     self.mox.ReplayAll()
 
     change = presubmit.SvnChange('mychange', '', self.fake_root_dir, files, 0,
                                  0)
-    input_api = presubmit.InputApi(change,
-                                   presubmit.os.path.join(self.fake_root_dir,
-                                                          'PRESUBMIT.py'),
-                                   False, False, None)
+    input_api = presubmit.InputApi(
+        change,
+        presubmit.os.path.join(self.fake_root_dir, 'PRESUBMIT.py'),
+        False, False, None, False)
     got_files = input_api.AffectedSourceFiles(FilterSourceFile)
     self.assertEquals(len(got_files), 2)
     self.assertEquals(got_files[0].LocalPath(), 'eeaee')
     self.assertEquals(got_files[1].LocalPath(), 'eeabee')
 
   def testLambdaFilter(self):
     white_list = presubmit.InputApi.DEFAULT_BLACK_LIST + (r".*?a.*?",)
     black_list = [r".*?b.*?"]
     files = [('A', 'eeaee'), ('M', 'eeabee'), ('M', 'eebcee'), ('M', 'eecaee')]
     for _, item in files:
       item = presubmit.os.path.join(self.fake_root_dir, item)
       presubmit.os.path.exists(item).AndReturn(True)
       presubmit.os.path.isdir(item).AndReturn(False)
       presubmit.scm.SVN.GetFileProperty(item, 'svn:mime-type').AndReturn(None)
     self.mox.ReplayAll()
 
     change = presubmit.SvnChange('mychange', '', self.fake_root_dir, files, 0,
                                  0)
-    input_api = presubmit.InputApi(change, './PRESUBMIT.py', False,
-                                   False, None)
+    input_api = presubmit.InputApi(
+        change, './PRESUBMIT.py', False, False, None, False)
     # Sample usage of overiding the default white and black lists.
     got_files = input_api.AffectedSourceFiles(
         lambda x: input_api.FilterSourceFile(x, white_list, black_list))
     self.assertEquals(len(got_files), 2)
     self.assertEquals(got_files[0].LocalPath(), 'eeaee')
     self.assertEquals(got_files[1].LocalPath(), 'eecaee')
 
   def testGetAbsoluteLocalPath(self):
     join = presubmit.os.path.join
     normpath = presubmit.normpath
@@ skipping 17 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,
-                             is_committing=True, tbr=False, host_url=None)
+    api = presubmit.InputApi(
+        change=change, presubmit_path=presubmit_path,
+        is_committing=True, tbr=False, host_url=None, verbose=False)
     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.warn(mox.IgnoreArg(), category=mox.IgnoreArg(), stacklevel=2)
     self.mox.ReplayAll()
 
     change = presubmit.Change('mychange', '', self.fake_root_dir, [], 0, 0)
     api = presubmit.InputApi(
         change,
         presubmit.os.path.join(self.fake_root_dir, 'foo', 'PRESUBMIT.py'), True,
-        False, None)
+        False, None, False)
     api.AffectedTextFiles(include_deletes=False)
 
   def testReadFileStringDenied(self):
     self.mox.ReplayAll()
 
     change = presubmit.Change('foo', 'foo', self.fake_root_dir, [('M', 'AA')],
                               0, 0)
     input_api = presubmit.InputApi(
         change, presubmit.os.path.join(self.fake_root_dir, '/p'), False,
-        False, None)
+        False, None, False)
     self.assertRaises(IOError, input_api.ReadFile, 'boo', 'x')
 
   def testReadFileStringAccepted(self):
     path = presubmit.os.path.join(self.fake_root_dir, 'AA/boo')
     presubmit.gclient_utils.FileRead(path, 'x').AndReturn(None)
     self.mox.ReplayAll()
 
     change = presubmit.Change('foo', 'foo', self.fake_root_dir, [('M', 'AA')],
                               0, 0)
     input_api = presubmit.InputApi(
         change, presubmit.os.path.join(self.fake_root_dir, '/p'), False,
-        False, None)
+        False, None, False)
     input_api.ReadFile(path, 'x')
 
   def testReadFileAffectedFileDenied(self):
     fileobj = presubmit.AffectedFile('boo', 'M', 'Unrelated')
     self.mox.ReplayAll()
 
     change = presubmit.Change('foo', 'foo', self.fake_root_dir, [('M', 'AA')],
                               0, 0)
     input_api = presubmit.InputApi(
         change, presubmit.os.path.join(self.fake_root_dir, '/p'), False,
-        False, None)
+        False, None, False)
     self.assertRaises(IOError, input_api.ReadFile, fileobj, 'x')
 
   def testReadFileAffectedFileAccepted(self):
     fileobj = presubmit.AffectedFile('AA/boo', 'M', self.fake_root_dir)
     presubmit.gclient_utils.FileRead(fileobj.AbsoluteLocalPath(), 'x'
                                      ).AndReturn(None)
     self.mox.ReplayAll()
 
     change = presubmit.Change('foo', 'foo', self.fake_root_dir, [('M', 'AA')],
                               0, 0)
     input_api = presubmit.InputApi(
         change, presubmit.os.path.join(self.fake_root_dir, '/p'), False,
-        False, None)
+        False, None, False)
     input_api.ReadFile(fileobj, 'x')
 
 
 class OuputApiUnittest(PresubmitTestsBase):
   """Tests presubmit.OutputApi."""
   def testMembersChanged(self):
     self.mox.ReplayAll()
     members = [
       'MailTextResult', 'PresubmitAddReviewers', 'PresubmitError',
       'PresubmitNotifyResult', 'PresubmitPromptWarning', 'PresubmitResult',
@@ skipping 916 matching lines @@
         expected_output='Missing LGTM from an OWNER for: foo.cc\n')
 
   def testCannedCheckOwners_WithLGTMs(self):
     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)
+    input_api.verbose = True
     unit_tests = ['allo', 'bar.py']
     input_api.PresubmitLocalPath().AndReturn(self.fake_root_dir)
     input_api.PresubmitLocalPath().AndReturn(self.fake_root_dir)
     input_api.subprocess.check_call(
         ['allo'], cwd=self.fake_root_dir)
     cmd = ['bar.py']
     if input_api.platform == 'win32':
       cmd.insert(0, input_api.python_executable)
     input_api.subprocess.check_call(
         cmd, 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)
+        unit_tests)
     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.verbose = True
     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('.')
     input_api.subprocess.check_call(
         [presubmit.os.path.join('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)
+        blacklist=['a'])
     self.assertEqual(results, [])
     self.checkstdout(
         'Running %s\n' % presubmit.os.path.join('random_directory', 'b'))
 
 
 if __name__ == '__main__':
   import unittest
   unittest.main()