Reland Implement owners check in presubmit for Gerrit.

tests/presubmit_unittest.py

 #!/usr/bin/env python
 # Copyright (c) 2012 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: disable=E1101,E1103
 
 import StringIO
@@ skipping 166 matching lines @@
       'NonexistantCannedCheckFilter', 'OutputApi', 'ParseFiles',
       'PresubmitFailure', 'PresubmitExecuter', 'PresubmitOutput', 'ScanSubDirs',
       'SvnAffectedFile', 'SvnChange', 'auth', 'cPickle', 'cpplint', 'cStringIO',
       'contextlib', 'canned_check_filter', 'fix_encoding', 'fnmatch',
       'gclient_utils', 'glob', 'inspect', 'json', 'load_files', 'logging',
       'marshal', 'normpath', 'optparse', 'os', 'owners', 'pickle',
       'presubmit_canned_checks', 'random', 're', 'rietveld', 'scm',
       'subprocess', 'sys', 'tempfile', 'time', 'traceback', 'types', 'unittest',
       'urllib2', 'warn', 'multiprocessing', 'DoGetTryMasters',
       'GetTryMastersExecuter', 'itertools', 'urlparse', 'gerrit_util',
+      'GerritAccessor',
     ]
     # If this test fails, you should add the relevant test.
     self.compareMembers(presubmit, members)
 
   def testCannedCheckFilter(self):
     canned = presubmit.presubmit_canned_checks
     orig = canned.CheckOwners
     with presubmit.canned_check_filter(['CheckOwners']):
       self.assertNotEqual(canned.CheckOwners, orig)
       self.assertEqual(canned.CheckOwners(None, None), [])
@@ skipping 624 matching lines @@
     # Always fail.
     change = presubmit.Change(
         'mychange',
         '\n'.join(description_lines),
         self.fake_root_dir,
         files,
         0,
         0,
         None)
     output = presubmit.DoPresubmitChecks(
-        change, False, True, None, input_buf, DEFAULT_SCRIPT, False, None)
+        change, False, True, None, input_buf, DEFAULT_SCRIPT, False, None, None,
+        None)
     self.failIf(output.should_continue())
     text = (
         'Running presubmit upload checks ...\n'
         'Warning, no PRESUBMIT.py found.\n'
         'Running default presubmit script.\n'
         '\n'
         '** Presubmit ERRORS **\n!!\n\n'
         'Was the presubmit check useful? If not, run "git cl presubmit -v"\n'
         'to figure out which PRESUBMIT.py was run, then run git blame\n'
         'on the file to figure out who to ask for help.\n')
@@ skipping 61 matching lines @@
     input_buf = StringIO.StringIO('y\n')
     change = presubmit.Change(
         'foo',
         'Blah Blah\n\nSTORY=http://tracker.com/42\nBUG=boo\n',
         self.fake_root_dir,
         None,
         0,
         0,
         None)
     self.failUnless(presubmit.DoPresubmitChecks(
-        change, False, True, output, input_buf, DEFAULT_SCRIPT, False, None))
+        change, False, True, output, input_buf, DEFAULT_SCRIPT, False, None,
+        None))
     self.assertEquals(output.getvalue(),
                       ('Running presubmit upload checks ...\n'
                        'Warning, no PRESUBMIT.py found.\n'
                        'Running default presubmit script.\n'
                        '\n'
                        '** Presubmit Messages **\n'
                        'http://tracker.com/42\n'
                        '\n'
                        'Presubmit checks passed.\n'))
 
@@ skipping 222 matching lines @@
     self.mox.StubOutWithMock(presubmit, 'ParseFiles')
     presubmit.scm.determine_scm(self.fake_root_dir).AndReturn(None)
     presubmit.ParseFiles(['random_file.txt'], None
         ).AndReturn([('M', 'random_file.txt')])
     output = self.mox.CreateMock(presubmit.PresubmitOutput)
     output.should_continue().AndReturn(False)
 
     presubmit.DoPresubmitChecks(mox.IgnoreArg(), False, False,
                                 mox.IgnoreArg(),
                                 mox.IgnoreArg(),
-                                None, False, None, None).AndReturn(output)
+                                None, False, None, None, None).AndReturn(output)
     self.mox.ReplayAll()
 
     self.assertEquals(
         True,
         presubmit.main(['--root', self.fake_root_dir, 'random_file.txt']))
 
   def testMainUnversionedFail(self):
     # OptParser calls presubmit.os.path.exists and is a pain when mocked.
     self.UnMock(presubmit.os.path, 'exists')
     self.mox.StubOutWithMock(presubmit, 'DoPresubmitChecks')
@@ skipping 23 matching lines @@
       'AbsoluteLocalPaths', 'AffectedFiles', 'AffectedSourceFiles',
       'AffectedTextFiles', 'DEFAULT_BLACK_LIST', 'DEFAULT_WHITE_LIST',
       'DepotToLocalPath', 'FilterSourceFile', 'LocalPaths', 'LocalToDepotPath',
       'Command', 'RunTests', 'PresubmitLocalPath', 'ReadFile',
       'RightHandSideLines', 'ServerPaths', 'basename', 'cPickle', 'cpplint',
       'cStringIO', 'canned_checks', 'change', 'cpu_count', 'environ', 'glob',
       'host_url', 'is_committing', 'json', 'logging', 'marshal', 'os_listdir',
       'os_walk', 'os_path', 'os_stat', 'owners_db', 'pickle', 'platform',
       'python_executable', 're', 'rietveld', 'subprocess', 'tbr', 'tempfile',
       'time', 'traceback', 'unittest', 'urllib2', 'version', 'verbose',
-      'dry_run',
+      'dry_run', 'gerrit',
     ]
     # If this test fails, you should add the relevant test.
     self.compareMembers(
         presubmit.InputApi(self.fake_change, './.', False, None, False),
         members)
 
   def testDepotToLocalPath(self):
     presubmit.scm.SVN._CaptureInfo(['svn://foo/smurf'], self.fake_root_dir
         ).AndReturn({'Path': 'prout'})
     presubmit.scm.SVN._CaptureInfo(
@@ skipping 621 matching lines @@
     # pylint: disable=R0201
     input_api = self.mox.CreateMock(presubmit.InputApi)
     input_api.cStringIO = presubmit.cStringIO
     input_api.json = presubmit.json
     input_api.logging = logging
     input_api.os_listdir = self.mox.CreateMockAnything()
     input_api.os_walk = self.mox.CreateMockAnything()
     input_api.os_path = presubmit.os.path
     input_api.re = presubmit.re
     input_api.rietveld = self.mox.CreateMock(rietveld.Rietveld)
+    input_api.gerrit = None
     input_api.traceback = presubmit.traceback
     input_api.urllib2 = self.mox.CreateMock(presubmit.urllib2)
     input_api.unittest = unittest
     input_api.subprocess = self.mox.CreateMock(subprocess)
     presubmit.subprocess = input_api.subprocess
     class fake_CalledProcessError(Exception):
       def __str__(self):
         return 'foo'
     input_api.subprocess.CalledProcessError = fake_CalledProcessError
     input_api.verbose = False
@@ skipping 702 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 AssertOwnersWorks(self, tbr=False, issue='1', approvers=None,
-      reviewers=None, is_committing=True, rietveld_response=None,
+      reviewers=None, is_committing=True,
+      rietveld_response=None, gerrit_response=None,
       uncovered_files=None, expected_output='',
       manually_specified_reviewers=None, dry_run=None):
     if approvers is None:
       # The set of people who lgtm'ed a change.
       approvers = set()
     if reviewers is None:
       # The set of people needed to lgtm a change. We default to
       # the same list as the people who approved it. We use 'reviewers'
       # to avoid a name collision w/ owners.py.
       reviewers = approvers
     if uncovered_files is None:
       uncovered_files = set()
     if manually_specified_reviewers is None:
       manually_specified_reviewers = []
 
     change = self.mox.CreateMock(presubmit.Change)
     change.issue = issue
     change.author_email = 'john@example.com'
     change.R = ','.join(manually_specified_reviewers)
     change.TBR = ''
     affected_file = self.mox.CreateMock(presubmit.SvnAffectedFile)
     input_api = self.MockInputApi(change, False)
+    if gerrit_response:
+      assert not rietveld_response
+      input_api.rietveld = None
+      input_api.gerrit = presubmit.GerritAccessor('host')
+
     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.tbr = tbr
     input_api.dry_run = dry_run
 
     if not is_committing or (not tbr and issue):
       if not dry_run:
         affected_file.LocalPath().AndReturn('foo/xyz.cc')
         change.AffectedFiles(file_filter=None).AndReturn([affected_file])
-      if issue and not rietveld_response:
+      if issue and not rietveld_response and not gerrit_response:
         rietveld_response = {
           "owner_email": change.author_email,
           "messages": [
             {"sender": a, "text": "I approve", "approval": True}
             for a in approvers
           ],
           "reviewers": reviewers
         }
 
       if is_committing:
         people = approvers
       else:
         people = reviewers
 
       if not dry_run:
         if issue:
-          input_api.rietveld.get_issue_properties(
-              issue=int(input_api.change.issue), messages=True).AndReturn(
-                  rietveld_response)
+          if rietveld_response:
+            input_api.rietveld.get_issue_properties(
+                issue=int(input_api.change.issue), messages=True).AndReturn(
+                    rietveld_response)
+          elif gerrit_response:
+            input_api.gerrit._FetchChangeDetail = lambda _: gerrit_response
 
         people.add(change.author_email)
         fake_db.files_not_covered_by(set(['foo/xyz.cc']),
             people).AndReturn(uncovered_files)
         if not is_committing and uncovered_files:
           fake_db.reviewers_for(set(['foo']),
               change.author_email).AndReturn(change.author_email)
 
     self.mox.ReplayAll()
     output = presubmit.PresubmitOutput()
@@ skipping 12 matching lines @@
         dry_run=True,
         rietveld_response=response,
         reviewers=set(["ben@example.com"]),
         expected_output='This is a dry run, skipping OWNERS check\n')
 
     self.AssertOwnersWorks(approvers=set(['ben@example.com']),
         is_committing=False,
         rietveld_response=response,
         expected_output='')
 
+  def testCannedCheckOwners_Approved_Gerrit(self):
+    response = {
+      "owner": {"email": "john@example.com"},
+      "labels": {"Code-Review": {
+        u'all': [
+          {
+            u'email': u'john@example.com',  # self +1 :)
+            u'value': 1
+          },
+          {
+            u'email': u'ben@example.com',
+            u'value': 2
+          },
+        ],
+        u'approved': {u'email': u'ben@example.org'},
+        u'default_value': 0,
+        u'values': {u' 0': u'No score',
+                    u'+1': u'Looks good to me, but someone else must approve',
+                    u'+2': u'Looks good to me, approved',
+                    u'-1': u"I would prefer that you didn't submit this",
+                    u'-2': u'Do not submit'}
+      }},
+    }
+    self.AssertOwnersWorks(approvers=set(['ben@example.com']),
+        gerrit_response=response,
+        is_committing=True,
+        expected_output='')
+
+    self.AssertOwnersWorks(approvers=set(['ben@example.com']),
+        is_committing=False,
+        gerrit_response=response,
+        expected_output='')
+
   def testCannedCheckOwners_Approved(self):
     response = {
       "owner_email": "john@example.com",
       "messages": [
         {
           "sender": "ben@example.com", "text": "foo", "approval": True,
         },
       ],
       "reviewers": ["ben@example.com"],
     }
@@ skipping 226 matching lines @@
         owners_check=False)
     self.assertEqual(2, len(results))
     self.assertEqual(
         'Found line ending with white spaces in:', results[0]._message)
     self.checkstdout('')
 
 
 if __name__ == '__main__':
   import unittest
   unittest.main()