Infer CL author and reviewer list from local state if the issue has not previously been uploaded.

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 functools
@@ skipping 1750 matching lines @@
     self.assertEquals(1, len(output))
     self.assertEquals(files[0], output[0])
 
 
 class ChangeUnittest(PresubmitTestsBase):
   def testMembersChanged(self):
     members = [
         'AbsoluteLocalPaths', 'AffectedFiles', 'AffectedTextFiles',
         'DescriptionText', 'FullDescriptionText', 'LocalPaths', 'Name',
         'RepositoryRoot', 'RightHandSideLines', 'ServerPaths',
-        'TAG_LINE_RE',
+        'SetDescriptionText', 'TAG_LINE_RE',
         'author_email', 'issue', 'patchset', 'scm', 'tags',
     ]
     # If this test fails, you should add the relevant test.
     self.mox.ReplayAll()
 
     change = presubmit.Change(
         'foo', 'foo', self.fake_root_dir, [('M', 'AA')], 0, 0, 'foo')
     self.compareMembers(change, members)
 
   def testMembers(self):
     change = presubmit.Change(
         'foo1', 'foo2\nDRU=ro', self.fake_root_dir, [('Y', 'AA')], 3, 5, 'foo3')
     self.assertEquals('foo1', change.Name())
     self.assertEquals('foo2', change.DescriptionText())
     self.assertEquals('foo3', change.author_email)
     self.assertEquals('ro', change.DRU)
     self.assertEquals(3, change.issue)
     self.assertEquals(5, change.patchset)
     self.assertEquals(self.fake_root_dir, change.RepositoryRoot())
     self.assertEquals(1, len(change.AffectedFiles(include_dirs=True)))
     self.assertEquals('Y', change.AffectedFiles(include_dirs=True)[0].Action())
 
+  def testSetDescriptionText(self):
+    change = presubmit.Change(
+        '', 'foo\nDRU=ro', self.fake_root_dir, [], 3, 5, '')
+    self.assertEquals('foo', change.DescriptionText())
+    self.assertEquals('foo\nDRU=ro', change.FullDescriptionText())
+    self.assertEquals('ro', change.DRU)
+
+    change.SetDescriptionText('bar\nWHIZ=bang')
+    self.assertEquals('bar', change.DescriptionText())
+    self.assertEquals('bar\nWHIZ=bang', change.FullDescriptionText())
+    self.assertEquals('bang', change.WHIZ)
+    self.assertFalse(change.DRU)
+
 
 def CommHelper(input_api, cmd, ret=None, **kwargs):
   ret = ret or (('', None), 0)
   input_api.subprocess.communicate(
       cmd, stdout=subprocess.PIPE, stderr=subprocess.STDOUT, **kwargs
       ).AndReturn(ret)
 
 
 class CannedChecksUnittest(PresubmitTestsBase):
   """Tests presubmit_canned_checks.py."""
@@ skipping 763 matching lines @@
       # 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'
+    change.R = ''
+    change.TBR = ''
     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])
-      if not rietveld_response:
+      if issue and not rietveld_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
+        change.R = ','.join(reviewers)
 
       if issue:
         input_api.rietveld.get_issue_properties(
             issue=int(input_api.change.issue), messages=True).AndReturn(
                 rietveld_response)
 
       if author_counts_as_owner:
         people.add(change.author_email)
         fake_db.files_not_covered_by(set(['foo/xyz.cc']),
             people).AndReturn(uncovered_files)
@@ skipping 91 matching lines @@
     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')
 
+  def testCannedCheckOwners_NoIssueLocalReviewers(self):
+    self.AssertOwnersWorks(issue=None,
+        reviewers=set(['jane@example.com']),
+        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,
+        reviewers=set(['jane@example.com']),
+        is_committing=False,
+        expected_output='')
+
   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')
     self.AssertOwnersWorks(approvers=set(['john@example.com']),
@@ skipping 124 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()