Make git-cl work with OWNERS files in a non .git/hooks/pre-cl-* world

tests/presubmit_unittest.py

 #!/usr/bin/python
 # Copyright (c) 2010 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
 
@@ skipping 324 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)
+    executer = presubmit.PresubmitExecuter(change, False, False, None)
     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)
+    executer = presubmit.PresubmitExecuter(change, True, False, None)
     # 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'
@@ skipping 328 matching lines @@
   def testMembersChanged(self):
     self.mox.ReplayAll()
     members = [
       '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', 'is_tbr', 'json', 'marshal', 'os_path',
+      'host_url', 'is_committing', 'json', 'marshal', 'os_path',
       'owners_db', 'pickle', 'platform', 'python_executable', 're',
-      'subprocess', 'tempfile', 'traceback', 'unittest', 'urllib2', 'version',
+      'subprocess', 'tbr', 'tempfile', 'traceback', 'unittest', 'urllib2',
+      'version',
     ]
     # If this test fails, you should add the relevant test.
-    self.compareMembers(presubmit.InputApi(self.fake_change, './.', False),
+    self.compareMembers(presubmit.InputApi(self.fake_change, './.', False,
+                                           False, None),
                         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).DepotToLocalPath(
-        'svn://foo/smurf')
+    path = presubmit.InputApi(self.fake_change, './p', False, False,
+        None).DepotToLocalPath('svn://foo/smurf')
     self.failUnless(path == 'prout')
-    path = presubmit.InputApi(self.fake_change, './p', False).DepotToLocalPath(
-        'svn:/foo/notfound/burp')
+    path = presubmit.InputApi(self.fake_change, './p', False, False,
+        None).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).LocalToDepotPath(
-        'smurf')
+    path = presubmit.InputApi(self.fake_change, './p', False, False,
+        None).LocalToDepotPath('smurf')
     self.assertEqual(path, 'svn://foo')
-    path = presubmit.InputApi(self.fake_change, './p', False).LocalToDepotPath(
-        'notfound-food')
+    path = presubmit.InputApi(self.fake_change, './p', False, False,
+        None).LocalToDepotPath('notfound-food')
     self.failUnless(path == None)
 
   def testInputApiConstruction(self):
     self.mox.ReplayAll()
     api = presubmit.InputApi(self.fake_change,
                              presubmit_path='foo/path/PRESUBMIT.py',
-                             is_committing=False)
+                             is_committing=False, tbr=False, host_url=None)
     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',
                          'and some more regular text')
     files = [
       ['A', join('foo', 'blat.cc')],
@@ skipping 35 matching lines @@
     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, False, None)
     # 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)
+    input_api = presubmit.InputApi(self.fake_change, './PRESUBMIT.py', False,
+        False, None)
     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.
@@ skipping 10 matching lines @@
       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, False, None)
     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)
+    input_api = presubmit.InputApi(change, './PRESUBMIT.py', False,
+                                   False, None)
     # 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 19 matching lines @@
                       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)
+                             is_committing=True, tbr=False, host_url=None)
     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)
+        presubmit.os.path.join(self.fake_root_dir, 'foo', 'PRESUBMIT.py'), True,
+        False, None)
     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)
+        change, presubmit.os.path.join(self.fake_root_dir, '/p'), False,
+        False, None)
     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)
+        change, presubmit.os.path.join(self.fake_root_dir, '/p'), False,
+        False, None)
     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)
+        change, presubmit.os.path.join(self.fake_root_dir, '/p'), False,
+        False, None)
     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)
+        change, presubmit.os.path.join(self.fake_root_dir, '/p'), False,
+        False, None)
     input_api.ReadFile(fileobj, 'x')
 
 
 class OuputApiUnittest(PresubmitTestsBase):
   """Tests presubmit.OutputApi."""
   def testMembersChanged(self):
     self.mox.ReplayAll()
     members = [
       'MailTextResult', 'PresubmitAddText', 'PresubmitError',
       'PresubmitNotifyResult', 'PresubmitPromptWarning', 'PresubmitResult',
     ]
     # If this test fails, you should add the relevant test.
     self.compareMembers(presubmit.OutputApi(), members)
 
   def testOutputApiBasics(self):
     self.mox.ReplayAll()
     self.failUnless(presubmit.OutputApi.PresubmitError('').IsFatal())
-    self.failUnless(presubmit.OutputApi.PresubmitError('').IsMessage())
     self.failIf(presubmit.OutputApi.PresubmitError('').ShouldPrompt())
 
     self.failIf(presubmit.OutputApi.PresubmitPromptWarning('').IsFatal())
     self.failUnless(
         presubmit.OutputApi.PresubmitPromptWarning('').ShouldPrompt())
-    self.failUnless(
-        presubmit.OutputApi.PresubmitPromptWarning('').IsMessage())
 
     self.failIf(presubmit.OutputApi.PresubmitNotifyResult('').IsFatal())
     self.failIf(presubmit.OutputApi.PresubmitNotifyResult('').ShouldPrompt())
-    self.failUnless(
-        presubmit.OutputApi.PresubmitNotifyResult('foo').IsMessage())
 
     self.failIf(presubmit.OutputApi.PresubmitAddText('foo').IsFatal())
     self.failIf(presubmit.OutputApi.PresubmitAddText('foo').ShouldPrompt())
-    self.failIf(presubmit.OutputApi.PresubmitAddText('foo').IsMessage())
 
     # TODO(joi) Test MailTextResult once implemented.
 
   def testOutputApiHandling(self):
     self.mox.ReplayAll()
 
     output = StringIO.StringIO()
     unused_input = StringIO.StringIO()
     added_text = presubmit.OutputApi.PresubmitAddText('R=ben@example.com')
     self.failUnless(added_text._Handle(output, unused_input))
@@ skipping 134 matching lines @@
     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)
 
     input_api.change = change
     input_api.host_url = 'http://localhost'
     input_api.is_committing = committing
-    input_api.ts_tbr = False
+    input_api.tbr = False
     input_api.python_executable = 'pyyyyython'
     return input_api
 
   def testMembersChanged(self):
     self.mox.ReplayAll()
     members = [
       'CheckChangeHasBugField', 'CheckChangeHasDescription',
       'CheckChangeHasNoStrayWhitespace',
       'CheckChangeHasOnlyOneEol', 'CheckChangeHasNoCR',
       'CheckChangeHasNoCrAndHasOnlyOneEol', 'CheckChangeHasNoTabs',
@@ skipping 622 matching lines @@
     }""")
     connection.close()
     self.mox.ReplayAll()
 
     results = presubmit_canned_checks.CheckBuildbotPendingBuilds(
         input_api, presubmit.OutputApi, 'uurl', 2, ('foo'))
     self.assertEquals(len(results), 1)
     self.assertEquals(results[0].__class__,
         presubmit.OutputApi.PresubmitNotifyResult)
 
-  def OwnersTest(self, is_committing, is_tbr=False, change_tags=None,
+  def OwnersTest(self, is_committing, tbr=False, change_tags=None,
       suggested_reviewers=None, approvers=None,
       uncovered_files=None, expected_results=None):
     affected_file = self.mox.CreateMock(presubmit.SvnAffectedFile)
     affected_file.LocalPath().AndReturn('foo.cc')
     change = self.mox.CreateMock(presubmit.Change)
     change.AffectedFiles(None).AndReturn([affected_file])
 
     input_api = self.MockInputApi(change, False)
     fake_db = self.mox.CreateMock(owners.Database)
     fake_db.email_regexp = input_api.re.compile(owners.BASIC_EMAIL_REGEXP)
     input_api.owners_db = fake_db
     input_api.is_committing = is_committing
-    input_api.is_tbr = is_tbr
+    input_api.tbr = tbr
 
-    if is_committing and not is_tbr:
+    if is_committing and not tbr:
       change.issue = '1'
       messages = list('{"sender": "' + a + '","text": "lgtm"}' for
                       a in approvers)
       rietveld_response = ('{"owner": "john@example.com",'
-                          '"messages": [' + ','.join(messages) + ']}')
+                           '"messages": [' + ','.join(messages) + ']}')
       input_api.urllib2.urlopen(
           input_api.host_url + '/api/1?messages=true').AndReturn(
           StringIO.StringIO(rietveld_response))
       input_api.json = presubmit.json
       fake_db.files_not_covered_by(set(['foo.cc']), approvers).AndReturn(
           uncovered_files)
     elif not is_committing:
       change.tags = change_tags
       if not change_tags.get('R'):
         fake_db.reviewers_for(set(['foo.cc'])).AndReturn(suggested_reviewers)
 
     self.mox.ReplayAll()
     results = presubmit_canned_checks.CheckOwners(input_api,
         presubmit.OutputApi)
     self.assertEquals(len(results), len(expected_results))
     if results and expected_results:
       output = StringIO.StringIO()
       unused_input = StringIO.StringIO()
       results[0]._Handle(output, unused_input)
       self.assertEquals(output.getvalue(), expected_results[0])
 
   def testCannedCheckOwners_WithReviewer(self):
     self.OwnersTest(is_committing=False, change_tags={'R': 'ben@example.com'},
         expected_results=[])
-    self.OwnersTest(is_committing=False, is_tbr=True,
+    self.OwnersTest(is_committing=False, tbr=True,
         change_tags={'R': 'ben@example.com'}, expected_results=[])
 
   def testCannedCheckOwners_NoReviewer(self):
     self.OwnersTest(is_committing=False, change_tags={},
         suggested_reviewers=['ben@example.com'],
         expected_results=['ADD: R=ben@example.com\n'])
-    self.OwnersTest(is_committing=False, is_tbr=True, change_tags={},
+    self.OwnersTest(is_committing=False, tbr=True, change_tags={},
         suggested_reviewers=['ben@example.com'],
         expected_results=['ADD: R=ben@example.com\n'])
 
   def testCannedCheckOwners_CommittingWithoutOwnerLGTM(self):
     self.OwnersTest(is_committing=True,
         approvers=set(),
         uncovered_files=set(['foo.cc']),
         expected_results=['Missing LGTM from an OWNER for: foo.cc\n'])
 
   def testCannedCheckOwners_CommittingWithLGTMs(self):
     self.OwnersTest(is_committing=True,
         approvers=set(['ben@example.com']),
         uncovered_files=set(),
         expected_results=[])
 
   def testCannedCheckOwners_TBR(self):
-    self.OwnersTest(is_committing=True, is_tbr=True,
+    self.OwnersTest(is_committing=True, tbr=True,
         approvers=set(),
         uncovered_files=set(),
         expected_results=['--tbr was specified, skipping OWNERS check\n'])
 
 if __name__ == '__main__':
   import unittest
   unittest.main()