Add post_processing code to update copyright year automatically.

tests/pending_manager_test.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 pending_manager.py."""
 
 import logging
 import os
 import re
@@ skipping 84 matching lines @@
           {
             "date": "2010-12-27 03:23:32.489999",
             "text": "hi!",
             "sender": "author@example.com",
             "recipients": ["rev@example.com", "cc@example.com"],
           },
         ],
         "commit": True,
       },
     }
+    self.patchsets = []
 
   def get_pending_issues(self):
     return self.issues.keys()
 
   def get_issue_properties(self, issue_id, _):
     return self.issues[issue_id]
 
   def close_issue(self, issue):
     pass
 
   def update_description(self, issue, text):
     pass
 
   def set_flag(self, issue, patchset, flag, value):
     pass
 
   def add_comment(self, issue, text):
     pass
 
   def get_patch(self, issue, patchset):
-    return patch.PatchSet([
+    self.patchsets.append(patch.PatchSet([
         patch.FilePatchDiff('chrome/file.cc', SVN_PATCH, []),
         patch.FilePatchDelete('other/place/foo', True),
         patch.FilePatchBinary('foo', 'data', []),
-    ])
+    ]))
+    return self.patchsets[-1]
 
 
 class FakeCheckout(object):
   project_path = os.getcwd()
 
   def __init__(self):
     self._prepare = 0
     self._commit = []
     self._apply_patch = []
 
   def prepare(self):
     self._prepare += 1
 
-  def apply_patch(self, patchset):
-    self._apply_patch.append(patchset)
+  def apply_patch(self, *args):
+    self._apply_patch.append(args)
 
-  def commit(self, message, author):
-    self._commit.append((message, author))
+  def commit(self, *args):
+    self._commit.append(args)
 
   def get_settings(self, key):
     return None
 
 
-class PendingManager(unittest.TestCase):
+class TestPendingManager(unittest.TestCase):
   def setUp(self):
-    super(PendingManager, self).setUp()
+    super(TestPendingManager, self).setUp()
     self.root_dir = ROOT_DIR
     self._old_send_stack = pending_manager.breakpad.SendStack
     pending_manager.breakpad.SendStack = _SendStackFail
 
   def tearDown(self):
     pending_manager.breakpad.SendStack = self._old_send_stack
-    super(PendingManager, self).tearDown()
+    super(TestPendingManager, self).tearDown()
 
   def testLoadSave(self):
     pc = pending_manager.PendingManager(
-        None, None, [fake.FakeVerifier(base.SUCCEEDED)], [])
+        None, None, [fake.FakeVerifier(base.SUCCEEDED)], [], [])
     filename = os.path.join(self.root_dir, 'foo.json')
     empty = """{
   "__persistent_module__": "pending_manager",
   "__persistent_type__": "PendingQueue",
   "pending_commits": []
 }
 """
     write(filename, empty)
     try:
       pc.load(filename)
       self.assertEquals(pc.queue.pending_commits, [])
       pc.save(filename)
       self.assertEquals(trim(empty), trim(read(filename)))
     finally:
       os.remove(filename)
       if os.path.exists(filename + '.old'):
         os.remove(filename + '.old')
 
   def _get_pc(self, verifiers_no_patch, verifiers):
     pc = pending_manager.PendingManager(
-        FakeRietveld(), FakeCheckout(), verifiers_no_patch, verifiers)
+        FakeRietveld(), FakeCheckout(), verifiers_no_patch, verifiers, [])
 
     def apply_patch(pending, revision):
       pc._patch_applied = True
 
     pc._apply_patch = apply_patch
     pc._patch_applied = False
     return pc
 
   def testNoVerification(self):
     try:
       pending_manager.PendingManager(
-          FakeRietveld(), FakeCheckout(), [], [])
+          FakeRietveld(), FakeCheckout(), [], [], [])
       self.fail()
     except AssertionError:
       pass
     try:
       pending_manager.PendingManager(
           FakeRietveld(),
           FakeCheckout(),
           [fake.FakeVerifier(base.SUCCEEDED)],
-          [fake.FakeVerifier(base.SUCCEEDED)])
+          [fake.FakeVerifier(base.SUCCEEDED)],
+          [])
       self.fail()
     except AssertionError:
       pass
 
   def _check_1(self, pc, result):
     self.assertEquals(len(pc.queue.pending_commits), 0)
     pc.look_for_new_pending_commit()
     self.assertEquals(len(pc.queue.pending_commits), 1)
     commit = pc.queue.pending_commits[0]
     self.assertEquals(len(commit.verifications), 0)
@@ skipping 184 matching lines @@
 
   def testDefer4Verification3rdFail(self):
     self._check_defer_4(
         base.SUCCEEDED, base.SUCCEEDED, base.FAILED, base.SUCCEEDED)
 
   def testRelPath(self):
     verifiers = [
         project_base.ProjectBaseUrlVerifier(
           [r'^%s(.*)$' % re.escape(r'http://example.com/')]),
     ]
+    r = FakeRietveld()
+    processors = [object()]
     pc = pending_manager.PendingManager(
-        FakeRietveld(), FakeCheckout(), verifiers, [])
+        r, FakeCheckout(), verifiers, [], processors)
     pc.rietveld.issues[31337]['base_url'] = 'http://example.com/sub/dir'
     pc.look_for_new_pending_commit()
     self.assertEquals(1, len(pc.queue.pending_commits))
     pc.process_new_pending_commit()
     self.assertEquals('sub/dir', pc.queue.pending_commits[0].relpath)
     self.assertEquals(1, pc.checkout._prepare)
-    self.assertEquals(1, len(pc.checkout._apply_patch))
+    self.assertEquals([(r.patchsets[0], processors)], pc.checkout._apply_patch)
     self.assertEquals([], pc.checkout._commit)
     pc.update_status()
     self.assertEquals(1, pc.checkout._prepare)
-    self.assertEquals(1, len(pc.checkout._apply_patch))
+    self.assertEquals([(r.patchsets[0], processors)], pc.checkout._apply_patch)
     self.assertEquals([], pc.checkout._commit)
     patches = pc.checkout._apply_patch[0]
     self.assertEquals(
         ['sub/dir/chrome/file.cc', 'sub/dir/other/place/foo', 'sub/dir/foo'],
-        patches.filenames)
+        patches[0].filenames)
     pc.scan_results()
     self.assertEquals(2, pc.checkout._prepare)
-    self.assertEquals(2, len(pc.checkout._apply_patch))
+    self.assertEquals(
+        [(r.patchsets[0], processors), (r.patchsets[1], processors)],
+        pc.checkout._apply_patch)
     self.assertEquals(
         [('foo\n\nReview URL: http://nowhere/31337', 'author@example.com')],
         pc.checkout._commit)
 
 
 if __name__ == '__main__':
   logging.basicConfig(level=logging.ERROR)
   unittest.main()