Use author as determined from scm if we can not get it from rietveld

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 2215 matching lines @@
     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()
 
     change = self.mox.CreateMock(presubmit.Change)
     change.issue = issue
+    change.author_email = 'john@example.com'
     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
     input_api.is_committing = is_committing
     input_api.tbr = tbr
 
     if not is_committing or (not tbr and issue):
       affected_file.LocalPath().AndReturn('foo/xyz.cc')
       change.AffectedFiles(file_filter=None).AndReturn([affected_file])
-      owner_email = 'john@example.com'
       if not rietveld_response:
         rietveld_response = {
-          "owner_email": owner_email,
+          "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 issue:
         input_api.rietveld.get_issue_properties(
             issue=int(input_api.change.issue), messages=True).AndReturn(
                 rietveld_response)
-        people.add(owner_email)
 
       if author_counts_as_owner:
+        people.add(change.author_email)
         fake_db.files_not_covered_by(set(['foo/xyz.cc']),
             people).AndReturn(uncovered_files)
       else:
+        people.discard(change.author_email)
         fake_db.files_not_covered_by(set(['foo/xyz.cc']),
-            people.difference(set([owner_email]))).AndReturn(uncovered_files)
+            people).AndReturn(uncovered_files)
       if not is_committing and uncovered_files:
         fake_db.reviewers_for(set(['foo/xyz.cc']),
-            owner_email if issue else '').AndReturn(owner_email)
+            change.author_email).AndReturn(change.author_email)
 
     self.mox.ReplayAll()
     output = presubmit.PresubmitOutput()
     results = presubmit_canned_checks.CheckOwners(input_api,
         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):
@@ skipping 72 matching lines @@
 
   def testCannedCheckOwners_NoIssue(self):
     self.AssertOwnersWorks(issue=None,
         uncovered_files=set(['foo']),
         expected_output="OWNERS check failed: this change has no Rietveld "
                         "issue number, so we can't check it for approvals.\n")
     self.AssertOwnersWorks(issue=None,
         is_committing=False,
         uncovered_files=set(['foo']),
         expected_output='Missing OWNER reviewers for these files:\n'
-                        '    foo\n'
-                        'Until the issue is uploaded, this list will include '
-                        'files for which you are an OWNER.\n')
+                        '    foo\n')
 
   def testCannedCheckOwners_NoLGTM(self):
     self.AssertOwnersWorks(expected_output='Missing LGTM from someone '
                                            'other than john@example.com\n')
     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')
@@ skipping 122 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()