Make prepare() accept a revision argument.

tests/checkout_test.py

 #!/usr/bin/env python
 # Copyright (c) 2011 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 checkout.py."""
 
 from __future__ import with_statement
 import logging
 import os
@@ skipping 163 matching lines @@
       tree['new_dir/subdir/new_file'] = 'A new file\nshould exist.\n'
     return tree
 
   def _check_base(self, co, root, git, expected):
     read_only = isinstance(co, checkout.ReadOnlyCheckout)
     assert not read_only == bool(expected)
     if not read_only:
       self.FAKE_REPOS.svn_dirty = True
 
     self.assertEquals(root, co.project_path)
-    self.assertEquals(self.previous_log['revision'], co.prepare())
+    self.assertEquals(self.previous_log['revision'], co.prepare(None))
     self.assertEquals('pouet', co.get_settings('bar'))
     self.assertTree(self.get_trunk(False), root)
     patches = self.get_patches()
     co.apply_patch(patches)
     self.assertEquals(
         ['bin_file', 'extra', 'new_dir/subdir/new_file', 'svn_utils_test.txt'],
         sorted(patches.filenames))
 
     if git:
       # Hackish to verify _branches() internal function.
       # pylint: disable=W0212
       self.assertEquals(
           (['master', 'working_branch'], 'working_branch'),
           co.checkout._branches())
 
     # Verify that the patch is applied even for read only checkout.
     self.assertTree(self.get_trunk(True), root)
     fake_author = self.FAKE_REPOS.USERS[1][0]
     revision = co.commit(u'msg', fake_author)
     # Nothing changed.
     self.assertTree(self.get_trunk(True), root)
 
     if read_only:
       self.assertEquals('FAKE', revision)
-      self.assertEquals(self.previous_log['revision'], co.prepare())
+      self.assertEquals(self.previous_log['revision'], co.prepare(None))
       # Changes should be reverted now.
       self.assertTree(self.get_trunk(False), root)
       expected = self.previous_log
     else:
       self.assertEquals(self.previous_log['revision'] + 1, revision)
-      self.assertEquals(self.previous_log['revision'] + 1, co.prepare())
+      self.assertEquals(self.previous_log['revision'] + 1, co.prepare(None))
       self.assertTree(self.get_trunk(True), root)
       expected = expected.copy()
       expected['msg'] = 'msg'
       expected['revision'] = self.previous_log['revision'] + 1
       expected.setdefault('author', fake_author)
 
     actual = self._log()
     self.assertEquals(expected, actual)
 
   def _check_exception(self, co, err_msg):
-    co.prepare()
+    co.prepare(None)
     try:
       co.apply_patch([patch.FilePatchDiff('svn_utils_test.txt', BAD_PATCH, [])])
       self.fail()
     except checkout.PatchApplicationFailed, e:
       self.assertEquals(e.filename, 'svn_utils_test.txt')
       self.assertEquals(e.status, err_msg)
 
   def _log(self):
     raise NotImplementedError()
 
   def _test_process(self, co):
     """Makes sure the process lambda is called correctly."""
     co.post_processors = [lambda *args: results.append(args)]
-    co.prepare()
+    co.prepare(None)
     ps = self.get_patches()
     results = []
     co.apply_patch(ps)
     expected = [(co, p) for p in ps.patches]
     self.assertEquals(expected, results)
 
 
 class SvnBaseTest(BaseTest):
   def setUp(self):
     super(SvnBaseTest, self).setUp()
@@ skipping 23 matching lines @@
         data[name] = item.text
     set_item('author')
     set_item('msg')
     revprops = logentry.find('revprops')
     if revprops != None:
       data['revprops'] = []
       for prop in revprops.getiterator('property'):
         data['revprops'].append((prop.attrib['name'], prop.text))
     return data
 
+  def _test_prepare(self, co):
+    self.assertEquals(1, co.prepare(1))
+
 
 class SvnCheckout(SvnBaseTest):
   def _get_co(self, read_only):
     if read_only:
       return checkout.ReadOnlyCheckout(
           checkout.SvnCheckout(
               self.root_dir, self.name, None, None, self.svn_url))
     else:
       return checkout.SvnCheckout(
           self.root_dir, self.name, self.usr, self.pwd, self.svn_url)
@@ skipping 16 matching lines @@
     self._check_exception(
         self._get_co(True),
         'While running patch -p1 --forward --force;\n'
         'patching file svn_utils_test.txt\n'
         'Hunk #1 FAILED at 3.\n'
         '1 out of 1 hunk FAILED -- saving rejects to file '
         'svn_utils_test.txt.rej\n')
 
   def testSvnProps(self):
     co = self._get_co(False)
-    co.prepare()
+    co.prepare(None)
     try:
       # svn:ignore can only be applied to directories.
       svn_props = [('svn:ignore', 'foo')]
       co.apply_patch(
           [patch.FilePatchDiff('svn_utils_test.txt', NAKED_PATCH, svn_props)])
       self.fail()
     except checkout.PatchApplicationFailed, e:
       self.assertEquals(e.filename, 'svn_utils_test.txt')
       self.assertEquals(
           e.status,
           'While running svn propset svn:ignore foo svn_utils_test.txt '
           '--non-interactive;\n'
           'patching file svn_utils_test.txt\n'
           'svn: Cannot set \'svn:ignore\' on a file (\'svn_utils_test.txt\')\n')
-    co.prepare()
+    co.prepare(None)
     svn_props = [('svn:eol-style', 'LF'), ('foo', 'bar')]
     co.apply_patch(
         [patch.FilePatchDiff('svn_utils_test.txt', NAKED_PATCH, svn_props)])
     filepath = os.path.join(self.root_dir, self.name, 'svn_utils_test.txt')
     # Manually verify the properties.
     props = subprocess2.check_output(
         ['svn', 'proplist', filepath],
         cwd=self.root_dir).splitlines()[1:]
     props = sorted(p.strip() for p in props)
     expected_props = dict(svn_props)
@@ skipping 26 matching lines @@
     root = os.path.join(self.root_dir, self.name)
     expected = {
         'author': self.FAKE_REPOS.USERS[1][0],
     }
     self._check_base(co, root, False, expected)
 
   def testAutoProps(self):
     co = self._get_co(False)
     co.svn_config = checkout.SvnConfig(
         os.path.join(ROOT_DIR, 'subversion_config'))
-    co.prepare()
+    co.prepare(None)
     patches = self.get_patches()
     co.apply_patch(patches)
     self.assertEquals(
         ['bin_file', 'extra', 'new_dir/subdir/new_file', 'svn_utils_test.txt'],
         sorted(patches.filenames))
     # *.txt = svn:eol-style=LF in subversion_config/config.
     out = subprocess2.check_output(
         ['svn', 'pget', 'svn:eol-style', 'svn_utils_test.txt'],
         cwd=co.project_path)
     self.assertEquals('LF\n', out)
 
   def testProcess(self):
     co = checkout.SvnCheckout(
         self.root_dir, self.name,
         None, None,
         self.svn_url)
     self._test_process(co)
 
+  def testPrepare(self):
+    co = checkout.SvnCheckout(
+        self.root_dir, self.name,
+        None, None,
+        self.svn_url)
+    self._test_prepare(co)
+
 
 class GitSvnCheckout(SvnBaseTest):
   name = 'foo.git'
 
   def _get_co(self, read_only):
     co = checkout.GitSvnCheckout(
         self.root_dir, self.name[:-4],
         self.usr, self.pwd,
         self.svn_base, self.svn_trunk)
     if read_only:
@@ skipping 12 matching lines @@
 
   def testAllRW(self):
     expected = {
         'author': self.FAKE_REPOS.USERS[0][0],
     }
     self._check(False, expected)
 
   def testGitSvnPremade(self):
     # Test premade git-svn clone. First make a git-svn clone.
     git_svn_co = self._get_co(True)
-    revision = git_svn_co.prepare()
+    revision = git_svn_co.prepare(None)
     self.assertEquals(self.previous_log['revision'], revision)
     # Then use GitSvnClone to clone it to lose the git-svn connection and verify
     # git svn init / git svn fetch works.
     git_svn_clone = checkout.GitSvnPremadeCheckout(
         self.root_dir, self.name[:-4] + '2', 'trunk',
         self.usr, self.pwd,
         self.svn_base, self.svn_trunk, git_svn_co.project_path)
-    self.assertEquals(self.previous_log['revision'], git_svn_clone.prepare())
+    self.assertEquals(
+        self.previous_log['revision'], git_svn_clone.prepare(None))
 
   def testException(self):
     self._check_exception(
         self._get_co(True), 'fatal: corrupt patch at line 12\n')
 
   def testSvnProps(self):
     co = self._get_co(False)
-    co.prepare()
+    co.prepare(None)
     try:
       svn_props = [('foo', 'bar')]
       co.apply_patch(
           [patch.FilePatchDiff('svn_utils_test.txt', NAKED_PATCH, svn_props)])
       self.fail()
     except patch.UnsupportedPatchFormat, e:
       self.assertEquals(e.filename, 'svn_utils_test.txt')
       self.assertEquals(
           e.status,
           'Cannot apply svn property foo to file svn_utils_test.txt.')
-    co.prepare()
+    co.prepare(None)
     # svn:eol-style is ignored.
     svn_props = [('svn:eol-style', 'LF')]
     co.apply_patch(
         [patch.FilePatchDiff('svn_utils_test.txt', NAKED_PATCH, svn_props)])
 
   def testProcess(self):
     co = checkout.SvnCheckout(
         self.root_dir, self.name,
         None, None,
         self.svn_url)
     self._test_process(co)
 
+  def testPrepare(self):
+    co = checkout.SvnCheckout(
+        self.root_dir, self.name,
+        None, None,
+        self.svn_url)
+    self._test_prepare(co)
+
 
 class RawCheckout(SvnBaseTest):
   def setUp(self):
     super(RawCheckout, self).setUp()
     # Use a svn checkout as the base.
     self.base_co = checkout.SvnCheckout(
         self.root_dir, self.name, None, None, self.svn_url)
-    self.base_co.prepare()
+    self.base_co.prepare(None)
 
   def _get_co(self, read_only):
     co = checkout.RawCheckout(self.root_dir, self.name, None)
     if read_only:
       return checkout.ReadOnlyCheckout(co)
     return co
 
   def _check(self, read_only):
     root = os.path.join(self.root_dir, self.name)
     co = self._get_co(read_only)
 
     # A copy of BaseTest._check_base()
     self.assertEquals(root, co.project_path)
-    self.assertEquals(None, co.prepare())
+    self.assertEquals(None, co.prepare(None))
     self.assertEquals('pouet', co.get_settings('bar'))
     self.assertTree(self.get_trunk(False), root)
     patches = self.get_patches()
     co.apply_patch(patches)
     self.assertEquals(
         ['bin_file', 'extra', 'new_dir/subdir/new_file', 'svn_utils_test.txt'],
         sorted(patches.filenames))
 
     # Verify that the patch is applied even for read only checkout.
     self.assertTree(self.get_trunk(True), root)
     if read_only:
       revision = co.commit(u'msg', self.FAKE_REPOS.USERS[1][0])
       self.assertEquals('FAKE', revision)
     else:
       try:
         co.commit(u'msg', self.FAKE_REPOS.USERS[1][0])
         self.fail()
       except NotImplementedError:
         pass
     self.assertTree(self.get_trunk(True), root)
     # Verify that prepare() is a no-op.
-    self.assertEquals(None, co.prepare())
+    self.assertEquals(None, co.prepare(None))
     self.assertTree(self.get_trunk(True), root)
 
   def testAllRW(self):
     self._check(False)
 
   def testAllRO(self):
     self._check(True)
 
   def testException(self):
     self._check_exception(
         self._get_co(True),
         'patching file svn_utils_test.txt\n'
         'Hunk #1 FAILED at 3.\n'
         '1 out of 1 hunk FAILED -- saving rejects to file '
         'svn_utils_test.txt.rej\n')
 
   def testProcess(self):
     co = checkout.SvnCheckout(
         self.root_dir, self.name,
         None, None,
         self.svn_url)
     self._test_process(co)
 
+  def testPrepare(self):
+    co = checkout.SvnCheckout(
+        self.root_dir, self.name,
+        None, None,
+        self.svn_url)
+    self._test_prepare(co)
+
 
 if __name__ == '__main__':
   if '-v' in sys.argv:
     DEBUGGING = True
     logging.basicConfig(
         level=logging.DEBUG,
         format='%(levelname)5s %(filename)15s(%(lineno)3d): %(message)s')
   else:
     logging.basicConfig(
         level=logging.ERROR,
         format='%(levelname)5s %(filename)15s(%(lineno)3d): %(message)s')
   unittest.main()