Add a way to require approval from owners other than the author.

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 logging
@@ skipping 2201 matching lines @@
     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,
-      uncovered_files=None, expected_output=''):
+      uncovered_files=None, expected_output='', author_counts_as_owner=True):
     if approvers is None:
+      # The set of people who lgtm'ed a change.
       approvers = set()
     if reviewers is None:
-      reviewers = set()
-    reviewers = reviewers.union(approvers)
+      # 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()
 
     change = self.mox.CreateMock(presubmit.Change)
     change.issue = issue
     affected_file = self.mox.CreateMock(presubmit.SvnAffectedFile)
     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
@@ skipping 18 matching lines @@
         people = approvers
       else:
         people = reviewers
 
       if issue:
         input_api.rietveld.get_issue_properties(
             issue=int(input_api.change.issue), messages=True).AndReturn(
                 rietveld_response)
         people.add(owner_email)
 
-      fake_db.files_not_covered_by(set(['foo/xyz.cc']),
-          people).AndReturn(uncovered_files)
+      if author_counts_as_owner:
+        fake_db.files_not_covered_by(set(['foo/xyz.cc']),
+            people).AndReturn(uncovered_files)
+      else:
+        fake_db.files_not_covered_by(set(['foo/xyz.cc']),
+            people.difference(set([owner_email]))).AndReturn(uncovered_files)
       if not is_committing and uncovered_files:
-        fake_db.reviewers_for(set(['foo/xyz.cc'])).AndReturn(owner_email)
+        fake_db.reviewers_for(set(['foo/xyz.cc']),
+            owner_email if issue else '').AndReturn(owner_email)
 
     self.mox.ReplayAll()
     output = presubmit.PresubmitOutput()
     results = presubmit_canned_checks.CheckOwners(input_api,
-        presubmit.OutputApi)
+        presubmit.OutputApi, author_counts_as_owner=author_counts_as_owner)
     if results:
       results[0].handle(output)
     self.assertEquals(output.getvalue(), expected_output)
 
   def testCannedCheckOwners_Approved(self):
     response = {
       "owner_email": "john@example.com",
       "messages": [
         {
           "sender": "ben@example.com", "text": "foo", "approval": True,
@@ skipping 84 matching lines @@
     self.AssertOwnersWorks(is_committing=False, expected_output='')
 
   def testCannedCheckOwners_OnlyOwnerLGTM(self):
     self.AssertOwnersWorks(approvers=set(['john@example.com']),
                            expected_output='Missing LGTM from someone '
                                            'other than john@example.com\n')
     self.AssertOwnersWorks(approvers=set(['john@example.com']),
                            is_committing=False,
                            expected_output='')
 
+  def testCannedCheckOwners_AuthorCountsAsOwner(self):
+    self.AssertOwnersWorks(approvers=set(['john@example.com',
+                                          'brett@example.com']),
+                           reviewers=set(['john@example.com',
+                                          'ben@example.com']),
+                           uncovered_files=set(['foo/xyz.cc']),
+                           expected_output='Missing LGTM from an OWNER '
+                                           'for these files:\n    foo/xyz.cc\n',
+                           author_counts_as_owner=False)
+
   def testCannedCheckOwners_TBR(self):
     self.AssertOwnersWorks(tbr=True,
         expected_output='--tbr was specified, skipping OWNERS check\n')
     self.AssertOwnersWorks(tbr=True, is_committing=False, expected_output='')
 
   def testCannedCheckOwners_WithoutOwnerLGTM(self):
     self.AssertOwnersWorks(uncovered_files=set(['foo']),
         expected_output='Missing LGTM from an OWNER for these files:\n'
                         '    foo\n')
     self.AssertOwnersWorks(uncovered_files=set(['foo']),
@@ skipping 98 matching lines @@
         owners_check=False)
     self.assertEqual(1, len(results))
     self.assertEqual(
         'Found line ending with white spaces in:', results[0]._message)
     self.checkstdout('')
 
 
 if __name__ == '__main__':
   import unittest
   unittest.main()