Share more data between checkout_test and patches_data.

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
 import shutil
 import sys
 import unittest
 from xml.etree import ElementTree
 
 ROOT_DIR = os.path.dirname(os.path.abspath(__file__))
 BASE_DIR = os.path.join(ROOT_DIR, '..')
 sys.path.insert(0, BASE_DIR)
 
 import checkout
 import patch
 import subprocess2
 from tests import fake_repos
+from tests.patches_data import GIT, RAW
 
 
 # pass -v to enable it.
 DEBUGGING = False
 
-# A naked patch.
-NAKED_PATCH = ("""\
---- svn_utils_test.txt
-+++ svn_utils_test.txt
-@@ -3,6 +3,7 @@ bb
- ccc
- dd
- e
-+FOO!
- ff
- ggg
- hh
-""")
-
-# A patch generated from git.
-GIT_PATCH = ("""\
-diff --git a/svn_utils_test.txt b/svn_utils_test.txt
-index 0e4de76..8320059 100644
---- a/svn_utils_test.txt
-+++ b/svn_utils_test.txt
-@@ -3,6 +3,7 @@ bb
- ccc
- dd
- e
-+FOO!
- ff
- ggg
- hh
-""")
-
 # A patch that will fail to apply.
-BAD_PATCH = ("""\
-diff --git a/svn_utils_test.txt b/svn_utils_test.txt
-index 0e4de76..8320059 100644
---- a/svn_utils_test.txt
-+++ b/svn_utils_test.txt
-@@ -3,7 +3,8 @@ bb
- ccc
- dd
-+FOO!
- ff
- ggg
- hh
-""")
-
-PATCH_ADD = ("""\
-diff --git a/new_dir/subdir/new_file b/new_dir/subdir/new_file
-new file mode 100644
---- /dev/null
-+++ b/new_dir/subdir/new_file
-@@ -0,0 +1,2 @@
-+A new file
-+should exist.
-""")
+BAD_PATCH = ''.join(
+    [l for l in GIT.PATCH.splitlines(True) if l.strip() != 'e'])
 
 
 class FakeRepos(fake_repos.FakeReposBase):
   def populateSvn(self):
     """Creates a few revisions of changes files."""
     subprocess2.check_call(
         ['svn', 'checkout', self.svn_base, self.svn_checkout, '-q',
          '--non-interactive', '--no-auth-cache',
          '--username', self.USERS[0][0], '--password', self.USERS[0][1]])
     assert os.path.isdir(os.path.join(self.svn_checkout, '.svn'))
     fs = {}
     fs['trunk/origin'] = 'svn@1'
     fs['trunk/codereview.settings'] = (
         '# Test data\n'
         'bar: pouet\n')
-    fs['trunk/svn_utils_test.txt'] = (
+    fs['trunk/chrome/file.cc'] = (
         'a\n'
         'bb\n'
         'ccc\n'
         'dd\n'
         'e\n'
         'ff\n'
         'ggg\n'
         'hh\n'
         'i\n'
         'jj\n'
@@ skipping 33 matching lines @@
     subprocess2.call = redirect_call
     self.usr, self.pwd = self.FAKE_REPOS.USERS[0]
     self.previous_log = None
 
   def tearDown(self):
     subprocess2.call = self._old_call
     super(BaseTest, self).tearDown()
 
   def get_patches(self):
     return patch.PatchSet([
-        patch.FilePatchDiff(
-            'svn_utils_test.txt', GIT_PATCH, []),
         # TODO(maruel): Test with is_new == False.
         patch.FilePatchBinary('bin_file', '\x00', [], is_new=True),
+        patch.FilePatchDiff(
+            'chrome/file.cc', GIT.PATCH, []),
+        patch.FilePatchDiff('new_dir/subdir/new_file', GIT.NEW_SUBDIR, []),
         patch.FilePatchDelete('extra', False),
-        patch.FilePatchDiff('new_dir/subdir/new_file', PATCH_ADD, []),
     ])
 
   def get_trunk(self, modified):
     tree = {}
     subroot = 'trunk/'
     for k, v in self.FAKE_REPOS.svn_revs[-1].iteritems():
       if k.startswith(subroot):
         f = k[len(subroot):]
         assert f not in tree
         tree[f] = v
 
     if modified:
-      content_lines = tree['svn_utils_test.txt'].splitlines(True)
-      tree['svn_utils_test.txt'] = ''.join(
+      content_lines = tree['chrome/file.cc'].splitlines(True)
+      tree['chrome/file.cc'] = ''.join(
           content_lines[0:5] + ['FOO!\n'] + content_lines[5:])
       del tree['extra']
       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(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))
+        ['bin_file', 'chrome/file.cc', 'new_dir/subdir/new_file', 'extra'],
+        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)
@@ skipping 16 matching lines @@
       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(None)
     try:
-      co.apply_patch([patch.FilePatchDiff('svn_utils_test.txt', BAD_PATCH, [])])
+      co.apply_patch([patch.FilePatchDiff('chrome/file.cc', BAD_PATCH, [])])
       self.fail()
     except checkout.PatchApplicationFailed, e:
-      self.assertEquals(e.filename, 'svn_utils_test.txt')
+      self.assertEquals(e.filename, 'chrome/file.cc')
       self.assertEquals(e.status, err_msg)
 
   def _log(self):
     raise NotImplementedError()
 
   def _test_process(self, co_lambda):
     """Makes sure the process lambda is called correctly."""
     post_processors = [lambda *args: results.append(args)]
     co = co_lambda(post_processors)
     self.assertEquals(post_processors, co.post_processors)
@@ skipping 66 matching lines @@
     }
     self._check(False, expected)
 
   def testAllRO(self):
     self._check(True, None)
 
   def testException(self):
     self._check_exception(
         self._get_co(True),
         'While running patch -p1 --forward --force;\n'
-        'patching file svn_utils_test.txt\n'
+        'patching file chrome/file.cc\n'
         'Hunk #1 FAILED at 3.\n'
         '1 out of 1 hunk FAILED -- saving rejects to file '
-        'svn_utils_test.txt.rej\n')
+        'chrome/file.cc.rej\n')
 
   def testSvnProps(self):
     co = self._get_co(False)
     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)])
+          [patch.FilePatchDiff('chrome/file.cc', RAW.PATCH, svn_props)])
       self.fail()
     except checkout.PatchApplicationFailed, e:
-      self.assertEquals(e.filename, 'svn_utils_test.txt')
+      self.assertEquals(e.filename, 'chrome/file.cc')
       self.assertEquals(
           e.status,
-          'While running svn propset svn:ignore foo svn_utils_test.txt '
+          'While running svn propset svn:ignore foo chrome/file.cc '
           '--non-interactive;\n'
-          'patching file svn_utils_test.txt\n'
-          'svn: Cannot set \'svn:ignore\' on a file (\'svn_utils_test.txt\')\n')
+          'patching file chrome/file.cc\n'
+          'svn: Cannot set \'svn:ignore\' on a file (\'chrome/file.cc\')\n')
     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')
+        [patch.FilePatchDiff('chrome/file.cc', RAW.PATCH, svn_props)])
+    filepath = os.path.join(self.root_dir, self.name, 'chrome/file.cc')
     # 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)
     self.assertEquals(sorted(expected_props.iterkeys()), props)
     for k, v in expected_props.iteritems():
       value = subprocess2.check_output(
         ['svn', 'propget', '--strict', k, filepath],
@@ skipping 26 matching lines @@
     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(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))
+        ['bin_file', 'chrome/file.cc', 'new_dir/subdir/new_file', 'extra'],
+        patches.filenames)
     # *.txt = svn:eol-style=LF in subversion_config/config.
     out = subprocess2.check_output(
-        ['svn', 'pget', 'svn:eol-style', 'svn_utils_test.txt'],
+        ['svn', 'pget', 'svn:eol-style', 'chrome/file.cc'],
         cwd=co.project_path)
     self.assertEquals('LF\n', out)
 
   def testProcess(self):
     co = lambda x: checkout.SvnCheckout(
         self.root_dir, self.name,
         None, None,
         self.svn_url,
         x)
     self._test_process(co)
@@ skipping 51 matching lines @@
   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(None)
     try:
       svn_props = [('foo', 'bar')]
       co.apply_patch(
-          [patch.FilePatchDiff('svn_utils_test.txt', NAKED_PATCH, svn_props)])
+          [patch.FilePatchDiff('chrome/file.cc', RAW.PATCH, svn_props)])
       self.fail()
     except patch.UnsupportedPatchFormat, e:
-      self.assertEquals(e.filename, 'svn_utils_test.txt')
+      self.assertEquals(e.filename, 'chrome/file.cc')
       self.assertEquals(
           e.status,
-          'Cannot apply svn property foo to file svn_utils_test.txt.')
+          'Cannot apply svn property foo to file chrome/file.cc.')
     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)])
+        [patch.FilePatchDiff('chrome/file.cc', RAW.PATCH, svn_props)])
 
   def testProcess(self):
     co = lambda x: checkout.SvnCheckout(
         self.root_dir, self.name,
         None, None,
         self.svn_url, x)
     self._test_process(co)
 
   def testPrepare(self):
     co = checkout.SvnCheckout(
@@ skipping 22 matching lines @@
     co = self._get_co(read_only)
 
     # A copy of BaseTest._check_base()
     self.assertEquals(root, co.project_path)
     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))
+        ['bin_file', 'chrome/file.cc', 'new_dir/subdir/new_file', 'extra'],
+        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(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'
+        'patching file chrome/file.cc\n'
         'Hunk #1 FAILED at 3.\n'
         '1 out of 1 hunk FAILED -- saving rejects to file '
-        'svn_utils_test.txt.rej\n')
+        'chrome/file.cc.rej\n')
 
   def testProcess(self):
     co = lambda x: checkout.SvnCheckout(
         self.root_dir, self.name,
         None, None,
         self.svn_url, x)
     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()